25 25 Source: source/ft-app/ft-app-B1.1/hmi/hmi-02.c
25-0 . /*
25-1 . ----------------------------------------------------------------------------
25-2 . --| BEGIN PROLOGUE
25-3 . --|
25-4 . --| CLASSIFICATION: UNCLASSIFIED
25-5 . --|
25-6 . --| FILE NAME: hmi-02.c
25-7 . --|
25-8 . --| ABSTRACT:
25-9 . --| This file contains the 12 functions that do file hmi stuff.
25-10 . --|
25-11 . --| HISTORY:
25-12 . --| CCCQ_NAME:
25-13 . --| CCCQ_VER:
25-14 . --|
25-15 . --| END PROLOGUE
25-16 . ----------------------------------------------------------------------------
25-17 . */
25-18 .
25-19 . #define A;
25-20 . float B;
25-21 .
25-22 .
25-23 .
25-24 . /*
25-25 . -----------------------------------------------------------------------------
25-26 . --| NAME: hmi.2.1
25-27 . --|
25-28 . --| ABSTRACT:
25-29 . --| This function does hmi stuff.
25-30 . --|
25-31 . --| RETURNS:
25-32 . --| NONE.
25-33 . --|
25-34 . ----------------------------------------------------------------------------
25-35 . */
25-36 . static void hmi.2.1(void)
25-37 . {
25-38 . A = B*C;
25-39 . A = B+C;
25-40 . A = B*C;
25-41 . A = B+C;
25-42 . A = B+C;
25-43 . A = B+C;
25-44 .
25-45 . if (A != B)
25-46 . {
25-47 . A = B + C;
25-48 . D = E + F;
25-49 . }
25-50 .
25-51 .
25-52 . if (A le B)
25-53 . {
25-54 . A = B + C;
25-55 . D = E + F;
25-56 . }
25-57 .
25-58 . A = B/C;
25-59 . A = B+C;
25-60 . A = B+C;
25-61 .
25-62 . if (A == B)
25-63 . {
25-64 . A = B + C;
25-65 . D = E + F;
25-66 . }
25-67 .
25-68 . /* LE SV TOC-1814 this is a hmi-02.1.13 req to compare*/
25-69 . send_buffer = (U16 *) malloc(size+1);
25-70 .
25-71 . if (A == B)
25-72 . {
25-73 . A = B + C;
25-74 . D = E + F;
25-75 . }
25-76 .
25-77 . A = B*C;
25-78 . A = B*C;
25-79 . A = B-C;
25-80 . A = 0x0003;
25-81 . A = B*C;
25-82 . A = B*C;
25-83 .
25-84 . if (A > B)
25-85 . {
25-86 . A = B + C;
25-87 . D = E + F;
25-88 . }
25-89 .
25-90 . A = B+C;
25-91 . A = B+C;
25-92 . A = B-C;
25-93 . A = B/C;
25-94 . A = B*C;
25-95 .
25-96 . if (A ne B)
25-97 . {
25-98 . A = B + C;
25-99 . D = E + F;
25-100 . }
25-101 .
25-102 . A = B/C;
25-103 . A = B+C;
25-104 . A = 0x0004;
25-105 . A = B+C;
25-106 .
25-107 . if (A ge B)
25-108 . {
25-109 . A = B + C;
25-110 . D = E + F;
25-111 . }
25-112 .
25-113 . send_buffer = (U16 *) malloc(size+1);
25-114 . A = B+C;
25-115 .
25-116 . if (A le B)
25-117 . {
25-118 . A = B + C;
25-119 . D = E + F;
25-120 . }
25-121 .
25-122 .
25-123 . if (A lt B)
25-124 . {
25-125 . A = B + C;
25-126 . D = E + F;
25-127 . }
25-128 .
25-129 .
25-130 . if (A < B)
25-131 . {
25-132 . A = B + C;
25-133 . D = E + F;
25-134 . }
25-135 .
25-136 .
25-137 . if (A == B)
25-138 . {
25-139 . A = B + C;
25-140 . D = E + F;
25-141 . }
25-142 .
25-143 . A = B/C;
25-144 . A = B*C;
25-145 . A = B*C;
25-146 . rcv_buffer = (U16 *) alloc(size+1);
25-147 . A = B+C;
25-148 .
25-149 . if (A ge B)
25-150 . {
25-151 . A = B + C;
25-152 . D = E + F;
25-153 . }
25-154 .
25-155 . A = B+C;
25-156 . /* LE SV TOC-1815 this is a hmi-02.1.41 req to inhibit*/
25-157 . A = B/C;
25-158 . A = B-C;
25-159 . A = B+C;
25-160 . A = B*C;
25-161 . A = B/C;
25-162 .
25-163 . if (A < B)
25-164 . {
25-165 . A = B + C;
25-166 . D = E + F;
25-167 . }
25-168 .
25-169 .
25-170 . if {
25-171 . X = Y + Z;
25-172 . }
25-173 . else {
25-174 . halt;
25-175 . }
25-176 .
25-177 . A = B+C;
25-178 .
25-179 . if (A > B)
25-180 . {
25-181 . A = B + C;
25-182 . D = E + F;
25-183 . }
25-184 .
25-185 . A = B*C;
25-186 . /* LE SV TOC-1816 this is a hmi-02.1.50 req to reject*/
25-187 .
25-188 . switch (hmi stuff)
25-189 . {
25-190 . case one:
25-191 . {
25-192 . run_this;
25-193 . break;
25-194 . }
25-195 . case two:
25-196 . {
25-197 . run_this;
25-198 . break;
25-199 . }
25-200 . default:
25-201 . {
25-202 . SwError;
25-203 . }
25-204 . }
25-205 .
25-206 . A = B*C;
25-207 . A = B-C;
25-208 . // max LOC 52
25-209 .
25-210 . }
25-211 .
25-212 .
25-213 . /*
25-214 . -----------------------------------------------------------------------------
25-215 . --| NAME: hmi.2.2
25-216 . --|
25-217 . --| ABSTRACT:
25-218 . --| This function does hmi stuff.
25-219 . --|
25-220 . --| RETURNS:
25-221 . --| NONE.
25-222 . --|
25-223 . ----------------------------------------------------------------------------
25-224 . */
25-225 . static void hmi.2.2(void)
25-226 . {
25-227 . A = B-C;
25-228 . // (P) this is really improtant
25-229 . A = B-C;
25-230 . A = B+C;
25-231 .
25-232 . if (A ne B)
25-233 . {
25-234 . A = B + C;
25-235 . D = E + F;
25-236 . }
25-237 .
25-238 . A = 0x0007;
25-239 . A = B*C;
25-240 . A = B/C;
25-241 .
25-242 . if (A != B)
25-243 . {
25-244 . A = B + C;
25-245 . D = E + F;
25-246 . }
25-247 .
25-248 . A = B/C;
25-249 . A = B-C;
25-250 .
25-251 . if (A > = B)
25-252 . {
25-253 . A = B + C;
25-254 . D = E + F;
25-255 . }
25-256 .
25-257 .
25-258 . if (A le B)
25-259 . {
25-260 . A = B + C;
25-261 . D = E + F;
25-262 . }
25-263 .
25-264 . A = B/C;
25-265 . // TBS - I need to figure this out
25-266 .
25-267 . if (A > B)
25-268 . {
25-269 . A = B + C;
25-270 . D = E + F;
25-271 . }
25-272 .
25-273 . A = B/C;
25-274 . A = B/C;
25-275 . A = B-C;
25-276 .
25-277 . if (A != B)
25-278 . {
25-279 . A = B + C;
25-280 . D = E + F;
25-281 . }
25-282 .
25-283 .
25-284 . if (A eq B)
25-285 . {
25-286 . A = B + C;
25-287 . D = E + F;
25-288 . }
25-289 .
25-290 .
25-291 . if (A < = B)
25-292 . {
25-293 . A = B + C;
25-294 . D = E + F;
25-295 . }
25-296 .
25-297 . A = B/C;
25-298 . A = B*C;
25-299 . A = B-C;
25-300 . A = B+C;
25-301 . A = B-C;
25-302 . A = B-C;
25-303 . A = B+C;
25-304 . A = B/C;
25-305 .
25-306 . if (A > = B)
25-307 . {
25-308 . A = B + C;
25-309 . D = E + F;
25-310 . }
25-311 .
25-312 . // max LOC 28
25-313 .
25-314 . }
25-315 .
25-316 .
25-317 . /*
25-318 . -----------------------------------------------------------------------------
25-319 . --| NAME: hmi.2.3
25-320 . --|
25-321 . --| ABSTRACT:
25-322 . --| This function does hmi stuff.
25-323 . --|
25-324 . --| RETURNS:
25-325 . --| NONE.
25-326 . --|
25-327 . ----------------------------------------------------------------------------
25-328 . */
25-329 . static void hmi.2.3(void)
25-330 . {
25-331 . A = B-C;
25-332 . A = B+C;
25-333 . A = 0x0001;
25-334 .
25-335 . if (A < B)
25-336 . {
25-337 . A = B + C;
25-338 . D = E + F;
25-339 . }
25-340 .
25-341 .
25-342 . if (A != B)
25-343 . {
25-344 . A = B + C;
25-345 . D = E + F;
25-346 . }
25-347 .
25-348 . A = B+C;
25-349 . A = B*C;
25-350 . A = B-C;
25-351 .
25-352 . if (A ne B)
25-353 . {
25-354 . A = B + C;
25-355 . D = E + F;
25-356 . }
25-357 .
25-358 .
25-359 . if (A lt B)
25-360 . {
25-361 . A = B + C;
25-362 . D = E + F;
25-363 . }
25-364 .
25-365 .
25-366 . if (A > B)
25-367 . {
25-368 . A = B + C;
25-369 . D = E + F;
25-370 . }
25-371 .
25-372 . A = B+C;
25-373 . A = B*C;
25-374 .
25-375 . if (A le B)
25-376 . {
25-377 . A = B + C;
25-378 . D = E + F;
25-379 . }
25-380 .
25-381 . A = B/C;
25-382 .
25-383 . if (A gt B)
25-384 . {
25-385 . A = B + C;
25-386 . D = E + F;
25-387 . }
25-388 .
25-389 . A = B+C;
25-390 . A = B-C;
25-391 . A = B+C;
25-392 .
25-393 . switch (hmi stuff)
25-394 . {
25-395 . case:
25-396 . case:
25-397 . // stacked case statements but only if there is a new line in between
25-398 .
25-399 . case:
25-400 . case:
25-401 . case:
25-402 . {
25-403 . run_this;
25-404 . break;
25-405 . }
25-406 . default:
25-407 . {
25-408 . halt;
25-409 . }
25-410 . }
25-411 .
25-412 . A = B-C;
25-413 . A = B+C;
25-414 . A = B+C;
25-415 . /* LE SV TOC-1817 this is a hmi-02.3.22 req to call admin*/
25-416 . A = B+C;
25-417 . A = B*C;
25-418 . A = B/C;
25-419 .
25-420 . if (A ge B)
25-421 . {
25-422 . A = B + C;
25-423 . D = E + F;
25-424 . }
25-425 .
25-426 . A = B-C;
25-427 .
25-428 . switch (hmi stuff)
25-429 . {
25-430 . case one:
25-431 . {
25-432 . run_this;
25-433 . break;
25-434 . }
25-435 . case two:
25-436 . {
25-437 . run_this;
25-438 . break;
25-439 . }
25-440 . default:
25-441 . {
25-442 . SwError;
25-443 . }
25-444 . }
25-445 .
25-446 .
25-447 . if (A > B)
25-448 . {
25-449 . A = B + C;
25-450 . D = E + F;
25-451 . }
25-452 .
25-453 . A = B-C;
25-454 . // TBD - what do I do now
25-455 .
25-456 . if (A le B)
25-457 . {
25-458 . A = B + C;
25-459 . D = E + F;
25-460 . }
25-461 .
25-462 . A = B+C;
25-463 . A = B/C;
25-464 . A = B+C;
25-465 . A = B+C;
25-466 . // max LOC 34
25-467 .
25-468 . }
25-469 .
25-470 .
25-471 . /*
25-472 . -----------------------------------------------------------------------------
25-473 . --| NAME: hmi.2.4
25-474 . --|
25-475 . --| ABSTRACT:
25-476 . --| This function does hmi stuff.
25-477 . --|
25-478 . --| RETURNS:
25-479 . --| NONE.
25-480 . --|
25-481 . ----------------------------------------------------------------------------
25-482 . */
25-483 . static void hmi.2.4(void)
25-484 . {
25-485 . A = B/C;
25-486 . A = B*C;
25-487 . A = B-C;
25-488 .
25-489 . if (A gt B)
25-490 . {
25-491 . A = B + C;
25-492 . D = E + F;
25-493 . }
25-494 .
25-495 .
25-496 . switch (hmi stuff)
25-497 . {
25-498 . case one:
25-499 . {
25-500 . run_this;
25-501 . break;
25-502 . }
25-503 . case two:
25-504 . {
25-505 . run_this;
25-506 . break;
25-507 . }
25-508 . default:
25-509 . {
25-510 . SwError;
25-511 . }
25-512 . }
25-513 .
25-514 . A = B+C;
25-515 . // max LOC 6
25-516 .
25-517 . }
25-518 .
25-519 .
25-520 . /*
25-521 . -----------------------------------------------------------------------------
25-522 . --| NAME: hmi.2.5
25-523 . --|
25-524 . --| ABSTRACT:
25-525 . --| This function does hmi stuff.
25-526 . --|
25-527 . --| RETURNS:
25-528 . --| NONE.
25-529 . --|
25-530 . ----------------------------------------------------------------------------
25-531 . */
25-532 . static void hmi.2.5(void)
25-533 . {
25-534 . A = B-C;
25-535 . A = B-C;
25-536 . A = B-C;
25-537 . A = B+C;
25-538 . A = B*C;
25-539 . A = B+C;
25-540 . A = B+C;
25-541 . A = B+C;
25-542 . A = B-C;
25-543 .
25-544 . if (A ne B)
25-545 . {
25-546 . A = B + C;
25-547 . D = E + F;
25-548 . }
25-549 .
25-550 . A = B*C;
25-551 . A = B/C;
25-552 . A = B/C;
25-553 . A = B*C;
25-554 . FreePtr = HmiStringPtr;
25-555 . A = B-C;
25-556 . A = B+C;
25-557 . A = B-C;
25-558 . A = B/C;
25-559 . A = B/C;
25-560 . A = B/C;
25-561 .
25-562 . if (A ge B)
25-563 . {
25-564 . A = B + C;
25-565 . D = E + F;
25-566 . }
25-567 .
25-568 .
25-569 . if (A ge B)
25-570 . {
25-571 . A = B + C;
25-572 . D = E + F;
25-573 . }
25-574 .
25-575 .
25-576 . if (A < = B)
25-577 . {
25-578 . A = B + C;
25-579 . D = E + F;
25-580 . }
25-581 .
25-582 .
25-583 . if (A lt B)
25-584 . {
25-585 . A = B + C;
25-586 . D = E + F;
25-587 . }
25-588 .
25-589 . A = (long)B + C;
25-590 . A = B/C;
25-591 .
25-592 . if (A == B)
25-593 . {
25-594 . A = B + C;
25-595 . D = E + F;
25-596 . }
25-597 .
25-598 .
25-599 . if (A ge B)
25-600 . {
25-601 . A = B + C;
25-602 . D = E + F;
25-603 . }
25-604 .
25-605 . A = B-C;
25-606 . A = B/C;
25-607 .
25-608 . if (A != B)
25-609 . {
25-610 . A = B + C;
25-611 . D = E + F;
25-612 . }
25-613 .
25-614 . A = B-C;
25-615 . A = B+C;
25-616 .
25-617 . if (A != B)
25-618 . {
25-619 . A = B + C;
25-620 . D = E + F;
25-621 . }
25-622 .
25-623 .
25-624 . /* dead_code = B + C;
25-625 . dead_code = D + E;
25-626 . dead_code = F + G; */
25-627 .
25-628 .
25-629 . if (A ne B)
25-630 . {
25-631 . A = B + C;
25-632 . D = E + F;
25-633 . }
25-634 .
25-635 . /* LE SV TOC-1818 this is a hmi-02.5.35 req to process*/
25-636 . A = B+C;
25-637 . A = B*C;
25-638 . A = B+C;
25-639 . A = B/C;
25-640 . A = B+C;
25-641 . A = B+C;
25-642 . A = B*C;
25-643 . A = B-C;
25-644 . A = B/C;
25-645 .
25-646 . if (A ge B)
25-647 . {
25-648 . A = B + C;
25-649 . D = E + F;
25-650 . }
25-651 .
25-652 .
25-653 . if (A < B)
25-654 . {
25-655 . A = B + C;
25-656 . D = E + F;
25-657 . }
25-658 .
25-659 . A = B/C;
25-660 . A = B/C;
25-661 . A = B-C;
25-662 . A = B/C;
25-663 .
25-664 . if (A < B)
25-665 . {
25-666 . A = B + C;
25-667 . D = E + F;
25-668 . }
25-669 .
25-670 . A = B*C;
25-671 .
25-672 . if (A == B)
25-673 . {
25-674 . A = B + C;
25-675 . D = E + F;
25-676 . }
25-677 .
25-678 . A = B/C;
25-679 . /* LE SV TOC-1819 this is a hmi-02.5.54 req to audit*/
25-680 .
25-681 . if (A gt B)
25-682 . {
25-683 . A = B + C;
25-684 . D = E + F;
25-685 . }
25-686 .
25-687 .
25-688 . if (A ge B)
25-689 . {
25-690 . A = B + C;
25-691 . D = E + F;
25-692 . }
25-693 .
25-694 . A = B/C;
25-695 . A = B-C;
25-696 . A = 0x0008;
25-697 . A = B*C;
25-698 . A = (long)B + C;
25-699 . A = B+C;
25-700 . A = B/C;
25-701 . // max LOC 60
25-702 .
25-703 . }
25-704 .
25-705 .
25-706 . /*
25-707 . -----------------------------------------------------------------------------
25-708 . --| NAME: hmi.2.6
25-709 . --|
25-710 . --| ABSTRACT:
25-711 . --| This function does hmi stuff.
25-712 . --|
25-713 . --| RETURNS:
25-714 . --| NONE.
25-715 . --|
25-716 . ----------------------------------------------------------------------------
25-717 . */
25-718 . static void hmi.2.6(void)
25-719 . {
25-720 .
25-721 . switch (hmi stuff)
25-722 . {
25-723 . case one:
25-724 . {
25-725 . run_this;
25-726 . break;
25-727 . }
25-728 . case two:
25-729 . {
25-730 . run_this;
25-731 . break;
25-732 . }
25-733 . default:
25-734 . {
25-735 . SwError;
25-736 . }
25-737 . }
25-738 .
25-739 . A = B/C;
25-740 . /* LE SV TOC-1820 this is a hmi-02.6.3 req to check unix*/
25-741 . A = B+C;
25-742 . A = B+C;
25-743 . A = B-C;
25-744 . A = B+C;
25-745 . A = B+C;
25-746 .
25-747 . /*
25-748 . dead_block = C * D;
25-749 . dead_block = E * F;
25-750 . */
25-751 .
25-752 . A = B+C;
25-753 . A = B-C;
25-754 .
25-755 . if (A gt B)
25-756 . {
25-757 . A = B + C;
25-758 . D = E + F;
25-759 . }
25-760 .
25-761 .
25-762 . if (A < = B)
25-763 . {
25-764 . A = B + C;
25-765 . D = E + F;
25-766 . }
25-767 .
25-768 . A = B+C;
25-769 . A = B*C;
25-770 . A = B+C;
25-771 . A = B*C;
25-772 . A = B+C;
25-773 .
25-774 . if (A eq B)
25-775 . {
25-776 . A = B + C;
25-777 . D = E + F;
25-778 . }
25-779 .
25-780 . A = B/C;
25-781 .
25-782 . if (A gt B)
25-783 . {
25-784 . A = B + C;
25-785 . D = E + F;
25-786 . }
25-787 .
25-788 . A = B+C;
25-789 . A = B/C;
25-790 .
25-791 . switch (hmi stuff)
25-792 . {
25-793 . case:
25-794 . case:
25-795 . // stacked case statements but only if there is a new line in between
25-796 .
25-797 . case:
25-798 . case:
25-799 . case:
25-800 . {
25-801 . run_this;
25-802 . break;
25-803 . }
25-804 . default:
25-805 . {
25-806 . halt;
25-807 . }
25-808 . }
25-809 .
25-810 . A = B-C;
25-811 . A = B-C;
25-812 . A = B-C;
25-813 . A = B+C;
25-814 .
25-815 . if (A != B)
25-816 . {
25-817 . A = B + C;
25-818 . D = E + F;
25-819 . }
25-820 .
25-821 . A = B-C;
25-822 . A = B-C;
25-823 .
25-824 . switch (hmi stuff)
25-825 . {
25-826 . case one:
25-827 . {
25-828 . run_this;
25-829 . break;
25-830 . }
25-831 . case two:
25-832 . {
25-833 . run_this;
25-834 . break;
25-835 . }
25-836 . default:
25-837 . {
25-838 . SwError;
25-839 . }
25-840 . }
25-841 .
25-842 . A = B-C;
25-843 .
25-844 . if (A < = B)
25-845 . {
25-846 . A = B + C;
25-847 . D = E + F;
25-848 . }
25-849 .
25-850 . A = B/C;
25-851 . A = B+C;
25-852 .
25-853 . if (A ge B)
25-854 . {
25-855 . A = B + C;
25-856 . D = E + F;
25-857 . }
25-858 .
25-859 . A = B/C;
25-860 . A = B/C;
25-861 . A = B*C;
25-862 .
25-863 . switch (hmi stuff)
25-864 . {
25-865 . case one:
25-866 . {
25-867 . run_this;
25-868 . break;
25-869 . }
25-870 . case two:
25-871 . {
25-872 . run_this;
25-873 . break;
25-874 . }
25-875 . default:
25-876 . {
25-877 . SwError;
25-878 . }
25-879 . }
25-880 .
25-881 . A = B+C;
25-882 .
25-883 . if (A gt B)
25-884 . {
25-885 . A = B + C;
25-886 . D = E + F;
25-887 . }
25-888 .
25-889 . A = B*C;
25-890 . A = B+C;
25-891 . A = B+C;
25-892 . A = B*C;
25-893 . A = B-C;
25-894 . A = B-C;
25-895 . A = B*C;
25-896 . A = 0x0009;
25-897 .
25-898 . if (A ge B)
25-899 . {
25-900 . A = B + C;
25-901 . D = E + F;
25-902 . }
25-903 .
25-904 . A = B/C;
25-905 . A = B*C;
25-906 . A = B/C;
25-907 . A = B-C;
25-908 . // max LOC 52
25-909 .
25-910 . }
25-911 .
25-912 .
25-913 . /*
25-914 . -----------------------------------------------------------------------------
25-915 . --| NAME: hmi.2.7
25-916 . --|
25-917 . --| ABSTRACT:
25-918 . --| This function does hmi stuff.
25-919 . --|
25-920 . --| RETURNS:
25-921 . --| NONE.
25-922 . --|
25-923 . ----------------------------------------------------------------------------
25-924 . */
25-925 . static void hmi.2.7(void)
25-926 . {
25-927 . A = B-C;
25-928 .
25-929 . if (A > = B)
25-930 . {
25-931 . A = B + C;
25-932 . D = E + F;
25-933 . }
25-934 .
25-935 .
25-936 . if (A > = B)
25-937 . {
25-938 . A = B + C;
25-939 . D = E + F;
25-940 . }
25-941 .
25-942 .
25-943 . if (A ge B)
25-944 . {
25-945 . A = B + C;
25-946 . D = E + F;
25-947 . }
25-948 .
25-949 . A = B+C;
25-950 . A = B+C;
25-951 .
25-952 . if (A le B)
25-953 . {
25-954 . A = B + C;
25-955 . D = E + F;
25-956 . }
25-957 .
25-958 . /* LE SV TOC-1821 this is a hmi-02.7.8 req to compare*/
25-959 . A = B-C;
25-960 .
25-961 . if (A eq B)
25-962 . {
25-963 . A = B + C;
25-964 . D = E + F;
25-965 . }
25-966 .
25-967 . // max LOC 9
25-968 .
25-969 . }
25-970 .
25-971 .
25-972 . /*
25-973 . -----------------------------------------------------------------------------
25-974 . --| NAME: hmi.2.8
25-975 . --|
25-976 . --| ABSTRACT:
25-977 . --| This function does hmi stuff.
25-978 . --|
25-979 . --| RETURNS:
25-980 . --| NONE.
25-981 . --|
25-982 . ----------------------------------------------------------------------------
25-983 . */
25-984 . static void hmi.2.8(void)
25-985 . {
25-986 . A = B/C;
25-987 .
25-988 . if (A ge B)
25-989 . {
25-990 . A = B + C;
25-991 . D = E + F;
25-992 . }
25-993 .
25-994 . A = B*C;
25-995 . A = B+C;
25-996 . A = B*C;
25-997 . A = B*C;
25-998 . A = B*C;
25-999 . A = B/C;
25-1000 . A = B-C;
25-1001 .
25-1002 . if (A lt B)
25-1003 . {
25-1004 . A = B + C;
25-1005 . D = E + F;
25-1006 . }
25-1007 .
25-1008 .
25-1009 . if (A > = B)
25-1010 . {
25-1011 . A = B + C;
25-1012 . D = E + F;
25-1013 . }
25-1014 .
25-1015 .
25-1016 . if (A < = B)
25-1017 . {
25-1018 . A = B + C;
25-1019 . D = E + F;
25-1020 . }
25-1021 .
25-1022 .
25-1023 . if (A > B)
25-1024 . {
25-1025 . A = B + C;
25-1026 . D = E + F;
25-1027 . }
25-1028 .
25-1029 .
25-1030 . if (A == B)
25-1031 . {
25-1032 . A = B + C;
25-1033 . D = E + F;
25-1034 . }
25-1035 .
25-1036 .
25-1037 . if (A < = B)
25-1038 . {
25-1039 . A = B + C;
25-1040 . D = E + F;
25-1041 . }
25-1042 .
25-1043 . A = B/C;
25-1044 . A = B/C;
25-1045 .
25-1046 . if (A ne B)
25-1047 . {
25-1048 . A = B + C;
25-1049 . D = E + F;
25-1050 . }
25-1051 .
25-1052 . A = B-C;
25-1053 . A = B-C;
25-1054 . A = B/C;
25-1055 . A = B*C;
25-1056 .
25-1057 . /*
25-1058 . dead_block = C * D;
25-1059 . dead_block = E * F;
25-1060 . */
25-1061 .
25-1062 . A = B+C;
25-1063 . A = 0x0009;
25-1064 .
25-1065 . if (A < = B)
25-1066 . {
25-1067 . A = B + C;
25-1068 . D = E + F;
25-1069 . }
25-1070 .
25-1071 .
25-1072 . if (A < = B)
25-1073 . {
25-1074 . A = B + C;
25-1075 . D = E + F;
25-1076 . }
25-1077 .
25-1078 . A = 0x0006;
25-1079 .
25-1080 . if (A != B)
25-1081 . {
25-1082 . A = B + C;
25-1083 . D = E + F;
25-1084 . }
25-1085 .
25-1086 . A = B-C;
25-1087 . A = B/C;
25-1088 .
25-1089 . if (A < B)
25-1090 . {
25-1091 . A = B + C;
25-1092 . D = E + F;
25-1093 . }
25-1094 .
25-1095 .
25-1096 . if (A < B)
25-1097 . {
25-1098 . A = B + C;
25-1099 . D = E + F;
25-1100 . }
25-1101 .
25-1102 . A = B+C;
25-1103 .
25-1104 . if (A == B)
25-1105 . {
25-1106 . A = B + C;
25-1107 . D = E + F;
25-1108 . }
25-1109 .
25-1110 .
25-1111 . if (A > = B)
25-1112 . {
25-1113 . A = B + C;
25-1114 . D = E + F;
25-1115 . }
25-1116 .
25-1117 .
25-1118 . if (A ne B)
25-1119 . {
25-1120 . A = B + C;
25-1121 . D = E + F;
25-1122 . }
25-1123 .
25-1124 . A = B/C;
25-1125 . /* LE SV TOC-1822 this is a hmi-02.8.36 req to set RTC*/
25-1126 . A = B-C;
25-1127 .
25-1128 . if (A > = B)
25-1129 . {
25-1130 . A = B + C;
25-1131 . D = E + F;
25-1132 . }
25-1133 .
25-1134 . A = 0x0006;
25-1135 .
25-1136 . if (A le B)
25-1137 . {
25-1138 . A = B + C;
25-1139 . D = E + F;
25-1140 . }
25-1141 .
25-1142 .
25-1143 . if (A != B)
25-1144 . {
25-1145 . A = B + C;
25-1146 . D = E + F;
25-1147 . }
25-1148 .
25-1149 . A = B*C;
25-1150 . A = B+C;
25-1151 . A = B/C;
25-1152 . // max LOC 42
25-1153 .
25-1154 . }
25-1155 .
25-1156 .
25-1157 . /*
25-1158 . -----------------------------------------------------------------------------
25-1159 . --| NAME: hmi.2.9
25-1160 . --|
25-1161 . --| ABSTRACT:
25-1162 . --| This function does hmi stuff.
25-1163 . --|
25-1164 . --| RETURNS:
25-1165 . --| NONE.
25-1166 . --|
25-1167 . ----------------------------------------------------------------------------
25-1168 . */
25-1169 . static void hmi.2.9(void)
25-1170 . {
25-1171 . A = B-C;
25-1172 . A = B*C;
25-1173 . A = B/C;
25-1174 .
25-1175 . if (A eq B)
25-1176 . {
25-1177 . A = B + C;
25-1178 . D = E + F;
25-1179 . }
25-1180 .
25-1181 . /* LE SV TOC-1823 this is a hmi-02.9.5 req to disable*/
25-1182 .
25-1183 . if (A eq B)
25-1184 . {
25-1185 . A = B + C;
25-1186 . D = E + F;
25-1187 . }
25-1188 .
25-1189 . A = B*C;
25-1190 . // TBS - I need to figure this out
25-1191 .
25-1192 . if (A ne B)
25-1193 . {
25-1194 . A = B + C;
25-1195 . D = E + F;
25-1196 . }
25-1197 .
25-1198 . /* LE SV TOC-1824 this is a hmi-02.9.8 req to set Real Time Clock*/
25-1199 .
25-1200 . if (A ne B)
25-1201 . {
25-1202 . A = B + C;
25-1203 . D = E + F;
25-1204 . }
25-1205 .
25-1206 .
25-1207 . if (A < B)
25-1208 . {
25-1209 . A = B + C;
25-1210 . D = E + F;
25-1211 . }
25-1212 .
25-1213 . A = B+C;
25-1214 .
25-1215 . if (A ne B)
25-1216 . {
25-1217 . A = B + C;
25-1218 . D = E + F;
25-1219 . }
25-1220 .
25-1221 .
25-1222 . if (A lt B)
25-1223 . {
25-1224 . A = B + C;
25-1225 . D = E + F;
25-1226 . }
25-1227 .
25-1228 . A = 0x0009;
25-1229 . A = B-C;
25-1230 . // max LOC 13
25-1231 .
25-1232 . }
25-1233 .
25-1234 .
25-1235 . /*
25-1236 . -----------------------------------------------------------------------------
25-1237 . --| NAME: hmi.2.10
25-1238 . --|
25-1239 . --| ABSTRACT:
25-1240 . --| This function does hmi stuff.
25-1241 . --|
25-1242 . --| RETURNS:
25-1243 . --| NONE.
25-1244 . --|
25-1245 . ----------------------------------------------------------------------------
25-1246 . */
25-1247 . static void hmi.2.10(void)
25-1248 . {
25-1249 . A = B+C;
25-1250 .
25-1251 . if (A < = B)
25-1252 . {
25-1253 . A = B + C;
25-1254 . D = E + F;
25-1255 . }
25-1256 .
25-1257 . A = B-C;
25-1258 . A = B-C;
25-1259 . A = B*C;
25-1260 . A = B+C;
25-1261 . A = B+C;
25-1262 .
25-1263 . if (A eq B)
25-1264 . {
25-1265 . A = B + C;
25-1266 . D = E + F;
25-1267 . }
25-1268 .
25-1269 .
25-1270 . if (A eq B)
25-1271 . {
25-1272 . A = B + C;
25-1273 . D = E + F;
25-1274 . }
25-1275 .
25-1276 .
25-1277 . if (A > B)
25-1278 . {
25-1279 . A = B + C;
25-1280 . D = E + F;
25-1281 . }
25-1282 .
25-1283 . A = B-C;
25-1284 . A = B/C;
25-1285 .
25-1286 . if (A != B)
25-1287 . {
25-1288 . A = B + C;
25-1289 . D = E + F;
25-1290 . }
25-1291 .
25-1292 . A = B+C;
25-1293 . A = B/C;
25-1294 . A = B*C;
25-1295 . A = B/C;
25-1296 . A = B+C;
25-1297 . A = B-C;
25-1298 . /* LE SV TOC-1825 this is a hmi-02.10.20 req to translate*/
25-1299 . A = B-C;
25-1300 .
25-1301 . if (A > = B)
25-1302 . {
25-1303 . A = B + C;
25-1304 . D = E + F;
25-1305 . }
25-1306 .
25-1307 .
25-1308 . if (A != B)
25-1309 . {
25-1310 . A = B + C;
25-1311 . D = E + F;
25-1312 . }
25-1313 .
25-1314 . A = B+C;
25-1315 . A = B*C;
25-1316 . A = B+C;
25-1317 .
25-1318 . if (A > = B)
25-1319 . {
25-1320 . A = B + C;
25-1321 . D = E + F;
25-1322 . }
25-1323 .
25-1324 . A = B/C;
25-1325 . A = B*C;
25-1326 .
25-1327 . if (A le B)
25-1328 . {
25-1329 . A = B + C;
25-1330 . D = E + F;
25-1331 . }
25-1332 .
25-1333 . A = B/C;
25-1334 . A = B*C;
25-1335 .
25-1336 . if (A > = B)
25-1337 . {
25-1338 . A = B + C;
25-1339 . D = E + F;
25-1340 . }
25-1341 .
25-1342 . A = B-C;
25-1343 . A = B-C;
25-1344 . A = B-C;
25-1345 . A = B+C;
25-1346 . A = B-C;
25-1347 . A = 0x0008;
25-1348 . // ??? go see ws
25-1349 . A = B/C;
25-1350 . A = B/C;
25-1351 . // max LOC 39
25-1352 .
25-1353 . }
25-1354 .
25-1355 .
25-1356 . /*
25-1357 . -----------------------------------------------------------------------------
25-1358 . --| NAME: hmi.2.11
25-1359 . --|
25-1360 . --| ABSTRACT:
25-1361 . --| This function does hmi stuff.
25-1362 . --|
25-1363 . --| RETURNS:
25-1364 . --| NONE.
25-1365 . --|
25-1366 . ----------------------------------------------------------------------------
25-1367 . */
25-1368 . static void hmi.2.11(void)
25-1369 . {
25-1370 . /* LE SV TOC-1826 this is a hmi-02.11.1 req to record*/
25-1371 .
25-1372 . if (A gt B)
25-1373 . {
25-1374 . A = B + C;
25-1375 . D = E + F;
25-1376 . }
25-1377 .
25-1378 . A = B-C;
25-1379 . A = B-C;
25-1380 . A = B*C;
25-1381 . A = B-C;
25-1382 .
25-1383 . switch (hmi stuff)
25-1384 . {
25-1385 . case one:
25-1386 . {
25-1387 . run_this;
25-1388 . // missing break
25-1389 . }
25-1390 . case two:
25-1391 . {
25-1392 . run_this;
25-1393 . break;
25-1394 . }
25-1395 . default:
25-1396 . {
25-1397 . SwError;
25-1398 . }
25-1399 . }
25-1400 .
25-1401 .
25-1402 . if (A < B)
25-1403 . {
25-1404 . A = B + C;
25-1405 . D = E + F;
25-1406 . }
25-1407 .
25-1408 . A = B+C;
25-1409 .
25-1410 . if (A > B)
25-1411 . {
25-1412 . A = B + C;
25-1413 . D = E + F;
25-1414 . }
25-1415 .
25-1416 . // max LOC 8
25-1417 .
25-1418 . }
25-1419 .
25-1420 .
25-1421 . /*
25-1422 . -----------------------------------------------------------------------------
25-1423 . --| NAME: hmi.2.12
25-1424 . --|
25-1425 . --| ABSTRACT:
25-1426 . --| This function does hmi stuff.
25-1427 . --|
25-1428 . --| RETURNS:
25-1429 . --| NONE.
25-1430 . --|
25-1431 . ----------------------------------------------------------------------------
25-1432 . */
25-1433 . static void hmi.2.12(void)
25-1434 . {
25-1435 .
25-1436 . if (A ge B)
25-1437 . {
25-1438 . A = B + C;
25-1439 . D = E + F;
25-1440 . }
25-1441 .
25-1442 . A = B/C;
25-1443 . A = B+C;
25-1444 . rcv_buffer = (U16 *) alloc(size+1);
25-1445 . A = B-C;
25-1446 . A = B+C;
25-1447 . A = B+C;
25-1448 . A = B-C;
25-1449 . A = B/C;
25-1450 . A = B*C;
25-1451 . A = B/C;
25-1452 . A = B/C;
25-1453 .
25-1454 . if (A != B)
25-1455 . {
25-1456 . A = B + C;
25-1457 . D = E + F;
25-1458 . }
25-1459 .
25-1460 . A = B/C;
25-1461 .
25-1462 . if (A ne B)
25-1463 . {
25-1464 . A = B + C;
25-1465 . D = E + F;
25-1466 . }
25-1467 .
25-1468 .
25-1469 . if (A == B)
25-1470 . {
25-1471 . A = B + C;
25-1472 . D = E + F;
25-1473 . }
25-1474 .
25-1475 . A = B/C;
25-1476 . A = B*C;
25-1477 . A = B*C;
25-1478 . A = B+C;
25-1479 . A = B/C;
25-1480 . A = (long)B + C;
25-1481 .
25-1482 . if (A == B)
25-1483 . {
25-1484 . A = B + C;
25-1485 . D = E + F;
25-1486 . }
25-1487 .
25-1488 . A = B-C;
25-1489 . A = B*C;
25-1490 .
25-1491 . if (A == B)
25-1492 . {
25-1493 . A = B + C;
25-1494 . D = E + F;
25-1495 . }
25-1496 .
25-1497 .
25-1498 . if (A le B)
25-1499 . {
25-1500 . A = B + C;
25-1501 . D = E + F;
25-1502 . }
25-1503 .
25-1504 . A = B/C;
25-1505 .
25-1506 . if (A == B)
25-1507 . {
25-1508 . A = B + C;
25-1509 . D = E + F;
25-1510 . }
25-1511 .
25-1512 .
25-1513 . if (A le B)
25-1514 . {
25-1515 . A = B + C;
25-1516 . D = E + F;
25-1517 . }
25-1518 .
25-1519 . A = B+C;
25-1520 . A = B*C;
25-1521 .
25-1522 . if (A > = B)
25-1523 . {
25-1524 . A = B + C;
25-1525 . D = E + F;
25-1526 . }
25-1527 .
25-1528 . A = B/C;
25-1529 . A = B*C;
25-1530 .
25-1531 . if (A < B)
25-1532 . {
25-1533 . A = B + C;
25-1534 . D = E + F;
25-1535 . }
25-1536 .
25-1537 . // max LOC 34
25-1538 .
25-1539 . }
25-1540 .
25 25 Result: result/source/ft-app/ft-app-B1.1/hmi/hmi-02.c
26 26 Source: source/ft-app/ft-app-B1.1/hmi/hmi-03.c
26-0 . /*
26-1 . ----------------------------------------------------------------------------
26-2 . --| BEGIN PROLOGUE
26-3 . --|
26-4 . --| CLASSIFICATION: UNCLASSIFIED
26-5 . --|
26-6 . --| FILE NAME: hmi-03.c
26-7 . --|
26-8 . --| ABSTRACT:
26-9 . --| This file contains the 13 functions that do file hmi stuff.
26-10 . --|
26-11 . --| HISTORY:
26-12 . --| CCCQ_NAME:
26-13 . --| CCCQ_VER:
26-14 . --|
26-15 . --| END PROLOGUE
26-16 . ----------------------------------------------------------------------------
26-17 . */
26-18 .
26-19 . #include A;
26-20 . #define D;
26-21 . #define C;
26-22 . #define C;
26-23 . #include C;
26-24 .
26-25 .
26-26 .
26-27 . /*
26-28 . -----------------------------------------------------------------------------
26-29 . --| NAME: hmi.3.1
26-30 . --|
26-31 . --| ABSTRACT:
26-32 . --| This function does hmi stuff.
26-33 . --|
26-34 . --| RETURNS:
26-35 . --| NONE.
26-36 . --|
26-37 . ----------------------------------------------------------------------------
26-38 . */
26-39 . static void hmi.3.1(void)
26-40 . {
26-41 . FreePtr = HmiStringPtr;
26-42 . A = B/C;
26-43 . A = B/C;
26-44 . A = B/C;
26-45 . A = B+C;
26-46 . A = B*C;
26-47 . A = B*C;
26-48 . A = B-C;
26-49 . A = B*C;
26-50 .
26-51 . if (A le B)
26-52 . {
26-53 . A = B + C;
26-54 . D = E + F;
26-55 . }
26-56 .
26-57 . A = B*C;
26-58 . A = B*C;
26-59 . // max LOC 11
26-60 .
26-61 . }
26-62 .
26-63 .
26-64 . /*
26-65 . -----------------------------------------------------------------------------
26-66 . --| NAME: hmi.3.2
26-67 . --|
26-68 . --| ABSTRACT:
26-69 . --| This function does hmi stuff.
26-70 . --|
26-71 . --| RETURNS:
26-72 . --| NONE.
26-73 . --|
26-74 . ----------------------------------------------------------------------------
26-75 . */
26-76 . static void hmi.3.2(void)
26-77 . {
26-78 . A = B/C;
26-79 . A = B-C;
26-80 .
26-81 . if (A le B)
26-82 . {
26-83 . A = B + C;
26-84 . D = E + F;
26-85 . }
26-86 .
26-87 . A = B/C;
26-88 . A = B+C;
26-89 .
26-90 . if (A > B)
26-91 . {
26-92 . A = B + C;
26-93 . D = E + F;
26-94 . }
26-95 .
26-96 . A = B*C;
26-97 . A = B+C;
26-98 . A = B+C;
26-99 . A = B-C;
26-100 . A = B/C;
26-101 .
26-102 . if (A > = B)
26-103 . {
26-104 . A = B + C;
26-105 . D = E + F;
26-106 . }
26-107 .
26-108 .
26-109 . if (A < = B)
26-110 . {
26-111 . A = B + C;
26-112 . D = E + F;
26-113 . }
26-114 .
26-115 . A = B/C;
26-116 . A = B-C;
26-117 . A = B-C;
26-118 .
26-119 . if (A gt B)
26-120 . {
26-121 . A = B + C;
26-122 . D = E + F;
26-123 . }
26-124 .
26-125 . A = B-C;
26-126 . A = 0x0009;
26-127 . A = B*C;
26-128 . A = B*C;
26-129 . A = B*C;
26-130 .
26-131 . if (A eq B)
26-132 . {
26-133 . A = B + C;
26-134 . D = E + F;
26-135 . }
26-136 .
26-137 .
26-138 . if (A == B)
26-139 . {
26-140 . A = B + C;
26-141 . D = E + F;
26-142 . }
26-143 .
26-144 .
26-145 . if (A le B)
26-146 . {
26-147 . A = B + C;
26-148 . D = E + F;
26-149 . }
26-150 .
26-151 . A = B+C;
26-152 . /* LE SV TOC-1827 this is a hmi-03.2.26 req to convert*/
26-153 . A = B/C;
26-154 . A = B*C;
26-155 . A = B+C;
26-156 . A = B-C;
26-157 . A = B*C;
26-158 . A = B*C;
26-159 . /* LE SV TOC-1828 this is a hmi-03.2.32 req to increment*/
26-160 .
26-161 . if (A < = B)
26-162 . {
26-163 . A = B + C;
26-164 . D = E + F;
26-165 . }
26-166 .
26-167 . A = B+C;
26-168 . A = B*C;
26-169 .
26-170 . if (A < = B)
26-171 . {
26-172 . A = B + C;
26-173 . D = E + F;
26-174 . }
26-175 .
26-176 . A = B-C;
26-177 .
26-178 . if (A > = B)
26-179 . {
26-180 . A = B + C;
26-181 . D = E + F;
26-182 . }
26-183 .
26-184 . A = B-C;
26-185 . A = B*C;
26-186 . /* LE SV TOC-1829 this is a hmi-03.2.40 req to translate*/
26-187 . A = B+C;
26-188 . A = B*C;
26-189 . A = B*C;
26-190 . A = B-C;
26-191 . A = B+C;
26-192 .
26-193 . if (A ne B)
26-194 . {
26-195 . A = B + C;
26-196 . D = E + F;
26-197 . }
26-198 .
26-199 . A = B-C;
26-200 . A = B/C;
26-201 . A = B/C;
26-202 . A = B+C;
26-203 . A = B/C;
26-204 . A = B+C;
26-205 . A = B+C;
26-206 .
26-207 . if (A < B)
26-208 . {
26-209 . A = B + C;
26-210 . D = E + F;
26-211 . }
26-212 .
26-213 . /* LE SV TOC-1830 this is a hmi-03.2.54 req to transform*/
26-214 . A = B*C;
26-215 . A = B-C;
26-216 . A = B/C;
26-217 .
26-218 . if (A < = B)
26-219 . {
26-220 . A = B + C;
26-221 . D = E + F;
26-222 . }
26-223 .
26-224 . do forever;
26-225 . A = B*C;
26-226 . A = B/C;
26-227 . A = B*C;
26-228 .
26-229 . if (A > B)
26-230 . {
26-231 . A = B + C;
26-232 . D = E + F;
26-233 . }
26-234 .
26-235 . A = B+C;
26-236 . A = B/C;
26-237 . A = B+C;
26-238 . A = B+C;
26-239 . A = B-C;
26-240 .
26-241 . switch (hmi stuff)
26-242 . {
26-243 . case one:
26-244 . {
26-245 . run_this;
26-246 . break;
26-247 . }
26-248 . case two:
26-249 . {
26-250 . run_this;
26-251 . break;
26-252 . }
26-253 . // missing default
26-254 . }
26-255 .
26-256 . A = B/C;
26-257 .
26-258 . if (A > B)
26-259 . {
26-260 . A = B + C;
26-261 . D = E + F;
26-262 . }
26-263 .
26-264 . A = B*C;
26-265 .
26-266 . if (A > = B)
26-267 . {
26-268 . A = B + C;
26-269 . D = E + F;
26-270 . }
26-271 .
26-272 . A = B+C;
26-273 . A = B+C;
26-274 . A = B+C;
26-275 . A = B/C;
26-276 .
26-277 . if (A le B)
26-278 . {
26-279 . A = B + C;
26-280 . D = E + F;
26-281 . }
26-282 .
26-283 . A = B/C;
26-284 . FreePtr = HmiStringPtr;
26-285 . A = B+C;
26-286 . // max LOC 77
26-287 .
26-288 . }
26-289 .
26-290 .
26-291 . /*
26-292 . -----------------------------------------------------------------------------
26-293 . --| NAME: hmi.3.3
26-294 . --|
26-295 . --| ABSTRACT:
26-296 . --| This function does hmi stuff.
26-297 . --|
26-298 . --| RETURNS:
26-299 . --| NONE.
26-300 . --|
26-301 . ----------------------------------------------------------------------------
26-302 . */
26-303 . static void hmi.3.3(void)
26-304 . {
26-305 . A = B/C;
26-306 . A = B+C;
26-307 .
26-308 . if (A lt B)
26-309 . {
26-310 . A = B + C;
26-311 . D = E + F;
26-312 . }
26-313 .
26-314 . A = B*C;
26-315 . do forever;
26-316 . A = B/C;
26-317 .
26-318 . if (A ge B)
26-319 . {
26-320 . A = B + C;
26-321 . D = E + F;
26-322 . }
26-323 .
26-324 . A = B+C;
26-325 . A = B*C;
26-326 . A = B*C;
26-327 . A = B-C;
26-328 . A = B/C;
26-329 . A = B-C;
26-330 .
26-331 . if (A < = B)
26-332 . {
26-333 . A = B + C;
26-334 . D = E + F;
26-335 . }
26-336 .
26-337 .
26-338 . switch (hmi stuff)
26-339 . {
26-340 . case one:
26-341 . {
26-342 . run_this;
26-343 . break;
26-344 . }
26-345 . case two:
26-346 . {
26-347 . run_this;
26-348 . break;
26-349 . }
26-350 . default:
26-351 . {
26-352 . SwError;
26-353 . }
26-354 . }
26-355 .
26-356 . A = B+C;
26-357 . A = B-C;
26-358 . A = B+C;
26-359 .
26-360 . if (A == B)
26-361 . {
26-362 . A = B + C;
26-363 . D = E + F;
26-364 . }
26-365 .
26-366 . A = B*C;
26-367 .
26-368 . /* dead_block = C * D;
26-369 . dead_block = E * F; */
26-370 .
26-371 .
26-372 . if (A < B)
26-373 . {
26-374 . A = B + C;
26-375 . D = E + F;
26-376 . }
26-377 .
26-378 . A = B+C;
26-379 . A = B/C;
26-380 . A = B/C;
26-381 . A = B/C;
26-382 . A = B+C;
26-383 .
26-384 . if (A ge B)
26-385 . {
26-386 . A = B + C;
26-387 . D = E + F;
26-388 . }
26-389 .
26-390 . A = 0x0002;
26-391 .
26-392 . if (A lt B)
26-393 . {
26-394 . A = B + C;
26-395 . D = E + F;
26-396 . }
26-397 .
26-398 . A = B*C;
26-399 .
26-400 . switch (hmi stuff)
26-401 . {
26-402 . case one:
26-403 . {
26-404 . run_this;
26-405 . break;
26-406 . }
26-407 . case two:
26-408 . {
26-409 . run_this;
26-410 . break;
26-411 . }
26-412 . default:
26-413 . {
26-414 . SwError;
26-415 . }
26-416 . }
26-417 .
26-418 . A = 0x0007;
26-419 . A = B*C;
26-420 . A = B/C;
26-421 . A = B*C;
26-422 . A = B/C;
26-423 . A = B-C;
26-424 . A = B+C;
26-425 .
26-426 . if (A eq B)
26-427 . {
26-428 . A = B + C;
26-429 . D = E + F;
26-430 . }
26-431 .
26-432 . A = B+C;
26-433 .
26-434 . if (A gt B)
26-435 . {
26-436 . A = B + C;
26-437 . D = E + F;
26-438 . }
26-439 .
26-440 .
26-441 . #ifdef LAZY
26-442 . // this is not nice
26-443 . A = B + C;
26-444 . A = B + C;
26-445 . #endif
26-446 .
26-447 . A = B*C;
26-448 . A = B+C;
26-449 . A = B+C;
26-450 . A = B+C;
26-451 . /* LE SV TOC-1831 this is a hmi-03.3.43 req to check pSOS*/
26-452 .
26-453 . if (A == B)
26-454 . {
26-455 . A = B + C;
26-456 . D = E + F;
26-457 . }
26-458 .
26-459 . /* LE SV TOC-1832 this is a hmi-03.3.44 req to audit*/
26-460 . A = B*C;
26-461 . A = B*C;
26-462 .
26-463 . if (A ge B)
26-464 . {
26-465 . A = B + C;
26-466 . D = E + F;
26-467 . }
26-468 .
26-469 . A = B/C;
26-470 . A = B/C;
26-471 . A = B*C;
26-472 . A = B*C;
26-473 . A = B/C;
26-474 .
26-475 . switch (hmi stuff)
26-476 . {
26-477 . case:
26-478 . case:
26-479 . // stacked case statements but only if there is a new line in between
26-480 .
26-481 . case:
26-482 . case:
26-483 . case:
26-484 . {
26-485 . run_this;
26-486 . break;
26-487 . }
26-488 . default:
26-489 . {
26-490 . halt;
26-491 . }
26-492 . }
26-493 .
26-494 . A = B*C;
26-495 . A = B*C;
26-496 . A = B+C;
26-497 . A = B-C;
26-498 .
26-499 . if (A == B)
26-500 . {
26-501 . A = B + C;
26-502 . D = E + F;
26-503 . }
26-504 .
26-505 . A = B-C;
26-506 . // max LOC 57
26-507 .
26-508 . }
26-509 .
26-510 .
26-511 . /*
26-512 . -----------------------------------------------------------------------------
26-513 . --| NAME: hmi.3.4
26-514 . --|
26-515 . --| ABSTRACT:
26-516 . --| This function does hmi stuff.
26-517 . --|
26-518 . --| RETURNS:
26-519 . --| NONE.
26-520 . --|
26-521 . ----------------------------------------------------------------------------
26-522 . */
26-523 . static void hmi.3.4(void)
26-524 . {
26-525 .
26-526 . if (A lt B)
26-527 . {
26-528 . A = B + C;
26-529 . D = E + F;
26-530 . }
26-531 .
26-532 . A = B*C;
26-533 . A = B+C;
26-534 .
26-535 . /*
26-536 . dead_code = B - C;
26-537 . dead_code = D - E;
26-538 . dead_code = F - G;
26-539 . */
26-540 .
26-541 . A = B/C;
26-542 . A = (int)B + C;
26-543 . A = B+C;
26-544 . A = B-C;
26-545 . A = B/C;
26-546 . A = B/C;
26-547 .
26-548 . if (A > = B)
26-549 . {
26-550 . A = B + C;
26-551 . D = E + F;
26-552 . }
26-553 .
26-554 . /* LE SV TOC-1833 this is a hmi-03.4.10 req to fail*/
26-555 . A = B*C;
26-556 . A = B+C;
26-557 . A = B+C;
26-558 .
26-559 . if (A ne B)
26-560 . {
26-561 . A = B + C;
26-562 . D = E + F;
26-563 . }
26-564 .
26-565 . A = B-C;
26-566 .
26-567 . switch (hmi stuff)
26-568 . {
26-569 . case one:
26-570 . {
26-571 . run_this;
26-572 . break;
26-573 . }
26-574 . case two:
26-575 . {
26-576 . run_this;
26-577 . break;
26-578 . }
26-579 . default:
26-580 . {
26-581 . SwError;
26-582 . }
26-583 . }
26-584 .
26-585 . A = B+C;
26-586 . A = B/C;
26-587 . A = B/C;
26-588 . A = B+C;
26-589 . /* LE SV TOC-1834 this is a hmi-03.4.20 req to disable*/
26-590 .
26-591 . if {
26-592 . X = Y + Z;
26-593 . }
26-594 . else {
26-595 . halt;
26-596 . }
26-597 .
26-598 . A = B*C;
26-599 . A = B/C;
26-600 . A = B*C;
26-601 . A = B+C;
26-602 . A = B+C;
26-603 . A = B/C;
26-604 .
26-605 . if (A le B)
26-606 . {
26-607 . A = B + C;
26-608 . D = E + F;
26-609 . }
26-610 .
26-611 . A = B/C;
26-612 . A = B/C;
26-613 . A = B+C;
26-614 . A = B+C;
26-615 . A = B-C;
26-616 . A = B+C;
26-617 . A = B/C;
26-618 . // TBS - I need to figure this out
26-619 . A = B-C;
26-620 . A = B*C;
26-621 . // ??? go see ws
26-622 . A = B*C;
26-623 . A = B-C;
26-624 . A = B*C;
26-625 .
26-626 . if (A > = B)
26-627 . {
26-628 . A = B + C;
26-629 . D = E + F;
26-630 . }
26-631 .
26-632 . A = B*C;
26-633 . A = B*C;
26-634 .
26-635 . if (A lt B)
26-636 . {
26-637 . A = B + C;
26-638 . D = E + F;
26-639 . }
26-640 .
26-641 . A = 0x0009;
26-642 . A = B*C;
26-643 .
26-644 . if (A > B)
26-645 . {
26-646 . A = B + C;
26-647 . D = E + F;
26-648 . }
26-649 .
26-650 . A = B-C;
26-651 . A = 0x0001;
26-652 . A = B/C;
26-653 .
26-654 . if (A < = B)
26-655 . {
26-656 . A = B + C;
26-657 . D = E + F;
26-658 . }
26-659 .
26-660 . A = B+C;
26-661 .
26-662 . if (A eq B)
26-663 . {
26-664 . A = B + C;
26-665 . D = E + F;
26-666 . }
26-667 .
26-668 . A = B/C;
26-669 .
26-670 . if (A > = B)
26-671 . {
26-672 . A = B + C;
26-673 . D = E + F;
26-674 . }
26-675 .
26-676 . A = B/C;
26-677 . A = B-C;
26-678 . A = B+C;
26-679 . // max LOC 54
26-680 .
26-681 . }
26-682 .
26-683 .
26-684 . /*
26-685 . -----------------------------------------------------------------------------
26-686 . --| NAME: hmi.3.5
26-687 . --|
26-688 . --| ABSTRACT:
26-689 . --| This function does hmi stuff.
26-690 . --|
26-691 . --| RETURNS:
26-692 . --| NONE.
26-693 . --|
26-694 . ----------------------------------------------------------------------------
26-695 . */
26-696 . static void hmi.3.5(void)
26-697 . {
26-698 . A = 0x0008;
26-699 . A = B*C;
26-700 . A = B-C;
26-701 . A = B*C;
26-702 .
26-703 . if (A eq B)
26-704 . {
26-705 . A = B + C;
26-706 . D = E + F;
26-707 . }
26-708 .
26-709 . A = B-C;
26-710 . free(FreePtr);
26-711 . A = B+C;
26-712 .
26-713 . if (A > B)
26-714 . {
26-715 . A = B + C;
26-716 . D = E + F;
26-717 . }
26-718 .
26-719 . A = B/C;
26-720 .
26-721 . switch (hmi stuff)
26-722 . {
26-723 . case:
26-724 . case:
26-725 . // stacked case statements but only if there is a new line in between
26-726 .
26-727 . case:
26-728 . case:
26-729 . case:
26-730 . {
26-731 . run_this;
26-732 . break;
26-733 . }
26-734 . default:
26-735 . {
26-736 . halt;
26-737 . }
26-738 . }
26-739 .
26-740 . A = B*C;
26-741 . A = B/C;
26-742 . A = B-C;
26-743 .
26-744 . if {
26-745 . X = Y + Z;
26-746 . }
26-747 . else {
26-748 . halt;
26-749 . }
26-750 .
26-751 . A = B/C;
26-752 . A = B+C;
26-753 . A = B+C;
26-754 .
26-755 . if (A eq B)
26-756 . {
26-757 . A = B + C;
26-758 . D = E + F;
26-759 . }
26-760 .
26-761 . A = B/C;
26-762 . A = B*C;
26-763 . A = B+C;
26-764 . // max LOC 18
26-765 .
26-766 . }
26-767 .
26-768 .
26-769 . /*
26-770 . -----------------------------------------------------------------------------
26-771 . --| NAME: hmi.3.6
26-772 . --|
26-773 . --| ABSTRACT:
26-774 . --| This function does hmi stuff.
26-775 . --|
26-776 . --| RETURNS:
26-777 . --| NONE.
26-778 . --|
26-779 . ----------------------------------------------------------------------------
26-780 . */
26-781 . static void hmi.3.6(void)
26-782 . {
26-783 . A = B+C;
26-784 .
26-785 . if (A ge B)
26-786 . {
26-787 . A = B + C;
26-788 . D = E + F;
26-789 . }
26-790 .
26-791 . /* LE SV TOC-1835 this is a hmi-03.6.3 req to verify*/
26-792 .
26-793 . if (A < B)
26-794 . {
26-795 . A = B + C;
26-796 . D = E + F;
26-797 . }
26-798 .
26-799 . A = B-C;
26-800 . A = B/C;
26-801 . A = B-C;
26-802 . A = B+C;
26-803 . A = B-C;
26-804 . A = B+C;
26-805 . A = B+C;
26-806 . A = B/C;
26-807 .
26-808 . if (veg)
26-809 . // missing curly brace
26-810 . variable = orange;
26-811 .
26-812 . A = B+C;
26-813 . A = B*C;
26-814 . A = B+C;
26-815 . A = B/C;
26-816 . A = B-C;
26-817 . A = B/C;
26-818 . A = B/C;
26-819 . A = 0x0008;
26-820 . A = B+C;
26-821 . A = B*C;
26-822 .
26-823 . switch (hmi stuff)
26-824 . {
26-825 . case one:
26-826 . {
26-827 . run_this;
26-828 . break;
26-829 . }
26-830 . case two:
26-831 . {
26-832 . run_this;
26-833 . break;
26-834 . }
26-835 . default:
26-836 . {
26-837 . SwError;
26-838 . }
26-839 . }
26-840 .
26-841 .
26-842 . if (A != B)
26-843 . {
26-844 . A = B + C;
26-845 . D = E + F;
26-846 . }
26-847 .
26-848 .
26-849 . /* dead_block = C * D;
26-850 . dead_block = E * F; */
26-851 .
26-852 . A = B*C;
26-853 .
26-854 . switch (hmi stuff)
26-855 . {
26-856 . case one:
26-857 . {
26-858 . run_this;
26-859 . break;
26-860 . }
26-861 . case two:
26-862 . {
26-863 . run_this;
26-864 . break;
26-865 . }
26-866 . default:
26-867 . {
26-868 . SwError;
26-869 . }
26-870 . }
26-871 .
26-872 . A = B*C;
26-873 .
26-874 . if (A ne B)
26-875 . {
26-876 . A = B + C;
26-877 . D = E + F;
26-878 . }
26-879 .
26-880 . A = B/C;
26-881 . A = 0x0007;
26-882 . A = B*C;
26-883 .
26-884 . if (A != B)
26-885 . {
26-886 . A = B + C;
26-887 . D = E + F;
26-888 . }
26-889 .
26-890 .
26-891 . if (A le B)
26-892 . {
26-893 . A = B + C;
26-894 . D = E + F;
26-895 . }
26-896 .
26-897 . A = B/C;
26-898 .
26-899 . if (A ne B)
26-900 . {
26-901 . A = B + C;
26-902 . D = E + F;
26-903 . }
26-904 .
26-905 .
26-906 . if (A le B)
26-907 . {
26-908 . A = B + C;
26-909 . D = E + F;
26-910 . }
26-911 .
26-912 . A = B-C;
26-913 . /* LE SV TOC-1836 this is a hmi-03.6.35 req to inhibit*/
26-914 . A = B*C;
26-915 . // max LOC 35
26-916 .
26-917 . }
26-918 .
26-919 .
26-920 . /*
26-921 . -----------------------------------------------------------------------------
26-922 . --| NAME: hmi.3.7
26-923 . --|
26-924 . --| ABSTRACT:
26-925 . --| This function does hmi stuff.
26-926 . --|
26-927 . --| RETURNS:
26-928 . --| NONE.
26-929 . --|
26-930 . ----------------------------------------------------------------------------
26-931 . */
26-932 . static void hmi.3.7(void)
26-933 . {
26-934 . A = B-C;
26-935 .
26-936 . if (A == B)
26-937 . {
26-938 . A = B + C;
26-939 . D = E + F;
26-940 . }
26-941 .
26-942 . A = B+C;
26-943 . // TBS - I need to figure this out
26-944 . A = B/C;
26-945 . A = B-C;
26-946 . A = B+C;
26-947 . A = B+C;
26-948 . A = B*C;
26-949 . A = B/C;
26-950 .
26-951 . if (A == B)
26-952 . {
26-953 . A = B + C;
26-954 . D = E + F;
26-955 . }
26-956 .
26-957 . /* LE SV TOC-1837 this is a hmi-03.7.11 req to disable*/
26-958 .
26-959 . if (A < = B)
26-960 . {
26-961 . A = B + C;
26-962 . D = E + F;
26-963 . }
26-964 .
26-965 . A = B+C;
26-966 . A = B/C;
26-967 .
26-968 . if (A == B)
26-969 . {
26-970 . A = B + C;
26-971 . D = E + F;
26-972 . }
26-973 .
26-974 . A = B/C;
26-975 . A = B/C;
26-976 .
26-977 . if (A < B)
26-978 . {
26-979 . A = B + C;
26-980 . D = E + F;
26-981 . }
26-982 .
26-983 . A = B+C;
26-984 . A = B-C;
26-985 .
26-986 . #ifdef LAZY
26-987 . // this is not nice
26-988 . A = B + C;
26-989 . A = B + C;
26-990 . #endif
26-991 .
26-992 . A = B*C;
26-993 .
26-994 . if (A ge B)
26-995 . {
26-996 . A = B + C;
26-997 . D = E + F;
26-998 . }
26-999 .
26-1000 . A = B*C;
26-1001 .
26-1002 . /*
26-1003 . dead_code = B - C;
26-1004 . dead_code = D - E;
26-1005 . dead_code = F - G;
26-1006 . */
26-1007 .
26-1008 . A = B/C;
26-1009 .
26-1010 . if (A ge B)
26-1011 . {
26-1012 . A = B + C;
26-1013 . D = E + F;
26-1014 . }
26-1015 .
26-1016 . A = B+C;
26-1017 . A = B/C;
26-1018 . A = B-C;
26-1019 . A = B-C;
26-1020 . A = B-C;
26-1021 .
26-1022 . if (A != B)
26-1023 . {
26-1024 . A = B + C;
26-1025 . D = E + F;
26-1026 . }
26-1027 .
26-1028 . A = B-C;
26-1029 . A = B/C;
26-1030 .
26-1031 . if (A > = B)
26-1032 . {
26-1033 . A = B + C;
26-1034 . D = E + F;
26-1035 . }
26-1036 .
26-1037 . /* LE SV TOC-1838 this is a hmi-03.7.34 req to increment*/
26-1038 . A = B+C;
26-1039 .
26-1040 . if (A eq B)
26-1041 . {
26-1042 . A = B + C;
26-1043 . D = E + F;
26-1044 . }
26-1045 .
26-1046 . /* LE SV TOC-1839 this is a hmi-03.7.36 req to recover*/
26-1047 . A = B-C;
26-1048 . A = B-C;
26-1049 . A = B-C;
26-1050 .
26-1051 . if (A ge B)
26-1052 . {
26-1053 . A = B + C;
26-1054 . D = E + F;
26-1055 . }
26-1056 .
26-1057 . A = B*C;
26-1058 .
26-1059 . if (A != B)
26-1060 . {
26-1061 . A = B + C;
26-1062 . D = E + F;
26-1063 . }
26-1064 .
26-1065 . A = B/C;
26-1066 . A = B+C;
26-1067 . A = B*C;
26-1068 . A = B+C;
26-1069 . A = B*C;
26-1070 . A = B/C;
26-1071 .
26-1072 . switch (hmi stuff)
26-1073 . {
26-1074 . case one:
26-1075 . {
26-1076 . run_this;
26-1077 . break;
26-1078 . }
26-1079 . case two:
26-1080 . {
26-1081 . run_this;
26-1082 . break;
26-1083 . }
26-1084 . default:
26-1085 . {
26-1086 . SwError;
26-1087 . }
26-1088 . }
26-1089 .
26-1090 .
26-1091 . if (A ne B)
26-1092 . {
26-1093 . A = B + C;
26-1094 . D = E + F;
26-1095 . }
26-1096 .
26-1097 . A = 0x0003;
26-1098 . A = B/C;
26-1099 .
26-1100 . if (A < = B)
26-1101 . {
26-1102 . A = B + C;
26-1103 . D = E + F;
26-1104 . }
26-1105 .
26-1106 . A = B-C;
26-1107 . A = B-C;
26-1108 .
26-1109 . switch (hmi stuff)
26-1110 . {
26-1111 . case one:
26-1112 . {
26-1113 . run_this;
26-1114 . break;
26-1115 . }
26-1116 . case two:
26-1117 . {
26-1118 . run_this;
26-1119 . break;
26-1120 . }
26-1121 . default:
26-1122 . {
26-1123 . SwError;
26-1124 . }
26-1125 . }
26-1126 .
26-1127 . A = B+C;
26-1128 .
26-1129 . if (A ge B)
26-1130 . {
26-1131 . A = B + C;
26-1132 . D = E + F;
26-1133 . }
26-1134 .
26-1135 . A = B-C;
26-1136 . A = B*C;
26-1137 .
26-1138 . if (A lt B)
26-1139 . {
26-1140 . A = B + C;
26-1141 . D = E + F;
26-1142 . }
26-1143 .
26-1144 . A = B*C;
26-1145 . A = B+C;
26-1146 . A = B+C;
26-1147 . // TBD - what do I do now
26-1148 . A = B-C;
26-1149 .
26-1150 . if (A == B)
26-1151 . {
26-1152 . A = B + C;
26-1153 . D = E + F;
26-1154 . }
26-1155 .
26-1156 . A = B-C;
26-1157 .
26-1158 . switch (hmi stuff)
26-1159 . {
26-1160 . case one:
26-1161 . {
26-1162 . run_this;
26-1163 . break;
26-1164 . }
26-1165 . case two:
26-1166 . {
26-1167 . run_this;
26-1168 . break;
26-1169 . }
26-1170 . default:
26-1171 . {
26-1172 . SwError;
26-1173 . }
26-1174 . }
26-1175 .
26-1176 . A = B+C;
26-1177 .
26-1178 . if (A < = B)
26-1179 . {
26-1180 . A = B + C;
26-1181 . D = E + F;
26-1182 . }
26-1183 .
26-1184 .
26-1185 . if (A eq B)
26-1186 . {
26-1187 . A = B + C;
26-1188 . D = E + F;
26-1189 . }
26-1190 .
26-1191 .
26-1192 . if (A > = B)
26-1193 . {
26-1194 . A = B + C;
26-1195 . D = E + F;
26-1196 . }
26-1197 .
26-1198 . A = B*C;
26-1199 .
26-1200 . if (A > = B)
26-1201 . {
26-1202 . A = B + C;
26-1203 . D = E + F;
26-1204 . }
26-1205 .
26-1206 . A = B/C;
26-1207 .
26-1208 . if (A le B)
26-1209 . {
26-1210 . A = B + C;
26-1211 . D = E + F;
26-1212 . }
26-1213 .
26-1214 .
26-1215 . if (A != B)
26-1216 . {
26-1217 . A = B + C;
26-1218 . D = E + F;
26-1219 . }
26-1220 .
26-1221 . A = B+C;
26-1222 . A = B*C;
26-1223 . A = B*C;
26-1224 . A = B-C;
26-1225 . A = B*C;
26-1226 . /* LE SV TOC-1840 this is a hmi-03.7.81 req to validate*/
26-1227 . A = B+C;
26-1228 . A = B+C;
26-1229 . /* LE SV TOC-1841 this is a hmi-03.7.83 req to assign*/
26-1230 . A = B*C;
26-1231 . A = B/C;
26-1232 . A = B*C;
26-1233 . A = B+C;
26-1234 . A = B/C;
26-1235 . A = B*C;
26-1236 . A = B*C;
26-1237 . goto error;
26-1238 . A = B+C;
26-1239 . A = B/C;
26-1240 .
26-1241 . switch (hmi stuff)
26-1242 . {
26-1243 . case one:
26-1244 . {
26-1245 . run_this;
26-1246 . break;
26-1247 . }
26-1248 . case two:
26-1249 . {
26-1250 . run_this;
26-1251 . break;
26-1252 . }
26-1253 . default:
26-1254 . {
26-1255 . SwError;
26-1256 . }
26-1257 . }
26-1258 .
26-1259 . A = B/C;
26-1260 . A = B-C;
26-1261 . A = B-C;
26-1262 .
26-1263 . if (A > B)
26-1264 . {
26-1265 . A = B + C;
26-1266 . D = E + F;
26-1267 . }
26-1268 .
26-1269 . // max LOC 96
26-1270 .
26-1271 . }
26-1272 .
26-1273 .
26-1274 . /*
26-1275 . -----------------------------------------------------------------------------
26-1276 . --| NAME: hmi.3.8
26-1277 . --|
26-1278 . --| ABSTRACT:
26-1279 . --| This function does hmi stuff.
26-1280 . --|
26-1281 . --| RETURNS:
26-1282 . --| NONE.
26-1283 . --|
26-1284 . ----------------------------------------------------------------------------
26-1285 . */
26-1286 . static void hmi.3.8(void)
26-1287 . {
26-1288 . A = B-C;
26-1289 . A = B/C;
26-1290 . A = B*C;
26-1291 . A = B-C;
26-1292 . A = B-C;
26-1293 . A = B*C;
26-1294 . A = B/C;
26-1295 .
26-1296 . if (A lt B)
26-1297 . {
26-1298 . A = B + C;
26-1299 . D = E + F;
26-1300 . }
26-1301 .
26-1302 . A = B+C;
26-1303 .
26-1304 . if (A gt B)
26-1305 . {
26-1306 . A = B + C;
26-1307 . D = E + F;
26-1308 . }
26-1309 .
26-1310 . A = B-C;
26-1311 .
26-1312 . if (A eq B)
26-1313 . {
26-1314 . A = B + C;
26-1315 . D = E + F;
26-1316 . }
26-1317 .
26-1318 . A = B+C;
26-1319 . A = B*C;
26-1320 . A = B+C;
26-1321 . A = B*C;
26-1322 . A = B+C;
26-1323 . A = B-C;
26-1324 . A = B-C;
26-1325 .
26-1326 . if (A > = B)
26-1327 . {
26-1328 . A = B + C;
26-1329 . D = E + F;
26-1330 . }
26-1331 .
26-1332 .
26-1333 . if (A == B)
26-1334 . {
26-1335 . A = B + C;
26-1336 . D = E + F;
26-1337 . }
26-1338 .
26-1339 . A = B-C;
26-1340 .
26-1341 . if (A ge B)
26-1342 . {
26-1343 . A = B + C;
26-1344 . D = E + F;
26-1345 . }
26-1346 .
26-1347 . A = B*C;
26-1348 . A = B-C;
26-1349 . A = B*C;
26-1350 .
26-1351 . if (A == B)
26-1352 . {
26-1353 . A = B + C;
26-1354 . D = E + F;
26-1355 . }
26-1356 .
26-1357 . A = B-C;
26-1358 .
26-1359 . if (A < = B)
26-1360 . {
26-1361 . A = B + C;
26-1362 . D = E + F;
26-1363 . }
26-1364 .
26-1365 . A = B/C;
26-1366 .
26-1367 . if (A gt B)
26-1368 . {
26-1369 . A = B + C;
26-1370 . D = E + F;
26-1371 . }
26-1372 .
26-1373 . A = B-C;
26-1374 . A = B-C;
26-1375 . A = B/C;
26-1376 . A = B-C;
26-1377 . A = B*C;
26-1378 . A = B-C;
26-1379 . A = B-C;
26-1380 .
26-1381 . switch (hmi stuff)
26-1382 . {
26-1383 . case one:
26-1384 . {
26-1385 . run_this;
26-1386 . break;
26-1387 . }
26-1388 . case two:
26-1389 . {
26-1390 . run_this;
26-1391 . break;
26-1392 . }
26-1393 . default:
26-1394 . {
26-1395 . SwError;
26-1396 . }
26-1397 . }
26-1398 .
26-1399 . A = B+C;
26-1400 .
26-1401 . if (A < = B)
26-1402 . {
26-1403 . A = B + C;
26-1404 . D = E + F;
26-1405 . }
26-1406 .
26-1407 . A = B-C;
26-1408 . A = B+C;
26-1409 . A = B+C;
26-1410 .
26-1411 . if (A eq B)
26-1412 . {
26-1413 . A = B + C;
26-1414 . D = E + F;
26-1415 . }
26-1416 .
26-1417 . A = B*C;
26-1418 . A = B-C;
26-1419 . A = 0x0006;
26-1420 .
26-1421 . if (A < = B)
26-1422 . {
26-1423 . A = B + C;
26-1424 . D = E + F;
26-1425 . }
26-1426 .
26-1427 .
26-1428 . if (A ge B)
26-1429 . {
26-1430 . A = B + C;
26-1431 . D = E + F;
26-1432 . }
26-1433 .
26-1434 .
26-1435 . if (A > B)
26-1436 . {
26-1437 . A = B + C;
26-1438 . D = E + F;
26-1439 . }
26-1440 .
26-1441 . /* LE SV TOC-1842 this is a hmi-03.8.51 req to convert*/
26-1442 . A = B+C;
26-1443 . A = B*C;
26-1444 . A = B*C;
26-1445 . A = B+C;
26-1446 . A = B*C;
26-1447 .
26-1448 . if (A > B)
26-1449 . {
26-1450 . A = B + C;
26-1451 . D = E + F;
26-1452 . }
26-1453 .
26-1454 . A = B*C;
26-1455 . A = B/C;
26-1456 . A = B+C;
26-1457 . A = B/C;
26-1458 .
26-1459 . if (A < B)
26-1460 . {
26-1461 . A = B + C;
26-1462 . D = E + F;
26-1463 . }
26-1464 .
26-1465 .
26-1466 . if (A > = B)
26-1467 . {
26-1468 . A = B + C;
26-1469 . D = E + F;
26-1470 . }
26-1471 .
26-1472 .
26-1473 . if (A > = B)
26-1474 . {
26-1475 . A = B + C;
26-1476 . D = E + F;
26-1477 . }
26-1478 .
26-1479 . A = B/C;
26-1480 . A = B/C;
26-1481 . A = B*C;
26-1482 . // max LOC 66
26-1483 .
26-1484 . }
26-1485 .
26-1486 .
26-1487 . /*
26-1488 . -----------------------------------------------------------------------------
26-1489 . --| NAME: hmi.3.9
26-1490 . --|
26-1491 . --| ABSTRACT:
26-1492 . --| This function does hmi stuff.
26-1493 . --|
26-1494 . --| RETURNS:
26-1495 . --| NONE.
26-1496 . --|
26-1497 . ----------------------------------------------------------------------------
26-1498 . */
26-1499 . static void hmi.3.9(void)
26-1500 . {
26-1501 . A = B-C;
26-1502 .
26-1503 . switch (hmi stuff)
26-1504 . {
26-1505 . case one:
26-1506 . {
26-1507 . run_this;
26-1508 . break;
26-1509 . }
26-1510 . case two:
26-1511 . {
26-1512 . run_this;
26-1513 . break;
26-1514 . }
26-1515 . // missing default
26-1516 . }
26-1517 .
26-1518 . A = B*C;
26-1519 . A = B-C;
26-1520 . A = B+C;
26-1521 .
26-1522 . if (A < = B)
26-1523 . {
26-1524 . A = B + C;
26-1525 . D = E + F;
26-1526 . }
26-1527 .
26-1528 .
26-1529 . if (A == B)
26-1530 . {
26-1531 . A = B + C;
26-1532 . D = E + F;
26-1533 . }
26-1534 .
26-1535 . A = B-C;
26-1536 .
26-1537 . switch (hmi stuff)
26-1538 . {
26-1539 . case one:
26-1540 . {
26-1541 . run_this;
26-1542 . // missing break
26-1543 . }
26-1544 . case two:
26-1545 . {
26-1546 . run_this;
26-1547 . break;
26-1548 . }
26-1549 . default:
26-1550 . {
26-1551 . SwError;
26-1552 . }
26-1553 . }
26-1554 .
26-1555 . A = B+C;
26-1556 .
26-1557 . if (A eq B)
26-1558 . {
26-1559 . A = B + C;
26-1560 . D = E + F;
26-1561 . }
26-1562 .
26-1563 .
26-1564 . if (A ge B)
26-1565 . {
26-1566 . A = B + C;
26-1567 . D = E + F;
26-1568 . }
26-1569 .
26-1570 . A = B-C;
26-1571 .
26-1572 . if (A lt B)
26-1573 . {
26-1574 . A = B + C;
26-1575 . D = E + F;
26-1576 . }
26-1577 .
26-1578 . A = B*C;
26-1579 . A = B*C;
26-1580 . A = B*C;
26-1581 .
26-1582 . if (A < B)
26-1583 . {
26-1584 . A = B + C;
26-1585 . D = E + F;
26-1586 . }
26-1587 .
26-1588 . A = B/C;
26-1589 . A = B-C;
26-1590 .
26-1591 . if (A != B)
26-1592 . {
26-1593 . A = B + C;
26-1594 . D = E + F;
26-1595 . }
26-1596 .
26-1597 .
26-1598 . if (A != B)
26-1599 . {
26-1600 . A = B + C;
26-1601 . D = E + F;
26-1602 . }
26-1603 .
26-1604 .
26-1605 . if (A eq B)
26-1606 . {
26-1607 . A = B + C;
26-1608 . D = E + F;
26-1609 . }
26-1610 .
26-1611 . A = B-C;
26-1612 .
26-1613 . if (A le B)
26-1614 . {
26-1615 . A = B + C;
26-1616 . D = E + F;
26-1617 . }
26-1618 .
26-1619 .
26-1620 . if {
26-1621 . X = Y + Z;
26-1622 . }
26-1623 . else {
26-1624 . halt;
26-1625 . }
26-1626 .
26-1627 . A = B-C;
26-1628 .
26-1629 . if (A lt B)
26-1630 . {
26-1631 . A = B + C;
26-1632 . D = E + F;
26-1633 . }
26-1634 .
26-1635 . A = B/C;
26-1636 .
26-1637 . if (A le B)
26-1638 . {
26-1639 . A = B + C;
26-1640 . D = E + F;
26-1641 . }
26-1642 .
26-1643 . /* LE SV TOC-1843 this is a hmi-03.9.28 req to compare*/
26-1644 . A = B+C;
26-1645 . A = B/C;
26-1646 . A = B/C;
26-1647 . A = B+C;
26-1648 . /* LE SV TOC-1844 this is a hmi-03.9.32 req to transform*/
26-1649 .
26-1650 . if (A != B)
26-1651 . {
26-1652 . A = B + C;
26-1653 . D = E + F;
26-1654 . }
26-1655 .
26-1656 . A = B+C;
26-1657 . /* LE SV TOC-1845 this is a hmi-03.9.34 req to check unix*/
26-1658 .
26-1659 . if (A eq B)
26-1660 . {
26-1661 . A = B + C;
26-1662 . D = E + F;
26-1663 . }
26-1664 .
26-1665 .
26-1666 . switch (hmi stuff)
26-1667 . {
26-1668 . case one:
26-1669 . {
26-1670 . run_this;
26-1671 . break;
26-1672 . }
26-1673 . case two:
26-1674 . {
26-1675 . run_this;
26-1676 . break;
26-1677 . }
26-1678 . default:
26-1679 . {
26-1680 . SwError;
26-1681 . }
26-1682 . }
26-1683 .
26-1684 . A = B-C;
26-1685 . A = B*C;
26-1686 . A = B-C;
26-1687 . A = B*C;
26-1688 . A = B-C;
26-1689 . A = B/C;
26-1690 . A = B+C;
26-1691 .
26-1692 . if (A eq B)
26-1693 . {
26-1694 . A = B + C;
26-1695 . D = E + F;
26-1696 . }
26-1697 .
26-1698 . A = B-C;
26-1699 . A = B/C;
26-1700 .
26-1701 . switch (hmi stuff)
26-1702 . {
26-1703 . case one:
26-1704 . {
26-1705 . run_this;
26-1706 . break;
26-1707 . }
26-1708 . case two:
26-1709 . {
26-1710 . run_this;
26-1711 . break;
26-1712 . }
26-1713 . default:
26-1714 . {
26-1715 . SwError;
26-1716 . }
26-1717 . }
26-1718 .
26-1719 . A = B*C;
26-1720 . A = B/C;
26-1721 .
26-1722 . if (A eq B)
26-1723 . {
26-1724 . A = B + C;
26-1725 . D = E + F;
26-1726 . }
26-1727 .
26-1728 .
26-1729 . if (A gt B)
26-1730 . {
26-1731 . A = B + C;
26-1732 . D = E + F;
26-1733 . }
26-1734 .
26-1735 . A = B*C;
26-1736 . A = B-C;
26-1737 . A = B/C;
26-1738 . A = B+C;
26-1739 .
26-1740 . if (A == B)
26-1741 . {
26-1742 . A = B + C;
26-1743 . D = E + F;
26-1744 . }
26-1745 .
26-1746 . A = B/C;
26-1747 . A = B+C;
26-1748 . A = B-C;
26-1749 . A = B*C;
26-1750 . A = B/C;
26-1751 . A = B*C;
26-1752 . A = B*C;
26-1753 . A = B-C;
26-1754 . A = B-C;
26-1755 . A = B-C;
26-1756 .
26-1757 . if (A < B)
26-1758 . {
26-1759 . A = B + C;
26-1760 . D = E + F;
26-1761 . }
26-1762 .
26-1763 . A = B+C;
26-1764 . A = B/C;
26-1765 .
26-1766 . if (A eq B)
26-1767 . {
26-1768 . A = B + C;
26-1769 . D = E + F;
26-1770 . }
26-1771 .
26-1772 . A = B+C;
26-1773 . A = B*C;
26-1774 . A = B/C;
26-1775 .
26-1776 . if (A ne B)
26-1777 . {
26-1778 . A = B + C;
26-1779 . D = E + F;
26-1780 . }
26-1781 .
26-1782 .
26-1783 . if (A < B)
26-1784 . {
26-1785 . A = B + C;
26-1786 . D = E + F;
26-1787 . }
26-1788 .
26-1789 .
26-1790 . if (A ne B)
26-1791 . {
26-1792 . A = B + C;
26-1793 . D = E + F;
26-1794 . }
26-1795 .
26-1796 . A = B+C;
26-1797 . // max LOC 76
26-1798 .
26-1799 . }
26-1800 .
26-1801 .
26-1802 . /*
26-1803 . -----------------------------------------------------------------------------
26-1804 . --| NAME: hmi.3.10
26-1805 . --|
26-1806 . --| ABSTRACT:
26-1807 . --| This function does hmi stuff.
26-1808 . --|
26-1809 . --| RETURNS:
26-1810 . --| NONE.
26-1811 . --|
26-1812 . ----------------------------------------------------------------------------
26-1813 . */
26-1814 . static void hmi.3.10(void)
26-1815 . {
26-1816 .
26-1817 . switch (hmi stuff)
26-1818 . {
26-1819 . case one:
26-1820 . {
26-1821 . run_this;
26-1822 . break;
26-1823 . }
26-1824 . case two:
26-1825 . {
26-1826 . run_this;
26-1827 . break;
26-1828 . }
26-1829 . default:
26-1830 . {
26-1831 . SwError;
26-1832 . }
26-1833 . }
26-1834 .
26-1835 . A = B-C;
26-1836 .
26-1837 . if (A gt B)
26-1838 . {
26-1839 . A = B + C;
26-1840 . D = E + F;
26-1841 . }
26-1842 .
26-1843 . A = B+C;
26-1844 . A = B/C;
26-1845 . do forever;
26-1846 . A = B*C;
26-1847 . A = B-C;
26-1848 . A = B+C;
26-1849 . A = B+C;
26-1850 . A = B/C;
26-1851 . A = B/C;
26-1852 . A = B-C;
26-1853 .
26-1854 . if (A le B)
26-1855 . {
26-1856 . A = B + C;
26-1857 . D = E + F;
26-1858 . }
26-1859 .
26-1860 . A = B-C;
26-1861 . A = B*C;
26-1862 . A = B/C;
26-1863 . A = B*C;
26-1864 . /* LE SV TOC-1846 this is a hmi-03.10.18 req to call isr*/
26-1865 . A = B-C;
26-1866 . /* LE SV TOC-1847 this is a hmi-03.10.19 req to set Real Time Clock*/
26-1867 . A = B-C;
26-1868 . A = B*C;
26-1869 .
26-1870 . if (A == B)
26-1871 . {
26-1872 . A = B + C;
26-1873 . D = E + F;
26-1874 . }
26-1875 .
26-1876 .
26-1877 . if (A le B)
26-1878 . {
26-1879 . A = B + C;
26-1880 . D = E + F;
26-1881 . }
26-1882 .
26-1883 . A = B+C;
26-1884 . A = B/C;
26-1885 . A = B-C;
26-1886 . A = 0x0007;
26-1887 .
26-1888 . if (A le B)
26-1889 . {
26-1890 . A = B + C;
26-1891 . D = E + F;
26-1892 . }
26-1893 .
26-1894 . A = B-C;
26-1895 . A = B/C;
26-1896 .
26-1897 . if (A < B)
26-1898 . {
26-1899 . A = B + C;
26-1900 . D = E + F;
26-1901 . }
26-1902 .
26-1903 . A = B*C;
26-1904 . A = B*C;
26-1905 .
26-1906 . if ($hmi stuff > $otherhmi stuff)
26-1907 . /* LE SV TOC-008 we really should log all error calls */
26-1908 . {
26-1909 . A = B + C;
26-1910 . }
26-1911 .
26-1912 . A = B/C;
26-1913 . A = B*C;
26-1914 .
26-1915 . if (A eq B)
26-1916 . {
26-1917 . A = B + C;
26-1918 . D = E + F;
26-1919 . }
26-1920 .
26-1921 . A = B+C;
26-1922 .
26-1923 . if (A eq B)
26-1924 . {
26-1925 . A = B + C;
26-1926 . D = E + F;
26-1927 . }
26-1928 .
26-1929 . A = B+C;
26-1930 . A = B*C;
26-1931 . do forever;
26-1932 . A = B+C;
26-1933 . /* LE SV TOC-1848 this is a hmi-03.10.40 req to detect error*/
26-1934 . A = B-C;
26-1935 . A = B/C;
26-1936 . A = B/C;
26-1937 . A = B*C;
26-1938 . A = B-C;
26-1939 . A = B-C;
26-1940 .
26-1941 . switch (hmi stuff)
26-1942 . {
26-1943 . case one:
26-1944 . {
26-1945 . run_this;
26-1946 . break;
26-1947 . }
26-1948 . case two:
26-1949 . {
26-1950 . run_this;
26-1951 . break;
26-1952 . }
26-1953 . default:
26-1954 . {
26-1955 . SwError;
26-1956 . }
26-1957 . }
26-1958 .
26-1959 . A = B/C;
26-1960 . A = B/C;
26-1961 .
26-1962 . if (A < B)
26-1963 . {
26-1964 . A = B + C;
26-1965 . D = E + F;
26-1966 . }
26-1967 .
26-1968 . A = B/C;
26-1969 . A = B-C;
26-1970 . A = B-C;
26-1971 .
26-1972 . if (A gt B)
26-1973 . {
26-1974 . A = B + C;
26-1975 . D = E + F;
26-1976 . }
26-1977 .
26-1978 . A = B*C;
26-1979 . A = B*C;
26-1980 . /* LE SV TOC-1849 this is a hmi-03.10.56 req to reject*/
26-1981 . // ??? go see ws
26-1982 . A = B+C;
26-1983 .
26-1984 . if (A lt B)
26-1985 . {
26-1986 . A = B + C;
26-1987 . D = E + F;
26-1988 . }
26-1989 .
26-1990 .
26-1991 . if (A > = B)
26-1992 . {
26-1993 . A = B + C;
26-1994 . D = E + F;
26-1995 . }
26-1996 .
26-1997 . /* LE SV TOC-1850 this is a hmi-03.10.59 req to reject*/
26-1998 . A = B+C;
26-1999 .
26-2000 . if (A > B)
26-2001 . {
26-2002 . A = B + C;
26-2003 . D = E + F;
26-2004 . }
26-2005 .
26-2006 . A = B-C;
26-2007 .
26-2008 . if (A != B)
26-2009 . {
26-2010 . A = B + C;
26-2011 . D = E + F;
26-2012 . }
26-2013 .
26-2014 . A = B/C;
26-2015 . A = B+C;
26-2016 .
26-2017 . if (A ge B)
26-2018 . {
26-2019 . A = B + C;
26-2020 . D = E + F;
26-2021 . }
26-2022 .
26-2023 . /* LE SV TOC-1851 this is a hmi-03.10.66 req to assign*/
26-2024 . A = B-C;
26-2025 .
26-2026 . switch (hmi stuff)
26-2027 . {
26-2028 . case one:
26-2029 . {
26-2030 . run_this;
26-2031 . break;
26-2032 . }
26-2033 . case two:
26-2034 . {
26-2035 . run_this;
26-2036 . break;
26-2037 . }
26-2038 . default:
26-2039 . {
26-2040 . // missing error call
26-2041 . }
26-2042 . }
26-2043 .
26-2044 .
26-2045 . if (A gt B)
26-2046 . {
26-2047 . A = B + C;
26-2048 . D = E + F;
26-2049 . }
26-2050 .
26-2051 . A = B/C;
26-2052 . A = B/C;
26-2053 .
26-2054 . switch (hmi stuff)
26-2055 . {
26-2056 . case one:
26-2057 . {
26-2058 . run_this;
26-2059 . break;
26-2060 . }
26-2061 . case two:
26-2062 . {
26-2063 . run_this;
26-2064 . break;
26-2065 . }
26-2066 . default:
26-2067 . {
26-2068 . SwError;
26-2069 . }
26-2070 . }
26-2071 .
26-2072 . A = B/C;
26-2073 . A = B-C;
26-2074 . // max LOC 72
26-2075 .
26-2076 . }
26-2077 .
26-2078 .
26-2079 . /*
26-2080 . -----------------------------------------------------------------------------
26-2081 . --| NAME: hmi.3.11
26-2082 . --|
26-2083 . --| ABSTRACT:
26-2084 . --| This function does hmi stuff.
26-2085 . --|
26-2086 . --| RETURNS:
26-2087 . --| NONE.
26-2088 . --|
26-2089 . ----------------------------------------------------------------------------
26-2090 . */
26-2091 . static void hmi.3.11(void)
26-2092 . {
26-2093 .
26-2094 . if (A ne B)
26-2095 . {
26-2096 . A = B + C;
26-2097 . D = E + F;
26-2098 . }
26-2099 .
26-2100 . A = B-C;
26-2101 . A = B/C;
26-2102 .
26-2103 . if (A == B)
26-2104 . {
26-2105 . A = B + C;
26-2106 . D = E + F;
26-2107 . }
26-2108 .
26-2109 .
26-2110 . if (A < B)
26-2111 . {
26-2112 . A = B + C;
26-2113 . D = E + F;
26-2114 . }
26-2115 .
26-2116 . A = B/C;
26-2117 .
26-2118 . if (A ne B)
26-2119 . {
26-2120 . A = B + C;
26-2121 . D = E + F;
26-2122 . }
26-2123 .
26-2124 . A = B-C;
26-2125 . A = B*C;
26-2126 . A = B-C;
26-2127 .
26-2128 . if (A le B)
26-2129 . {
26-2130 . A = B + C;
26-2131 . D = E + F;
26-2132 . }
26-2133 .
26-2134 . A = B-C;
26-2135 . A = B*C;
26-2136 . A = B*C;
26-2137 . /* LE SV TOC-1852 this is a hmi-03.11.15 req to set Real Time Clock*/
26-2138 .
26-2139 . if (A ne B)
26-2140 . {
26-2141 . A = B + C;
26-2142 . D = E + F;
26-2143 . }
26-2144 .
26-2145 . A = B*C;
26-2146 .
26-2147 . switch (hmi stuff)
26-2148 . {
26-2149 . case one:
26-2150 . {
26-2151 . run_this;
26-2152 . break;
26-2153 . }
26-2154 . case two:
26-2155 . {
26-2156 . run_this;
26-2157 . break;
26-2158 . }
26-2159 . default:
26-2160 . {
26-2161 . SwError;
26-2162 . }
26-2163 . }
26-2164 .
26-2165 .
26-2166 . if (A == B)
26-2167 . {
26-2168 . A = B + C;
26-2169 . D = E + F;
26-2170 . }
26-2171 .
26-2172 . A = B*C;
26-2173 . A = B/C;
26-2174 .
26-2175 . if (A < B)
26-2176 . {
26-2177 . A = B + C;
26-2178 . D = E + F;
26-2179 . }
26-2180 .
26-2181 .
26-2182 . if (A != B)
26-2183 . {
26-2184 . A = B + C;
26-2185 . D = E + F;
26-2186 . }
26-2187 .
26-2188 . A = B+C;
26-2189 .
26-2190 . if (A lt B)
26-2191 . {
26-2192 . A = B + C;
26-2193 . D = E + F;
26-2194 . }
26-2195 .
26-2196 . A = B+C;
26-2197 . /* LE SV TOC-1853 this is a hmi-03.11.26 req to reject*/
26-2198 . A = (float)B + C;
26-2199 . A = B*C;
26-2200 . A = B*C;
26-2201 .
26-2202 . /* dead_block = C * D;
26-2203 . dead_block = E * F; */
26-2204 .
26-2205 .
26-2206 . if (A eq B)
26-2207 . {
26-2208 . A = B + C;
26-2209 . D = E + F;
26-2210 . }
26-2211 .
26-2212 . A = B/C;
26-2213 .
26-2214 . if (A ge B)
26-2215 . {
26-2216 . A = B + C;
26-2217 . D = E + F;
26-2218 . }
26-2219 .
26-2220 . A = B-C;
26-2221 .
26-2222 . if (A == B)
26-2223 . {
26-2224 . A = B + C;
26-2225 . D = E + F;
26-2226 . }
26-2227 .
26-2228 .
26-2229 . if (A != B)
26-2230 . {
26-2231 . A = B + C;
26-2232 . D = E + F;
26-2233 . }
26-2234 .
26-2235 . A = B+C;
26-2236 . A = B*C;
26-2237 . A = B+C;
26-2238 . A = B+C;
26-2239 .
26-2240 . switch (hmi stuff)
26-2241 . {
26-2242 . case one:
26-2243 . {
26-2244 . run_this;
26-2245 . break;
26-2246 . }
26-2247 . case two:
26-2248 . {
26-2249 . run_this;
26-2250 . break;
26-2251 . }
26-2252 . default:
26-2253 . {
26-2254 . SwError;
26-2255 . }
26-2256 . }
26-2257 .
26-2258 . A = B-C;
26-2259 .
26-2260 . if (A > B)
26-2261 . {
26-2262 . A = B + C;
26-2263 . D = E + F;
26-2264 . }
26-2265 .
26-2266 . A = B/C;
26-2267 . A = B/C;
26-2268 . A = B-C;
26-2269 .
26-2270 . if (A < = B)
26-2271 . {
26-2272 . A = B + C;
26-2273 . D = E + F;
26-2274 . }
26-2275 .
26-2276 . A = B/C;
26-2277 . A = B-C;
26-2278 . A = B/C;
26-2279 . // max LOC 47
26-2280 .
26-2281 . }
26-2282 .
26-2283 .
26-2284 . /*
26-2285 . -----------------------------------------------------------------------------
26-2286 . --| NAME: hmi.3.12
26-2287 . --|
26-2288 . --| ABSTRACT:
26-2289 . --| This function does hmi stuff.
26-2290 . --|
26-2291 . --| RETURNS:
26-2292 . --| NONE.
26-2293 . --|
26-2294 . ----------------------------------------------------------------------------
26-2295 . */
26-2296 . static void hmi.3.12(void)
26-2297 . {
26-2298 .
26-2299 . if (A ne B)
26-2300 . {
26-2301 . A = B + C;
26-2302 . D = E + F;
26-2303 . }
26-2304 .
26-2305 . FreePtr = HmiStringPtr;
26-2306 . A = B-C;
26-2307 .
26-2308 . if (A ne B)
26-2309 . {
26-2310 . A = B + C;
26-2311 . D = E + F;
26-2312 . }
26-2313 .
26-2314 . /* LE SV TOC-1854 this is a hmi-03.12.4 req to validate*/
26-2315 . A = B*C;
26-2316 . A = B-C;
26-2317 . A = B/C;
26-2318 . A = B*C;
26-2319 . A = B*C;
26-2320 . A = B/C;
26-2321 . FreePtr = HmiStringPtr;
26-2322 . A = B+C;
26-2323 . /* LE SV TOC-1855 this is a hmi-03.12.11 req to detect error*/
26-2324 . A = B-C;
26-2325 . A = B+C;
26-2326 .
26-2327 . if (A eq B)
26-2328 . {
26-2329 . A = B + C;
26-2330 . D = E + F;
26-2331 . }
26-2332 .
26-2333 . A = B-C;
26-2334 . /* LE SV TOC-1856 this is a hmi-03.12.15 req to verify*/
26-2335 . A = B-C;
26-2336 . A = B-C;
26-2337 . A = B-C;
26-2338 . A = B/C;
26-2339 .
26-2340 . if (A eq B)
26-2341 . {
26-2342 . A = B + C;
26-2343 . D = E + F;
26-2344 . }
26-2345 .
26-2346 . A = B/C;
26-2347 . A = B/C;
26-2348 . A = B/C;
26-2349 . // TBS - I need to figure this out
26-2350 . A = B/C;
26-2351 . A = B*C;
26-2352 . A = B/C;
26-2353 . A = B+C;
26-2354 . free(FreePtr);
26-2355 .
26-2356 . switch (hmi stuff)
26-2357 . {
26-2358 . case one:
26-2359 . {
26-2360 . run_this;
26-2361 . break;
26-2362 . }
26-2363 . case two:
26-2364 . {
26-2365 . run_this;
26-2366 . break;
26-2367 . }
26-2368 . default:
26-2369 . {
26-2370 . SwError;
26-2371 . }
26-2372 . }
26-2373 .
26-2374 . A = B/C;
26-2375 . A = B/C;
26-2376 . A = B/C;
26-2377 . A = B/C;
26-2378 . A = B-C;
26-2379 . A = 0x0003;
26-2380 . A = B/C;
26-2381 . A = B/C;
26-2382 . A = B*C;
26-2383 .
26-2384 . if (A > B)
26-2385 . {
26-2386 . A = B + C;
26-2387 . D = E + F;
26-2388 . }
26-2389 .
26-2390 .
26-2391 . if (A eq B)
26-2392 . {
26-2393 . A = B + C;
26-2394 . D = E + F;
26-2395 . }
26-2396 .
26-2397 .
26-2398 . if (A != B)
26-2399 . {
26-2400 . A = B + C;
26-2401 . D = E + F;
26-2402 . }
26-2403 .
26-2404 . A = B-C;
26-2405 . A = B+C;
26-2406 . A = B*C;
26-2407 .
26-2408 . if (A le B)
26-2409 . {
26-2410 . A = B + C;
26-2411 . D = E + F;
26-2412 . }
26-2413 .
26-2414 . A = B*C;
26-2415 . A = B+C;
26-2416 . A = B/C;
26-2417 . A = B-C;
26-2418 .
26-2419 . if (A ne B)
26-2420 . {
26-2421 . A = B + C;
26-2422 . D = E + F;
26-2423 . }
26-2424 .
26-2425 . /* LE SV TOC-1857 this is a hmi-03.12.48 req to set Real Time Clock*/
26-2426 .
26-2427 . if (A le B)
26-2428 . {
26-2429 . A = B + C;
26-2430 . D = E + F;
26-2431 . }
26-2432 .
26-2433 .
26-2434 . if (A eq B)
26-2435 . {
26-2436 . A = B + C;
26-2437 . D = E + F;
26-2438 . }
26-2439 .
26-2440 . A = B/C;
26-2441 .
26-2442 . if (A le B)
26-2443 . {
26-2444 . A = B + C;
26-2445 . D = E + F;
26-2446 . }
26-2447 .
26-2448 . A = B/C;
26-2449 . A = B+C;
26-2450 .
26-2451 . if (A gt B)
26-2452 . {
26-2453 . A = B + C;
26-2454 . D = E + F;
26-2455 . }
26-2456 .
26-2457 . A = (long)B + C;
26-2458 .
26-2459 . if (A == B)
26-2460 . {
26-2461 . A = B + C;
26-2462 . D = E + F;
26-2463 . }
26-2464 .
26-2465 . A = B-C;
26-2466 . A = B-C;
26-2467 .
26-2468 . if (A != B)
26-2469 . {
26-2470 . A = B + C;
26-2471 . D = E + F;
26-2472 . }
26-2473 .
26-2474 . A = B/C;
26-2475 . A = B+C;
26-2476 . /* LE SV TOC-1858 this is a hmi-03.12.61 req to audit*/
26-2477 . A = B+C;
26-2478 . A = B+C;
26-2479 .
26-2480 . if (A le B)
26-2481 . {
26-2482 . A = B + C;
26-2483 . D = E + F;
26-2484 . }
26-2485 .
26-2486 . A = B*C;
26-2487 . A = B/C;
26-2488 . A = B-C;
26-2489 . A = B-C;
26-2490 .
26-2491 . if (A < = B)
26-2492 . {
26-2493 . A = B + C;
26-2494 . D = E + F;
26-2495 . }
26-2496 .
26-2497 .
26-2498 . if (A < B)
26-2499 . {
26-2500 . A = B + C;
26-2501 . D = E + F;
26-2502 . }
26-2503 .
26-2504 . A = B+C;
26-2505 . A = B/C;
26-2506 . A = B+C;
26-2507 . A = B-C;
26-2508 . A = B/C;
26-2509 . A = B*C;
26-2510 .
26-2511 . if (A le B)
26-2512 . {
26-2513 . A = B + C;
26-2514 . D = E + F;
26-2515 . }
26-2516 .
26-2517 . /* LE SV TOC-1859 this is a hmi-03.12.77 req to store*/
26-2518 .
26-2519 . switch (hmi stuff)
26-2520 . {
26-2521 . case one:
26-2522 . {
26-2523 . run_this;
26-2524 . break;
26-2525 . }
26-2526 . case two:
26-2527 . {
26-2528 . run_this;
26-2529 . break;
26-2530 . }
26-2531 . default:
26-2532 . {
26-2533 . SwError;
26-2534 . }
26-2535 . }
26-2536 .
26-2537 . A = B*C;
26-2538 . A = B-C;
26-2539 .
26-2540 . if (A > B)
26-2541 . {
26-2542 . A = B + C;
26-2543 . D = E + F;
26-2544 . }
26-2545 .
26-2546 .
26-2547 . if (A == B)
26-2548 . {
26-2549 . A = B + C;
26-2550 . D = E + F;
26-2551 . }
26-2552 .
26-2553 .
26-2554 . if (A lt B)
26-2555 . {
26-2556 . A = B + C;
26-2557 . D = E + F;
26-2558 . }
26-2559 .
26-2560 . A = B*C;
26-2561 . A = B/C;
26-2562 . A = B-C;
26-2563 .
26-2564 . if (A > B)
26-2565 . {
26-2566 . A = B + C;
26-2567 . D = E + F;
26-2568 . }
26-2569 .
26-2570 . A = B+C;
26-2571 .
26-2572 . if (A eq B)
26-2573 . {
26-2574 . A = B + C;
26-2575 . D = E + F;
26-2576 . }
26-2577 .
26-2578 .
26-2579 . if (A == B)
26-2580 . {
26-2581 . A = B + C;
26-2582 . D = E + F;
26-2583 . }
26-2584 .
26-2585 .
26-2586 . if (A lt B)
26-2587 . {
26-2588 . A = B + C;
26-2589 . D = E + F;
26-2590 . }
26-2591 .
26-2592 .
26-2593 . if (A lt B)
26-2594 . {
26-2595 . A = B + C;
26-2596 . D = E + F;
26-2597 . }
26-2598 .
26-2599 . A = B-C;
26-2600 . A = B/C;
26-2601 . // max LOC 93
26-2602 .
26-2603 . }
26-2604 .
26-2605 .
26-2606 . /*
26-2607 . -----------------------------------------------------------------------------
26-2608 . --| NAME: hmi.3.13
26-2609 . --|
26-2610 . --| ABSTRACT:
26-2611 . --| This function does hmi stuff.
26-2612 . --|
26-2613 . --| RETURNS:
26-2614 . --| NONE.
26-2615 . --|
26-2616 . ----------------------------------------------------------------------------
26-2617 . */
26-2618 . static void hmi.3.13(void)
26-2619 . {
26-2620 . A = B/C;
26-2621 . A = B*C;
26-2622 . send_buffer = (U16 *) malloc(size+1);
26-2623 .
26-2624 . switch (hmi stuff)
26-2625 . {
26-2626 . case one:
26-2627 . {
26-2628 . run_this;
26-2629 . break;
26-2630 . }
26-2631 . case two:
26-2632 . {
26-2633 . run_this;
26-2634 . break;
26-2635 . }
26-2636 . default:
26-2637 . {
26-2638 . SwError;
26-2639 . }
26-2640 . }
26-2641 .
26-2642 . A = B*C;
26-2643 . A = B*C;
26-2644 .
26-2645 . if (A eq B)
26-2646 . {
26-2647 . A = B + C;
26-2648 . D = E + F;
26-2649 . }
26-2650 .
26-2651 . A = B-C;
26-2652 . do forever;
26-2653 . A = B-C;
26-2654 . A = B/C;
26-2655 .
26-2656 . if (A gt B)
26-2657 . {
26-2658 . A = B + C;
26-2659 . D = E + F;
26-2660 . }
26-2661 .
26-2662 . A = B+C;
26-2663 . A = B/C;
26-2664 . A = B/C;
26-2665 . A = B-C;
26-2666 .
26-2667 . if (A < B)
26-2668 . {
26-2669 . A = B + C;
26-2670 . D = E + F;
26-2671 . }
26-2672 .
26-2673 . A = B/C;
26-2674 .
26-2675 . if (A lt B)
26-2676 . {
26-2677 . A = B + C;
26-2678 . D = E + F;
26-2679 . }
26-2680 .
26-2681 .
26-2682 . if (A lt B)
26-2683 . {
26-2684 . A = B + C;
26-2685 . D = E + F;
26-2686 . }
26-2687 .
26-2688 . A = B+C;
26-2689 .
26-2690 . if (A < = B)
26-2691 . {
26-2692 . A = B + C;
26-2693 . D = E + F;
26-2694 . }
26-2695 .
26-2696 .
26-2697 . if (A le B)
26-2698 . {
26-2699 . A = B + C;
26-2700 . D = E + F;
26-2701 . }
26-2702 .
26-2703 . A = B-C;
26-2704 . A = B+C;
26-2705 . A = B+C;
26-2706 . A = B*C;
26-2707 . A = B*C;
26-2708 . A = B*C;
26-2709 . A = B/C;
26-2710 . A = B/C;
26-2711 . A = B-C;
26-2712 . A = B/C;
26-2713 .
26-2714 . if (A < = B)
26-2715 . {
26-2716 . A = B + C;
26-2717 . D = E + F;
26-2718 . }
26-2719 .
26-2720 . A = 0x0009;
26-2721 . A = B+C;
26-2722 . A = B-C;
26-2723 . A = B-C;
26-2724 .
26-2725 . if (A > B)
26-2726 . {
26-2727 . A = B + C;
26-2728 . D = E + F;
26-2729 . }
26-2730 .
26-2731 . A = B+C;
26-2732 . A = B+C;
26-2733 . A = B/C;
26-2734 . A = B-C;
26-2735 . A = B-C;
26-2736 . A = B+C;
26-2737 .
26-2738 . if (A gt B)
26-2739 . {
26-2740 . A = B + C;
26-2741 . D = E + F;
26-2742 . }
26-2743 .
26-2744 . A = B*C;
26-2745 . A = B/C;
26-2746 . A = B/C;
26-2747 .
26-2748 . if (A lt B)
26-2749 . {
26-2750 . A = B + C;
26-2751 . D = E + F;
26-2752 . }
26-2753 .
26-2754 . A = B*C;
26-2755 . A = B*C;
26-2756 . A = B-C;
26-2757 . A = B-C;
26-2758 .
26-2759 . if (A < = B)
26-2760 . {
26-2761 . A = B + C;
26-2762 . D = E + F;
26-2763 . }
26-2764 .
26-2765 .
26-2766 . if (A ge B)
26-2767 . {
26-2768 . A = B + C;
26-2769 . D = E + F;
26-2770 . }
26-2771 .
26-2772 . A = B/C;
26-2773 .
26-2774 . if (A == B)
26-2775 . {
26-2776 . A = B + C;
26-2777 . D = E + F;
26-2778 . }
26-2779 .
26-2780 . A = B*C;
26-2781 . A = B-C;
26-2782 .
26-2783 . if (A le B)
26-2784 . {
26-2785 . A = B + C;
26-2786 . D = E + F;
26-2787 . }
26-2788 .
26-2789 .
26-2790 . if (A lt B)
26-2791 . {
26-2792 . A = B + C;
26-2793 . D = E + F;
26-2794 . }
26-2795 .
26-2796 . A = B-C;
26-2797 . A = B-C;
26-2798 . A = B/C;
26-2799 .
26-2800 . if (A != B)
26-2801 . {
26-2802 . A = B + C;
26-2803 . D = E + F;
26-2804 . }
26-2805 .
26-2806 . A = B/C;
26-2807 .
26-2808 . switch (hmi stuff)
26-2809 . {
26-2810 . case one:
26-2811 . {
26-2812 . run_this;
26-2813 . // missing break
26-2814 . }
26-2815 . case two:
26-2816 . {
26-2817 . run_this;
26-2818 . break;
26-2819 . }
26-2820 . default:
26-2821 . {
26-2822 . SwError;
26-2823 . }
26-2824 . }
26-2825 .
26-2826 . A = B+C;
26-2827 . A = B-C;
26-2828 . A = B+C;
26-2829 . A = B+C;
26-2830 . A = B*C;
26-2831 . /* LE SV TOC-1860 this is a hmi-03.13.70 req to detect error*/
26-2832 . A = 0x0004;
26-2833 . A = B*C;
26-2834 . // max LOC 70
26-2835 .
26-2836 . }
26-2837 .
26 26 Result: result/source/ft-app/ft-app-B1.1/hmi/hmi-03.c
27 27 Source: source/ft-app/ft-app-B1.1/hmi/hmi-04.c
27-0 . /*
27-1 . ----------------------------------------------------------------------------
27-2 . --| BEGIN PROLOGUE
27-3 . --|
27-4 . --| CLASSIFICATION: UNCLASSIFIED
27-5 . --|
27-6 . --| FILE NAME: hmi-04.c
27-7 . --|
27-8 . --| ABSTRACT:
27-9 . --| This file contains the 5 functions that do file hmi stuff.
27-10 . --|
27-11 . --| HISTORY:
27-12 . --| CCCQ_NAME:
27-13 . --| CCCQ_VER:
27-14 . --|
27-15 . --| END PROLOGUE
27-16 . ----------------------------------------------------------------------------
27-17 . */
27-18 .
27-19 . double C;
27-20 . #define A;
27-21 . #define D;
27-22 . #define A;
27-23 . #include A;
27-24 . #include D;
27-25 . #define D;
27-26 . #define B;
27-27 .
27-28 .
27-29 .
27-30 . /*
27-31 . -----------------------------------------------------------------------------
27-32 . --| NAME: hmi.4.1
27-33 . --|
27-34 . --| ABSTRACT:
27-35 . --| This function does hmi stuff.
27-36 . --|
27-37 . --| RETURNS:
27-38 . --| NONE.
27-39 . --|
27-40 . ----------------------------------------------------------------------------
27-41 . */
27-42 . static void hmi.4.1(void)
27-43 . {
27-44 .
27-45 . if (A lt B)
27-46 . {
27-47 . A = B + C;
27-48 . D = E + F;
27-49 . }
27-50 .
27-51 . A = B/C;
27-52 . A = B-C;
27-53 .
27-54 . if (A != B)
27-55 . {
27-56 . A = B + C;
27-57 . D = E + F;
27-58 . }
27-59 .
27-60 . /* LE SV TOC-1861 this is a hmi-04.1.5 req to disable*/
27-61 . A = B*C;
27-62 .
27-63 . if (A < B)
27-64 . {
27-65 . A = B + C;
27-66 . D = E + F;
27-67 . }
27-68 .
27-69 . A = B-C;
27-70 . A = B+C;
27-71 .
27-72 . switch (hmi stuff)
27-73 . {
27-74 . case one:
27-75 . {
27-76 . run_this;
27-77 . break;
27-78 . }
27-79 . case two:
27-80 . {
27-81 . run_this;
27-82 . break;
27-83 . }
27-84 . default:
27-85 . {
27-86 . // missing error call
27-87 . }
27-88 . }
27-89 .
27-90 . A = B*C;
27-91 . A = B-C;
27-92 . A = B*C;
27-93 . A = B/C;
27-94 .
27-95 . if (A ne B)
27-96 . {
27-97 . A = B + C;
27-98 . D = E + F;
27-99 . }
27-100 .
27-101 .
27-102 . if (A < B)
27-103 . {
27-104 . A = B + C;
27-105 . D = E + F;
27-106 . }
27-107 .
27-108 . A = B*C;
27-109 . A = B-C;
27-110 . A = B+C;
27-111 . A = B*C;
27-112 . // max LOC 18
27-113 .
27-114 . }
27-115 .
27-116 .
27-117 . /*
27-118 . -----------------------------------------------------------------------------
27-119 . --| NAME: hmi.4.2
27-120 . --|
27-121 . --| ABSTRACT:
27-122 . --| This function does hmi stuff.
27-123 . --|
27-124 . --| RETURNS:
27-125 . --| NONE.
27-126 . --|
27-127 . ----------------------------------------------------------------------------
27-128 . */
27-129 . static void hmi.4.2(void)
27-130 . {
27-131 .
27-132 . if (A ne B)
27-133 . {
27-134 . A = B + C;
27-135 . D = E + F;
27-136 . }
27-137 .
27-138 . A = B+C;
27-139 . A = 0x0007;
27-140 . A = B*C;
27-141 . A = B-C;
27-142 .
27-143 . if (A > = B)
27-144 . {
27-145 . A = B + C;
27-146 . D = E + F;
27-147 . }
27-148 .
27-149 . A = B*C;
27-150 . A = B*C;
27-151 . A = B*C;
27-152 .
27-153 . if (A > = B)
27-154 . {
27-155 . A = B + C;
27-156 . D = E + F;
27-157 . }
27-158 .
27-159 .
27-160 . switch (hmi stuff)
27-161 . {
27-162 . case one:
27-163 . {
27-164 . run_this;
27-165 . break;
27-166 . }
27-167 . case two:
27-168 . {
27-169 . run_this;
27-170 . break;
27-171 . }
27-172 . // missing default
27-173 . }
27-174 .
27-175 .
27-176 . if (A != B)
27-177 . {
27-178 . A = B + C;
27-179 . D = E + F;
27-180 . }
27-181 .
27-182 . A = B+C;
27-183 . /* LE SV TOC-1862 this is a hmi-04.2.12 req to transform*/
27-184 . A = B-C;
27-185 . A = B/C;
27-186 . A = B/C;
27-187 . A = B-C;
27-188 . A = B+C;
27-189 . A = B/C;
27-190 . goto error;
27-191 . A = B+C;
27-192 . A = B*C;
27-193 . A = B/C;
27-194 .
27-195 . if (A lt B)
27-196 . {
27-197 . A = B + C;
27-198 . D = E + F;
27-199 . }
27-200 .
27-201 .
27-202 . if (A le B)
27-203 . {
27-204 . A = B + C;
27-205 . D = E + F;
27-206 . }
27-207 .
27-208 . A = B+C;
27-209 . A = B/C;
27-210 .
27-211 . if (A == B)
27-212 . {
27-213 . A = B + C;
27-214 . D = E + F;
27-215 . }
27-216 .
27-217 .
27-218 . if (A > B)
27-219 . {
27-220 . A = B + C;
27-221 . D = E + F;
27-222 . }
27-223 .
27-224 . A = B/C;
27-225 . A = B/C;
27-226 . A = B*C;
27-227 . A = B*C;
27-228 . A = B+C;
27-229 .
27-230 . switch (hmi stuff)
27-231 . {
27-232 . case one:
27-233 . {
27-234 . run_this;
27-235 . break;
27-236 . }
27-237 . case two:
27-238 . {
27-239 . run_this;
27-240 . break;
27-241 . }
27-242 . default:
27-243 . {
27-244 . SwError;
27-245 . }
27-246 . }
27-247 .
27-248 . /* LE SV TOC-1863 this is a hmi-04.2.33 req to check unix*/
27-249 .
27-250 . if (A eq B)
27-251 . {
27-252 . A = B + C;
27-253 . D = E + F;
27-254 . }
27-255 .
27-256 . A = B*C;
27-257 . FreePtr = HmiStringPtr;
27-258 . A = B*C;
27-259 . A = B-C;
27-260 . // (P) this is really improtant
27-261 . A = B+C;
27-262 . A = B/C;
27-263 . A = B/C;
27-264 . A = B+C;
27-265 .
27-266 . /*
27-267 . dead_block = C * D;
27-268 . dead_block = E * F;
27-269 . */
27-270 .
27-271 .
27-272 . if (A ne B)
27-273 . {
27-274 . A = B + C;
27-275 . D = E + F;
27-276 . }
27-277 .
27-278 . A = B*C;
27-279 . /* LE SV TOC-1864 this is a hmi-04.2.43 req to audit*/
27-280 . A = B-C;
27-281 . A = B/C;
27-282 . A = B*C;
27-283 .
27-284 . if (A < = B)
27-285 . {
27-286 . A = B + C;
27-287 . D = E + F;
27-288 . }
27-289 .
27-290 .
27-291 . if (A eq B)
27-292 . {
27-293 . A = B + C;
27-294 . D = E + F;
27-295 . }
27-296 .
27-297 . A = B*C;
27-298 . A = B/C;
27-299 . A = B/C;
27-300 . A = B*C;
27-301 . A = B*C;
27-302 . A = B*C;
27-303 .
27-304 . if (A != B)
27-305 . {
27-306 . A = B + C;
27-307 . D = E + F;
27-308 . }
27-309 .
27-310 . A = B/C;
27-311 . A = B+C;
27-312 .
27-313 . switch (hmi stuff)
27-314 . {
27-315 . case one:
27-316 . {
27-317 . run_this;
27-318 . break;
27-319 . }
27-320 . case two:
27-321 . {
27-322 . run_this;
27-323 . break;
27-324 . }
27-325 . default:
27-326 . {
27-327 . // missing error call
27-328 . }
27-329 . }
27-330 .
27-331 .
27-332 . if (A < = B)
27-333 . {
27-334 . A = B + C;
27-335 . D = E + F;
27-336 . }
27-337 .
27-338 .
27-339 . if (A ge B)
27-340 . {
27-341 . A = B + C;
27-342 . D = E + F;
27-343 . }
27-344 .
27-345 .
27-346 . if (A ge B)
27-347 . {
27-348 . A = B + C;
27-349 . D = E + F;
27-350 . }
27-351 .
27-352 .
27-353 . if (A > = B)
27-354 . {
27-355 . A = B + C;
27-356 . D = E + F;
27-357 . }
27-358 .
27-359 . A = B*C;
27-360 .
27-361 . if (A ne B)
27-362 . {
27-363 . A = B + C;
27-364 . D = E + F;
27-365 . }
27-366 .
27-367 .
27-368 . if (A < = B)
27-369 . {
27-370 . A = B + C;
27-371 . D = E + F;
27-372 . }
27-373 .
27-374 . A = B-C;
27-375 . A = B+C;
27-376 . A = B+C;
27-377 . A = B*C;
27-378 . A = B/C;
27-379 .
27-380 . if (A gt B)
27-381 . {
27-382 . A = B + C;
27-383 . D = E + F;
27-384 . }
27-385 .
27-386 .
27-387 . if (A lt B)
27-388 . {
27-389 . A = B + C;
27-390 . D = E + F;
27-391 . }
27-392 .
27-393 . A = B+C;
27-394 . A = B-C;
27-395 . A = B-C;
27-396 . A = B-C;
27-397 . A = B*C;
27-398 . A = B-C;
27-399 . /* LE SV TOC-1865 this is a hmi-04.2.77 req to update*/
27-400 . A = B+C;
27-401 . A = (long)B + C;
27-402 . A = B*C;
27-403 . A = B-C;
27-404 . A = B/C;
27-405 . A = B-C;
27-406 .
27-407 . if (A == B)
27-408 . {
27-409 . A = B + C;
27-410 . D = E + F;
27-411 . }
27-412 .
27-413 . A = B/C;
27-414 .
27-415 . if (A le B)
27-416 . {
27-417 . A = B + C;
27-418 . D = E + F;
27-419 . }
27-420 .
27-421 .
27-422 . if (A > B)
27-423 . {
27-424 . A = B + C;
27-425 . D = E + F;
27-426 . }
27-427 .
27-428 . A = B-C;
27-429 .
27-430 . if (A lt B)
27-431 . {
27-432 . A = B + C;
27-433 . D = E + F;
27-434 . }
27-435 .
27-436 . A = B-C;
27-437 . A = B-C;
27-438 . A = B-C;
27-439 . A = B*C;
27-440 . A = B+C;
27-441 . A = B-C;
27-442 . // max LOC 93
27-443 .
27-444 . }
27-445 .
27-446 .
27-447 . /*
27-448 . -----------------------------------------------------------------------------
27-449 . --| NAME: hmi.4.3
27-450 . --|
27-451 . --| ABSTRACT:
27-452 . --| This function does hmi stuff.
27-453 . --|
27-454 . --| RETURNS:
27-455 . --| NONE.
27-456 . --|
27-457 . ----------------------------------------------------------------------------
27-458 . */
27-459 . static void hmi.4.3(void)
27-460 . {
27-461 . A = B*C;
27-462 . // TBD - what do I do now
27-463 . A = B*C;
27-464 . A = B-C;
27-465 . A = B/C;
27-466 . // TBD - what do I do now
27-467 . A = B*C;
27-468 . A = B+C;
27-469 .
27-470 . if (A lt B)
27-471 . {
27-472 . A = B + C;
27-473 . D = E + F;
27-474 . }
27-475 .
27-476 .
27-477 . if {
27-478 . X = Y + Z;
27-479 . }
27-480 . else {
27-481 . halt;
27-482 . }
27-483 .
27-484 .
27-485 . if (A ne B)
27-486 . {
27-487 . A = B + C;
27-488 . D = E + F;
27-489 . }
27-490 .
27-491 . A = 0x0006;
27-492 . A = B/C;
27-493 . A = B-C;
27-494 . A = B-C;
27-495 . A = B*C;
27-496 . A = B/C;
27-497 . A = B/C;
27-498 . A = B+C;
27-499 . A = B*C;
27-500 . A = B*C;
27-501 . A = B/C;
27-502 .
27-503 . if (A ne B)
27-504 . {
27-505 . A = B + C;
27-506 . D = E + F;
27-507 . }
27-508 .
27-509 .
27-510 . if (A lt B)
27-511 . {
27-512 . A = B + C;
27-513 . D = E + F;
27-514 . }
27-515 .
27-516 . A = B-C;
27-517 . A = B*C;
27-518 . A = B-C;
27-519 .
27-520 . if (A ge B)
27-521 . {
27-522 . A = B + C;
27-523 . D = E + F;
27-524 . }
27-525 .
27-526 .
27-527 . if (A ne B)
27-528 . {
27-529 . A = B + C;
27-530 . D = E + F;
27-531 . }
27-532 .
27-533 .
27-534 . switch (hmi stuff)
27-535 . {
27-536 . case one:
27-537 . {
27-538 . run_this;
27-539 . break;
27-540 . }
27-541 . case two:
27-542 . {
27-543 . run_this;
27-544 . break;
27-545 . }
27-546 . default:
27-547 . {
27-548 . SwError;
27-549 . }
27-550 . }
27-551 .
27-552 . A = B/C;
27-553 . A = B/C;
27-554 .
27-555 . if (A > = B)
27-556 . {
27-557 . A = B + C;
27-558 . D = E + F;
27-559 . }
27-560 .
27-561 .
27-562 . switch (hmi stuff)
27-563 . {
27-564 . case one:
27-565 . {
27-566 . run_this;
27-567 . break;
27-568 . }
27-569 . case two:
27-570 . {
27-571 . run_this;
27-572 . break;
27-573 . }
27-574 . default:
27-575 . {
27-576 . SwError;
27-577 . }
27-578 . }
27-579 .
27-580 . A = B+C;
27-581 . A = B-C;
27-582 .
27-583 . if (A > = B)
27-584 . {
27-585 . A = B + C;
27-586 . D = E + F;
27-587 . }
27-588 .
27-589 . A = B+C;
27-590 .
27-591 . if (A eq B)
27-592 . {
27-593 . A = B + C;
27-594 . D = E + F;
27-595 . }
27-596 .
27-597 . A = B*C;
27-598 . A = B*C;
27-599 . A = B/C;
27-600 . A = B*C;
27-601 . A = B/C;
27-602 . A = B/C;
27-603 . A = B+C;
27-604 . A = B/C;
27-605 . A = 0x0004;
27-606 .
27-607 . if (A le B)
27-608 . {
27-609 . A = B + C;
27-610 . D = E + F;
27-611 . }
27-612 .
27-613 . A = B-C;
27-614 . A = B/C;
27-615 . A = B/C;
27-616 . A = B-C;
27-617 .
27-618 . switch (hmi stuff)
27-619 . {
27-620 . case one:
27-621 . {
27-622 . run_this;
27-623 . break;
27-624 . }
27-625 . case two:
27-626 . {
27-627 . run_this;
27-628 . break;
27-629 . }
27-630 . default:
27-631 . {
27-632 . SwError;
27-633 . }
27-634 . }
27-635 .
27-636 .
27-637 . if (A != B)
27-638 . {
27-639 . A = B + C;
27-640 . D = E + F;
27-641 . }
27-642 .
27-643 . A = B/C;
27-644 . A = B+C;
27-645 .
27-646 . if (A le B)
27-647 . {
27-648 . A = B + C;
27-649 . D = E + F;
27-650 . }
27-651 .
27-652 . A = B*C;
27-653 . A = B-C;
27-654 . A = B+C;
27-655 .
27-656 . if (A gt B)
27-657 . {
27-658 . A = B + C;
27-659 . D = E + F;
27-660 . }
27-661 .
27-662 .
27-663 . if (A ne B)
27-664 . {
27-665 . A = B + C;
27-666 . D = E + F;
27-667 . }
27-668 .
27-669 . A = B*C;
27-670 . A = B+C;
27-671 . A = B-C;
27-672 . A = B-C;
27-673 .
27-674 . if (A eq B)
27-675 . {
27-676 . A = B + C;
27-677 . D = E + F;
27-678 . }
27-679 .
27-680 . A = B-C;
27-681 .
27-682 . if (A < B)
27-683 . {
27-684 . A = B + C;
27-685 . D = E + F;
27-686 . }
27-687 .
27-688 .
27-689 . if (A ge B)
27-690 . {
27-691 . A = B + C;
27-692 . D = E + F;
27-693 . }
27-694 .
27-695 . // max LOC 66
27-696 .
27-697 . }
27-698 .
27-699 .
27-700 . /*
27-701 . -----------------------------------------------------------------------------
27-702 . --| NAME: hmi.4.4
27-703 . --|
27-704 . --| ABSTRACT:
27-705 . --| This function does hmi stuff.
27-706 . --|
27-707 . --| RETURNS:
27-708 . --| NONE.
27-709 . --|
27-710 . ----------------------------------------------------------------------------
27-711 . */
27-712 . static void hmi.4.4(void)
27-713 . {
27-714 . A = B-C;
27-715 .
27-716 . if (A le B)
27-717 . {
27-718 . A = B + C;
27-719 . D = E + F;
27-720 . }
27-721 .
27-722 .
27-723 . if (A eq B)
27-724 . {
27-725 . A = B + C;
27-726 . D = E + F;
27-727 . }
27-728 .
27-729 . A = B/C;
27-730 . A = B-C;
27-731 . A = 0x0009;
27-732 . A = B+C;
27-733 . A = B/C;
27-734 .
27-735 . if (A eq B)
27-736 . {
27-737 . A = B + C;
27-738 . D = E + F;
27-739 . }
27-740 .
27-741 .
27-742 . if (A > B)
27-743 . {
27-744 . A = B + C;
27-745 . D = E + F;
27-746 . }
27-747 .
27-748 . A = B+C;
27-749 . A = B+C;
27-750 . A = B+C;
27-751 . A = B-C;
27-752 .
27-753 . if (A > B)
27-754 . {
27-755 . A = B + C;
27-756 . D = E + F;
27-757 . }
27-758 .
27-759 . A = B*C;
27-760 . A = B+C;
27-761 . A = B/C;
27-762 . A = B/C;
27-763 . A = B/C;
27-764 . A = B*C;
27-765 .
27-766 . if (A == B)
27-767 . {
27-768 . A = B + C;
27-769 . D = E + F;
27-770 . }
27-771 .
27-772 . A = B+C;
27-773 .
27-774 . if (A gt B)
27-775 . {
27-776 . A = B + C;
27-777 . D = E + F;
27-778 . }
27-779 .
27-780 . /* LE SV TOC-1866 this is a hmi-04.4.24 req to check pSOS*/
27-781 . A = B*C;
27-782 . A = B*C;
27-783 .
27-784 . if (A > = B)
27-785 . {
27-786 . A = B + C;
27-787 . D = E + F;
27-788 . }
27-789 .
27-790 .
27-791 . switch (hmi stuff)
27-792 . {
27-793 . case:
27-794 . case:
27-795 . // stacked case statements but only if there is a new line in between
27-796 .
27-797 . case:
27-798 . case:
27-799 . case:
27-800 . {
27-801 . run_this;
27-802 . break;
27-803 . }
27-804 . default:
27-805 . {
27-806 . halt;
27-807 . }
27-808 . }
27-809 .
27-810 . A = B+C;
27-811 . A = B-C;
27-812 . // ??? go see ws
27-813 . A = B/C;
27-814 . // (P) this is really improtant
27-815 . A = B-C;
27-816 . A = B-C;
27-817 . rcv_buffer = (U16 *) alloc(size+1);
27-818 .
27-819 . if (A lt B)
27-820 . {
27-821 . A = B + C;
27-822 . D = E + F;
27-823 . }
27-824 .
27-825 .
27-826 . if (A < = B)
27-827 . {
27-828 . A = B + C;
27-829 . D = E + F;
27-830 . }
27-831 .
27-832 . A = B-C;
27-833 . A = B/C;
27-834 . A = B-C;
27-835 . A = B/C;
27-836 . /* LE SV TOC-1867 this is a hmi-04.4.38 req to convert*/
27-837 .
27-838 . switch (hmi stuff)
27-839 . {
27-840 . case one:
27-841 . {
27-842 . run_this;
27-843 . break;
27-844 . }
27-845 . case two:
27-846 . {
27-847 . run_this;
27-848 . break;
27-849 . }
27-850 . default:
27-851 . {
27-852 . SwError;
27-853 . }
27-854 . }
27-855 .
27-856 . A = 0x0008;
27-857 . A = B+C;
27-858 . A = B*C;
27-859 .
27-860 . if (A ne B)
27-861 . {
27-862 . A = B + C;
27-863 . D = E + F;
27-864 . }
27-865 .
27-866 . A = B/C;
27-867 . A = B-C;
27-868 .
27-869 . if (A eq B)
27-870 . {
27-871 . A = B + C;
27-872 . D = E + F;
27-873 . }
27-874 .
27-875 . // max LOC 44
27-876 .
27-877 . }
27-878 .
27-879 .
27-880 . /*
27-881 . -----------------------------------------------------------------------------
27-882 . --| NAME: hmi.4.5
27-883 . --|
27-884 . --| ABSTRACT:
27-885 . --| This function does hmi stuff.
27-886 . --|
27-887 . --| RETURNS:
27-888 . --| NONE.
27-889 . --|
27-890 . ----------------------------------------------------------------------------
27-891 . */
27-892 . static void hmi.4.5(void)
27-893 . {
27-894 . A = B*C;
27-895 .
27-896 . if (A > B)
27-897 . {
27-898 . A = B + C;
27-899 . D = E + F;
27-900 . }
27-901 .
27-902 . A = B+C;
27-903 . A = B+C;
27-904 . /* LE SV TOC-1868 this is a hmi-04.5.5 req to set Real Time Clock*/
27-905 .
27-906 . switch (hmi stuff)
27-907 . {
27-908 . case one:
27-909 . {
27-910 . run_this;
27-911 . break;
27-912 . }
27-913 . case two:
27-914 . {
27-915 . run_this;
27-916 . break;
27-917 . }
27-918 . default:
27-919 . {
27-920 . SwError;
27-921 . }
27-922 . }
27-923 .
27-924 .
27-925 . if (A != B)
27-926 . {
27-927 . A = B + C;
27-928 . D = E + F;
27-929 . }
27-930 .
27-931 .
27-932 . if (A lt B)
27-933 . {
27-934 . A = B + C;
27-935 . D = E + F;
27-936 . }
27-937 .
27-938 . A = B+C;
27-939 . A = B*C;
27-940 . A = B/C;
27-941 . A = B-C;
27-942 .
27-943 . if (A > = B)
27-944 . {
27-945 . A = B + C;
27-946 . D = E + F;
27-947 . }
27-948 .
27-949 . A = B-C;
27-950 . A = B/C;
27-951 . /* LE SV TOC-1869 this is a hmi-04.5.15 req to record*/
27-952 . A = B*C;
27-953 . A = B+C;
27-954 . A = B/C;
27-955 . A = B*C;
27-956 .
27-957 . if (A eq B)
27-958 . {
27-959 . A = B + C;
27-960 . D = E + F;
27-961 . }
27-962 .
27-963 .
27-964 . switch (hmi stuff)
27-965 . {
27-966 . case one:
27-967 . {
27-968 . run_this;
27-969 . break;
27-970 . }
27-971 . case two:
27-972 . {
27-973 . run_this;
27-974 . break;
27-975 . }
27-976 . default:
27-977 . {
27-978 . // missing error call
27-979 . }
27-980 . }
27-981 .
27-982 . A = B/C;
27-983 .
27-984 . if (A ge B)
27-985 . {
27-986 . A = B + C;
27-987 . D = E + F;
27-988 . }
27-989 .
27-990 .
27-991 . if (A != B)
27-992 . {
27-993 . A = B + C;
27-994 . D = E + F;
27-995 . }
27-996 .
27-997 . A = B*C;
27-998 . A = B/C;
27-999 . A = B+C;
27-1000 .
27-1001 . if (A lt B)
27-1002 . {
27-1003 . A = B + C;
27-1004 . D = E + F;
27-1005 . }
27-1006 .
27-1007 . A = B-C;
27-1008 .
27-1009 . if (A lt B)
27-1010 . {
27-1011 . A = B + C;
27-1012 . D = E + F;
27-1013 . }
27-1014 .
27-1015 . A = B+C;
27-1016 . A = B+C;
27-1017 . A = B+C;
27-1018 . /* LE SV TOC-1870 this is a hmi-04.5.32 req to set RTC*/
27-1019 . A = B/C;
27-1020 .
27-1021 . if (A ne B)
27-1022 . {
27-1023 . A = B + C;
27-1024 . D = E + F;
27-1025 . }
27-1026 .
27-1027 .
27-1028 . if (A gt B)
27-1029 . {
27-1030 . A = B + C;
27-1031 . D = E + F;
27-1032 . }
27-1033 .
27-1034 . A = B-C;
27-1035 . A = B+C;
27-1036 . A = B-C;
27-1037 .
27-1038 . if (A < = B)
27-1039 . {
27-1040 . A = B + C;
27-1041 . D = E + F;
27-1042 . }
27-1043 .
27-1044 .
27-1045 . if (A < = B)
27-1046 . {
27-1047 . A = B + C;
27-1048 . D = E + F;
27-1049 . }
27-1050 .
27-1051 . A = B+C;
27-1052 . A = B+C;
27-1053 . A = B+C;
27-1054 . A = B*C;
27-1055 .
27-1056 . if (A > B)
27-1057 . {
27-1058 . A = B + C;
27-1059 . D = E + F;
27-1060 . }
27-1061 .
27-1062 . A = B+C;
27-1063 .
27-1064 . if (A == B)
27-1065 . {
27-1066 . A = B + C;
27-1067 . D = E + F;
27-1068 . }
27-1069 .
27-1070 .
27-1071 . if (veg)
27-1072 . // missing curly brace
27-1073 . variable = orange;
27-1074 .
27-1075 . A = B+C;
27-1076 .
27-1077 . if (A gt B)
27-1078 . {
27-1079 . A = B + C;
27-1080 . D = E + F;
27-1081 . }
27-1082 .
27-1083 . A = B*C;
27-1084 . A = B+C;
27-1085 .
27-1086 . if (A eq B)
27-1087 . {
27-1088 . A = B + C;
27-1089 . D = E + F;
27-1090 . }
27-1091 .
27-1092 . A = B*C;
27-1093 . A = 0x0001;
27-1094 .
27-1095 . if (A eq B)
27-1096 . {
27-1097 . A = B + C;
27-1098 . D = E + F;
27-1099 . }
27-1100 .
27-1101 . A = B*C;
27-1102 . A = B+C;
27-1103 .
27-1104 . if (A eq B)
27-1105 . {
27-1106 . A = B + C;
27-1107 . D = E + F;
27-1108 . }
27-1109 .
27-1110 . A = B/C;
27-1111 . A = B/C;
27-1112 . A = B/C;
27-1113 . A = B*C;
27-1114 . A = B*C;
27-1115 . A = B+C;
27-1116 . A = B/C;
27-1117 . A = B*C;
27-1118 . A = B+C;
27-1119 . A = B-C;
27-1120 . A = B/C;
27-1121 . A = B/C;
27-1122 . A = B+C;
27-1123 .
27-1124 . switch (hmi stuff)
27-1125 . {
27-1126 . case one:
27-1127 . {
27-1128 . run_this;
27-1129 . break;
27-1130 . }
27-1131 . case two:
27-1132 . {
27-1133 . run_this;
27-1134 . break;
27-1135 . }
27-1136 . default:
27-1137 . {
27-1138 . SwError;
27-1139 . }
27-1140 . }
27-1141 .
27-1142 . A = B/C;
27-1143 . A = 0x0002;
27-1144 . A = B/C;
27-1145 . A = B+C;
27-1146 .
27-1147 . if {
27-1148 . X = Y + Z;
27-1149 . }
27-1150 . else {
27-1151 . halt;
27-1152 . }
27-1153 .
27-1154 . A = B-C;
27-1155 . A = B/C;
27-1156 . A = 0x0001;
27-1157 . A = (int)B + C;
27-1158 . A = B/C;
27-1159 . A = B*C;
27-1160 .
27-1161 . if (A > = B)
27-1162 . {
27-1163 . A = B + C;
27-1164 . D = E + F;
27-1165 . }
27-1166 .
27-1167 . A = B/C;
27-1168 . // max LOC 79
27-1169 .
27-1170 . }
27-1171 .
27 27 Result: result/source/ft-app/ft-app-B1.1/hmi/hmi-04.c
28 28 Source: source/ft-app/ft-app-B1.1/hmi/hmi-05.c
28-0 . /*
28-1 . ----------------------------------------------------------------------------
28-2 . --| BEGIN PROLOGUE
28-3 . --|
28-4 . --| CLASSIFICATION: UNCLASSIFIED
28-5 . --|
28-6 . --| FILE NAME: hmi-05.c
28-7 . --|
28-8 . --| ABSTRACT:
28-9 . --| This file contains the 12 functions that do file hmi stuff.
28-10 . --|
28-11 . --| HISTORY:
28-12 . --| CCCQ_NAME:
28-13 . --| CCCQ_VER:
28-14 . --|
28-15 . --| END PROLOGUE
28-16 . ----------------------------------------------------------------------------
28-17 . */
28-18 .
28-19 . #include A;
28-20 . #define C;
28-21 . char D;
28-22 . float B;
28-23 . #include B;
28-24 .
28-25 .
28-26 .
28-27 . /*
28-28 . -----------------------------------------------------------------------------
28-29 . --| NAME: hmi.5.1
28-30 . --|
28-31 . --| ABSTRACT:
28-32 . --| This function does hmi stuff.
28-33 . --|
28-34 . --| RETURNS:
28-35 . --| NONE.
28-36 . --|
28-37 . ----------------------------------------------------------------------------
28-38 . */
28-39 . static void hmi.5.1(void)
28-40 . {
28-41 . A = B/C;
28-42 .
28-43 . /*
28-44 . dead_block = C * D;
28-45 . dead_block = E * F;
28-46 . */
28-47 .
28-48 . A = B-C;
28-49 .
28-50 . if (A > B)
28-51 . {
28-52 . A = B + C;
28-53 . D = E + F;
28-54 . }
28-55 .
28-56 . A = B*C;
28-57 .
28-58 . if (A > B)
28-59 . {
28-60 . A = B + C;
28-61 . D = E + F;
28-62 . }
28-63 .
28-64 .
28-65 . switch (hmi stuff)
28-66 . {
28-67 . case one:
28-68 . {
28-69 . run_this;
28-70 . break;
28-71 . }
28-72 . case two:
28-73 . {
28-74 . run_this;
28-75 . break;
28-76 . }
28-77 . default:
28-78 . {
28-79 . SwError;
28-80 . }
28-81 . }
28-82 .
28-83 .
28-84 . if (A > B)
28-85 . {
28-86 . A = B + C;
28-87 . D = E + F;
28-88 . }
28-89 .
28-90 .
28-91 . if (A eq B)
28-92 . {
28-93 . A = B + C;
28-94 . D = E + F;
28-95 . }
28-96 .
28-97 .
28-98 . if (A eq B)
28-99 . {
28-100 . A = B + C;
28-101 . D = E + F;
28-102 . }
28-103 .
28-104 . A = B+C;
28-105 . A = B-C;
28-106 . A = B-C;
28-107 . A = B*C;
28-108 . A = B/C;
28-109 . A = B+C;
28-110 . A = B/C;
28-111 . A = B-C;
28-112 .
28-113 . if (A < B)
28-114 . {
28-115 . A = B + C;
28-116 . D = E + F;
28-117 . }
28-118 .
28-119 . A = B-C;
28-120 . A = B*C;
28-121 . A = B/C;
28-122 . A = B/C;
28-123 . // max LOC 22
28-124 .
28-125 . }
28-126 .
28-127 .
28-128 . /*
28-129 . -----------------------------------------------------------------------------
28-130 . --| NAME: hmi.5.2
28-131 . --|
28-132 . --| ABSTRACT:
28-133 . --| This function does hmi stuff.
28-134 . --|
28-135 . --| RETURNS:
28-136 . --| NONE.
28-137 . --|
28-138 . ----------------------------------------------------------------------------
28-139 . */
28-140 . static void hmi.5.2(void)
28-141 . {
28-142 . A = B-C;
28-143 . A = B+C;
28-144 .
28-145 . if (A ge B)
28-146 . {
28-147 . A = B + C;
28-148 . D = E + F;
28-149 . }
28-150 .
28-151 . A = B/C;
28-152 . A = B/C;
28-153 . A = B*C;
28-154 . A = B+C;
28-155 . A = B*C;
28-156 . A = B/C;
28-157 . A = B*C;
28-158 . A = 0x0006;
28-159 . A = B-C;
28-160 . A = B+C;
28-161 . A = B*C;
28-162 . A = B-C;
28-163 . A = B/C;
28-164 . A = B*C;
28-165 .
28-166 . if (A ne B)
28-167 . {
28-168 . A = B + C;
28-169 . D = E + F;
28-170 . }
28-171 .
28-172 . A = B+C;
28-173 . A = B-C;
28-174 . A = B+C;
28-175 . A = B/C;
28-176 . A = B/C;
28-177 . A = B-C;
28-178 . A = B*C;
28-179 . A = B/C;
28-180 .
28-181 . if (A > B)
28-182 . {
28-183 . A = B + C;
28-184 . D = E + F;
28-185 . }
28-186 .
28-187 . // max LOC 26
28-188 .
28-189 . }
28-190 .
28-191 .
28-192 . /*
28-193 . -----------------------------------------------------------------------------
28-194 . --| NAME: hmi.5.3
28-195 . --|
28-196 . --| ABSTRACT:
28-197 . --| This function does hmi stuff.
28-198 . --|
28-199 . --| RETURNS:
28-200 . --| NONE.
28-201 . --|
28-202 . ----------------------------------------------------------------------------
28-203 . */
28-204 . static void hmi.5.3(void)
28-205 . {
28-206 .
28-207 . if (A lt B)
28-208 . {
28-209 . A = B + C;
28-210 . D = E + F;
28-211 . }
28-212 .
28-213 . A = B-C;
28-214 .
28-215 . if (A > B)
28-216 . {
28-217 . A = B + C;
28-218 . D = E + F;
28-219 . }
28-220 .
28-221 . A = B+C;
28-222 . A = B/C;
28-223 . A = B/C;
28-224 . A = B+C;
28-225 . A = (int)B + C;
28-226 .
28-227 . if (A < B)
28-228 . {
28-229 . A = B + C;
28-230 . D = E + F;
28-231 . }
28-232 .
28-233 .
28-234 . if (A lt B)
28-235 . {
28-236 . A = B + C;
28-237 . D = E + F;
28-238 . }
28-239 .
28-240 . A = B*C;
28-241 . A = B/C;
28-242 . A = B+C;
28-243 .
28-244 . if (A gt B)
28-245 . {
28-246 . A = B + C;
28-247 . D = E + F;
28-248 . }
28-249 .
28-250 . A = B+C;
28-251 .
28-252 . if (A < = B)
28-253 . {
28-254 . A = B + C;
28-255 . D = E + F;
28-256 . }
28-257 .
28-258 .
28-259 . if (A > B)
28-260 . {
28-261 . A = B + C;
28-262 . D = E + F;
28-263 . }
28-264 .
28-265 . free(FreePtr);
28-266 .
28-267 . if (A > = B)
28-268 . {
28-269 . A = B + C;
28-270 . D = E + F;
28-271 . }
28-272 .
28-273 .
28-274 . if (A < B)
28-275 . {
28-276 . A = B + C;
28-277 . D = E + F;
28-278 . }
28-279 .
28-280 . A = 0x0007;
28-281 . A = B*C;
28-282 . // max LOC 19
28-283 .
28-284 . }
28-285 .
28-286 .
28-287 . /*
28-288 . -----------------------------------------------------------------------------
28-289 . --| NAME: hmi.5.4
28-290 . --|
28-291 . --| ABSTRACT:
28-292 . --| This function does hmi stuff.
28-293 . --|
28-294 . --| RETURNS:
28-295 . --| NONE.
28-296 . --|
28-297 . ----------------------------------------------------------------------------
28-298 . */
28-299 . static void hmi.5.4(void)
28-300 . {
28-301 . A = B+C;
28-302 .
28-303 . switch (hmi stuff)
28-304 . {
28-305 . case one:
28-306 . {
28-307 . run_this;
28-308 . break;
28-309 . }
28-310 . case two:
28-311 . {
28-312 . run_this;
28-313 . break;
28-314 . }
28-315 . default:
28-316 . {
28-317 . // missing error call
28-318 . }
28-319 . }
28-320 .
28-321 .
28-322 . if (A != B)
28-323 . {
28-324 . A = B + C;
28-325 . D = E + F;
28-326 . }
28-327 .
28-328 . /* LE SV TOC-1871 this is a hmi-05.4.3 req to record*/
28-329 . A = B+C;
28-330 . A = B*C;
28-331 . send_buffer = (U16 *) malloc(size+1);
28-332 .
28-333 . if (A < = B)
28-334 . {
28-335 . A = B + C;
28-336 . D = E + F;
28-337 . }
28-338 .
28-339 . A = B+C;
28-340 . A = B+C;
28-341 .
28-342 . if (A le B)
28-343 . {
28-344 . A = B + C;
28-345 . D = E + F;
28-346 . }
28-347 .
28-348 .
28-349 . if (A ge B)
28-350 . {
28-351 . A = B + C;
28-352 . D = E + F;
28-353 . }
28-354 .
28-355 . A = B*C;
28-356 .
28-357 . if (A eq B)
28-358 . {
28-359 . A = B + C;
28-360 . D = E + F;
28-361 . }
28-362 .
28-363 .
28-364 . if (A ne B)
28-365 . {
28-366 . A = B + C;
28-367 . D = E + F;
28-368 . }
28-369 .
28-370 . A = B+C;
28-371 . A = B+C;
28-372 .
28-373 . if (A ge B)
28-374 . {
28-375 . A = B + C;
28-376 . D = E + F;
28-377 . }
28-378 .
28-379 . A = B*C;
28-380 . A = B*C;
28-381 . /* LE SV TOC-1872 this is a hmi-05.4.18 req to audit*/
28-382 . A = B-C;
28-383 .
28-384 . if (A < B)
28-385 . {
28-386 . A = B + C;
28-387 . D = E + F;
28-388 . }
28-389 .
28-390 . A = B+C;
28-391 . A = B*C;
28-392 .
28-393 . if (A le B)
28-394 . {
28-395 . A = B + C;
28-396 . D = E + F;
28-397 . }
28-398 .
28-399 . A = B-C;
28-400 . A = 0x0003;
28-401 . A = B-C;
28-402 . /* LE SV TOC-1873 this is a hmi-05.4.25 req to convert*/
28-403 .
28-404 . if (A gt B)
28-405 . {
28-406 . A = B + C;
28-407 . D = E + F;
28-408 . }
28-409 .
28-410 . A = B+C;
28-411 .
28-412 . switch (hmi stuff)
28-413 . {
28-414 . case one:
28-415 . {
28-416 . run_this;
28-417 . break;
28-418 . }
28-419 . case two:
28-420 . {
28-421 . run_this;
28-422 . break;
28-423 . }
28-424 . default:
28-425 . {
28-426 . SwError;
28-427 . }
28-428 . }
28-429 .
28-430 . A = B-C;
28-431 .
28-432 . if (A < = B)
28-433 . {
28-434 . A = B + C;
28-435 . D = E + F;
28-436 . }
28-437 .
28-438 . /* LE SV TOC-1874 this is a hmi-05.4.30 req to validate*/
28-439 .
28-440 . if (A != B)
28-441 . {
28-442 . A = B + C;
28-443 . D = E + F;
28-444 . }
28-445 .
28-446 . A = B*C;
28-447 . A = B*C;
28-448 . /* dead_code = A * B; */
28-449 .
28-450 . if (A == B)
28-451 . {
28-452 . A = B + C;
28-453 . D = E + F;
28-454 . }
28-455 .
28-456 . A = B+C;
28-457 . A = B/C;
28-458 . A = B+C;
28-459 . A = B+C;
28-460 . /* LE SV TOC-1875 this is a hmi-05.4.38 req to assign*/
28-461 . A = B+C;
28-462 . A = B+C;
28-463 .
28-464 . if (A == B)
28-465 . {
28-466 . A = B + C;
28-467 . D = E + F;
28-468 . }
28-469 .
28-470 . A = B-C;
28-471 . A = B+C;
28-472 . A = B+C;
28-473 .
28-474 . if (A eq B)
28-475 . {
28-476 . A = B + C;
28-477 . D = E + F;
28-478 . }
28-479 .
28-480 . A = B+C;
28-481 .
28-482 . /*
28-483 . dead_code = B - C;
28-484 . dead_code = D - E;
28-485 . dead_code = F - G;
28-486 . */
28-487 .
28-488 . A = B+C;
28-489 . A = 0x0001;
28-490 .
28-491 . if (A ge B)
28-492 . {
28-493 . A = B + C;
28-494 . D = E + F;
28-495 . }
28-496 .
28-497 . A = (long)B + C;
28-498 . A = B*C;
28-499 . goto error;
28-500 .
28-501 . if (A > = B)
28-502 . {
28-503 . A = B + C;
28-504 . D = E + F;
28-505 . }
28-506 .
28-507 . A = B+C;
28-508 . A = B+C;
28-509 . A = B-C;
28-510 . A = B/C;
28-511 .
28-512 . if (A < = B)
28-513 . {
28-514 . A = B + C;
28-515 . D = E + F;
28-516 . }
28-517 .
28-518 . A = B-C;
28-519 . A = B-C;
28-520 .
28-521 . if (A ge B)
28-522 . {
28-523 . A = B + C;
28-524 . D = E + F;
28-525 . }
28-526 .
28-527 . A = B*C;
28-528 . A = B/C;
28-529 . send_buffer = (U16 *) malloc(size+1);
28-530 . A = B+C;
28-531 . A = B+C;
28-532 . A = B+C;
28-533 .
28-534 . switch (hmi stuff)
28-535 . {
28-536 . case one:
28-537 . {
28-538 . run_this;
28-539 . break;
28-540 . }
28-541 . case two:
28-542 . {
28-543 . run_this;
28-544 . break;
28-545 . }
28-546 . default:
28-547 . {
28-548 . SwError;
28-549 . }
28-550 . }
28-551 .
28-552 . A = B+C;
28-553 . A = B*C;
28-554 . A = B+C;
28-555 . A = B/C;
28-556 .
28-557 . if (A > = B)
28-558 . {
28-559 . A = B + C;
28-560 . D = E + F;
28-561 . }
28-562 .
28-563 . /* LE SV TOC-1876 this is a hmi-05.4.69 req to audit*/
28-564 . A = B/C;
28-565 . A = B+C;
28-566 .
28-567 . if (A gt B)
28-568 . {
28-569 . A = B + C;
28-570 . D = E + F;
28-571 . }
28-572 .
28-573 .
28-574 . if (A ge B)
28-575 . {
28-576 . A = B + C;
28-577 . D = E + F;
28-578 . }
28-579 .
28-580 . A = B-C;
28-581 .
28-582 . if (A > = B)
28-583 . {
28-584 . A = B + C;
28-585 . D = E + F;
28-586 . }
28-587 .
28-588 .
28-589 . if (A > = B)
28-590 . {
28-591 . A = B + C;
28-592 . D = E + F;
28-593 . }
28-594 .
28-595 . A = B*C;
28-596 .
28-597 . #ifdef LAZY
28-598 . // this is not nice
28-599 . A = B + C;
28-600 . A = B + C;
28-601 . #endif
28-602 .
28-603 . A = B*C;
28-604 . A = B*C;
28-605 . // max LOC 78
28-606 .
28-607 . }
28-608 .
28-609 .
28-610 . /*
28-611 . -----------------------------------------------------------------------------
28-612 . --| NAME: hmi.5.5
28-613 . --|
28-614 . --| ABSTRACT:
28-615 . --| This function does hmi stuff.
28-616 . --|
28-617 . --| RETURNS:
28-618 . --| NONE.
28-619 . --|
28-620 . ----------------------------------------------------------------------------
28-621 . */
28-622 . static void hmi.5.5(void)
28-623 . {
28-624 . A = B-C;
28-625 .
28-626 . if (A lt B)
28-627 . {
28-628 . A = B + C;
28-629 . D = E + F;
28-630 . }
28-631 .
28-632 . A = B-C;
28-633 .
28-634 . switch (hmi stuff)
28-635 . {
28-636 . case one:
28-637 . {
28-638 . run_this;
28-639 . break;
28-640 . }
28-641 . case two:
28-642 . {
28-643 . run_this;
28-644 . break;
28-645 . }
28-646 . default:
28-647 . {
28-648 . SwError;
28-649 . }
28-650 . }
28-651 .
28-652 . /* LE SV TOC-1877 this is a hmi-05.5.5 req to validate*/
28-653 . A = B*C;
28-654 . A = B/C;
28-655 .
28-656 . if (A < = B)
28-657 . {
28-658 . A = B + C;
28-659 . D = E + F;
28-660 . }
28-661 .
28-662 .
28-663 . switch (hmi stuff)
28-664 . {
28-665 . case one:
28-666 . {
28-667 . run_this;
28-668 . break;
28-669 . }
28-670 . case two:
28-671 . {
28-672 . run_this;
28-673 . break;
28-674 . }
28-675 . default:
28-676 . {
28-677 . SwError;
28-678 . }
28-679 . }
28-680 .
28-681 .
28-682 . if (A le B)
28-683 . {
28-684 . A = B + C;
28-685 . D = E + F;
28-686 . }
28-687 .
28-688 . A = B+C;
28-689 . A = B/C;
28-690 . A = B-C;
28-691 . A = B-C;
28-692 . A = B*C;
28-693 . A = B*C;
28-694 . A = B*C;
28-695 .
28-696 . if (A gt B)
28-697 . {
28-698 . A = B + C;
28-699 . D = E + F;
28-700 . }
28-701 .
28-702 . A = B-C;
28-703 . /* LE SV TOC-1878 this is a hmi-05.5.19 req to assign*/
28-704 .
28-705 . if (A lt B)
28-706 . {
28-707 . A = B + C;
28-708 . D = E + F;
28-709 . }
28-710 .
28-711 . A = B*C;
28-712 .
28-713 . if (A gt B)
28-714 . {
28-715 . A = B + C;
28-716 . D = E + F;
28-717 . }
28-718 .
28-719 .
28-720 . if (A < B)
28-721 . {
28-722 . A = B + C;
28-723 . D = E + F;
28-724 . }
28-725 .
28-726 . A = B+C;
28-727 . A = B/C;
28-728 . A = B*C;
28-729 .
28-730 . if (A eq B)
28-731 . {
28-732 . A = B + C;
28-733 . D = E + F;
28-734 . }
28-735 .
28-736 . A = B*C;
28-737 . A = B/C;
28-738 . A = B-C;
28-739 . A = B-C;
28-740 .
28-741 . if (A eq B)
28-742 . {
28-743 . A = B + C;
28-744 . D = E + F;
28-745 . }
28-746 .
28-747 . A = B+C;
28-748 . A = B*C;
28-749 . A = B+C;
28-750 . A = B+C;
28-751 . A = B*C;
28-752 .
28-753 . if (A ne B)
28-754 . {
28-755 . A = B + C;
28-756 . D = E + F;
28-757 . }
28-758 .
28-759 . A = B*C;
28-760 .
28-761 . if (A != B)
28-762 . {
28-763 . A = B + C;
28-764 . D = E + F;
28-765 . }
28-766 .
28-767 .
28-768 . if (A ne B)
28-769 . {
28-770 . A = B + C;
28-771 . D = E + F;
28-772 . }
28-773 .
28-774 . A = (int)B + C;
28-775 . A = B/C;
28-776 . A = B+C;
28-777 . A = B+C;
28-778 . A = B-C;
28-779 . A = B*C;
28-780 .
28-781 . if (A ne B)
28-782 . {
28-783 . A = B + C;
28-784 . D = E + F;
28-785 . }
28-786 .
28-787 . A = B-C;
28-788 .
28-789 . if (A ge B)
28-790 . {
28-791 . A = B + C;
28-792 . D = E + F;
28-793 . }
28-794 .
28-795 . A = 0x0001;
28-796 . A = B/C;
28-797 . A = B+C;
28-798 .
28-799 . if (A < = B)
28-800 . {
28-801 . A = B + C;
28-802 . D = E + F;
28-803 . }
28-804 .
28-805 . /* LE SV TOC-1879 this is a hmi-05.5.52 req to disable*/
28-806 . A = B/C;
28-807 . A = B+C;
28-808 .
28-809 . if {
28-810 . X = Y + Z;
28-811 . }
28-812 . else {
28-813 . halt;
28-814 . }
28-815 .
28-816 . A = B-C;
28-817 . A = B/C;
28-818 . A = B*C;
28-819 .
28-820 . if (A > B)
28-821 . {
28-822 . A = B + C;
28-823 . D = E + F;
28-824 . }
28-825 .
28-826 . A = B/C;
28-827 .
28-828 . if (A > B)
28-829 . {
28-830 . A = B + C;
28-831 . D = E + F;
28-832 . }
28-833 .
28-834 . A = B*C;
28-835 . A = B*C;
28-836 . A = B-C;
28-837 . A = B*C;
28-838 . // ??? go see ws
28-839 . A = B-C;
28-840 .
28-841 . if (A ge B)
28-842 . {
28-843 . A = B + C;
28-844 . D = E + F;
28-845 . }
28-846 .
28-847 .
28-848 . if (A gt B)
28-849 . {
28-850 . A = B + C;
28-851 . D = E + F;
28-852 . }
28-853 .
28-854 . A = B+C;
28-855 . A = B*C;
28-856 . A = B*C;
28-857 .
28-858 . if (A == B)
28-859 . {
28-860 . A = B + C;
28-861 . D = E + F;
28-862 . }
28-863 .
28-864 .
28-865 . if (A < B)
28-866 . {
28-867 . A = B + C;
28-868 . D = E + F;
28-869 . }
28-870 .
28-871 . A = B*C;
28-872 .
28-873 . if (A > = B)
28-874 . {
28-875 . A = B + C;
28-876 . D = E + F;
28-877 . }
28-878 .
28-879 . A = B+C;
28-880 . A = B-C;
28-881 . A = B*C;
28-882 . A = B/C;
28-883 . A = B/C;
28-884 . A = B+C;
28-885 . /* LE SV TOC-1880 this is a hmi-05.5.80 req to convert*/
28-886 .
28-887 . if (A eq B)
28-888 . {
28-889 . A = B + C;
28-890 . D = E + F;
28-891 . }
28-892 .
28-893 . /* LE SV TOC-1881 this is a hmi-05.5.81 req to update*/
28-894 .
28-895 . if (A < B)
28-896 . {
28-897 . A = B + C;
28-898 . D = E + F;
28-899 . }
28-900 .
28-901 .
28-902 . if (A ne B)
28-903 . {
28-904 . A = B + C;
28-905 . D = E + F;
28-906 . }
28-907 .
28-908 . A = B-C;
28-909 . // TBD - what do I do now
28-910 . A = B*C;
28-911 . A = B+C;
28-912 . A = B-C;
28-913 .
28-914 . if (A > = B)
28-915 . {
28-916 . A = B + C;
28-917 . D = E + F;
28-918 . }
28-919 .
28-920 . A = B*C;
28-921 . A = B/C;
28-922 . A = B+C;
28-923 .
28-924 . if (A ge B)
28-925 . {
28-926 . A = B + C;
28-927 . D = E + F;
28-928 . }
28-929 .
28-930 . A = B/C;
28-931 . A = B*C;
28-932 . A = B/C;
28-933 .
28-934 . if (A lt B)
28-935 . {
28-936 . A = B + C;
28-937 . D = E + F;
28-938 . }
28-939 .
28-940 . /* LE SV TOC-1882 this is a hmi-05.5.96 req to fail*/
28-941 . A = B-C;
28-942 . // max LOC 96
28-943 .
28-944 . }
28-945 .
28-946 .
28-947 . /*
28-948 . -----------------------------------------------------------------------------
28-949 . --| NAME: hmi.5.6
28-950 . --|
28-951 . --| ABSTRACT:
28-952 . --| This function does hmi stuff.
28-953 . --|
28-954 . --| RETURNS:
28-955 . --| NONE.
28-956 . --|
28-957 . ----------------------------------------------------------------------------
28-958 . */
28-959 . static void hmi.5.6(void)
28-960 . {
28-961 .
28-962 . if (A < = B)
28-963 . {
28-964 . A = B + C;
28-965 . D = E + F;
28-966 . }
28-967 .
28-968 . A = B*C;
28-969 . /* LE SV TOC-1883 this is a hmi-05.6.3 req to recover*/
28-970 .
28-971 . if (A < = B)
28-972 . {
28-973 . A = B + C;
28-974 . D = E + F;
28-975 . }
28-976 .
28-977 . A = B/C;
28-978 . A = B+C;
28-979 . A = B*C;
28-980 . A = B*C;
28-981 .
28-982 . if (A gt B)
28-983 . {
28-984 . A = B + C;
28-985 . D = E + F;
28-986 . }
28-987 .
28-988 . A = B*C;
28-989 . A = B*C;
28-990 . A = B*C;
28-991 . A = B+C;
28-992 .
28-993 . switch (hmi stuff)
28-994 . {
28-995 . case one:
28-996 . {
28-997 . run_this;
28-998 . // missing break
28-999 . }
28-1000 . case two:
28-1001 . {
28-1002 . run_this;
28-1003 . break;
28-1004 . }
28-1005 . default:
28-1006 . {
28-1007 . SwError;
28-1008 . }
28-1009 . }
28-1010 .
28-1011 . A = B+C;
28-1012 . A = B-C;
28-1013 .
28-1014 . if (A gt B)
28-1015 . {
28-1016 . A = B + C;
28-1017 . D = E + F;
28-1018 . }
28-1019 .
28-1020 . A = B+C;
28-1021 . A = B*C;
28-1022 .
28-1023 . if (A < = B)
28-1024 . {
28-1025 . A = B + C;
28-1026 . D = E + F;
28-1027 . }
28-1028 .
28-1029 . A = B+C;
28-1030 . // max LOC 19
28-1031 .
28-1032 . }
28-1033 .
28-1034 .
28-1035 . /*
28-1036 . -----------------------------------------------------------------------------
28-1037 . --| NAME: hmi.5.7
28-1038 . --|
28-1039 . --| ABSTRACT:
28-1040 . --| This function does hmi stuff.
28-1041 . --|
28-1042 . --| RETURNS:
28-1043 . --| NONE.
28-1044 . --|
28-1045 . ----------------------------------------------------------------------------
28-1046 . */
28-1047 . static void hmi.5.7(void)
28-1048 . {
28-1049 . A = B+C;
28-1050 . A = B+C;
28-1051 . A = B/C;
28-1052 . A = B/C;
28-1053 . A = B-C;
28-1054 . A = B-C;
28-1055 .
28-1056 . if (A lt B)
28-1057 . {
28-1058 . A = B + C;
28-1059 . D = E + F;
28-1060 . }
28-1061 .
28-1062 .
28-1063 . if (A ne B)
28-1064 . {
28-1065 . A = B + C;
28-1066 . D = E + F;
28-1067 . }
28-1068 .
28-1069 . A = B/C;
28-1070 . A = B/C;
28-1071 . A = B+C;
28-1072 .
28-1073 . if (A eq B)
28-1074 . {
28-1075 . A = B + C;
28-1076 . D = E + F;
28-1077 . }
28-1078 .
28-1079 . // (P) this is really improtant
28-1080 .
28-1081 . if (A > = B)
28-1082 . {
28-1083 . A = B + C;
28-1084 . D = E + F;
28-1085 . }
28-1086 .
28-1087 . A = B+C;
28-1088 .
28-1089 . if (A ne B)
28-1090 . {
28-1091 . A = B + C;
28-1092 . D = E + F;
28-1093 . }
28-1094 .
28-1095 . A = B/C;
28-1096 .
28-1097 . if (A le B)
28-1098 . {
28-1099 . A = B + C;
28-1100 . D = E + F;
28-1101 . }
28-1102 .
28-1103 . A = B+C;
28-1104 . A = B*C;
28-1105 . A = (float)B + C;
28-1106 .
28-1107 . if (A ne B)
28-1108 . {
28-1109 . A = B + C;
28-1110 . D = E + F;
28-1111 . }
28-1112 .
28-1113 . A = B*C;
28-1114 .
28-1115 . if (A < = B)
28-1116 . {
28-1117 . A = B + C;
28-1118 . D = E + F;
28-1119 . }
28-1120 .
28-1121 . A = B*C;
28-1122 . A = B/C;
28-1123 .
28-1124 . if (A eq B)
28-1125 . {
28-1126 . A = B + C;
28-1127 . D = E + F;
28-1128 . }
28-1129 .
28-1130 . A = B-C;
28-1131 .
28-1132 . if (A le B)
28-1133 . {
28-1134 . A = B + C;
28-1135 . D = E + F;
28-1136 . }
28-1137 .
28-1138 .
28-1139 . if (A le B)
28-1140 . {
28-1141 . A = B + C;
28-1142 . D = E + F;
28-1143 . }
28-1144 .
28-1145 . A = B/C;
28-1146 . A = B*C;
28-1147 . A = B-C;
28-1148 . /* LE SV TOC-1884 this is a hmi-05.7.32 req to set RTC*/
28-1149 . A = B+C;
28-1150 .
28-1151 . if (A > = B)
28-1152 . {
28-1153 . A = B + C;
28-1154 . D = E + F;
28-1155 . }
28-1156 .
28-1157 .
28-1158 . if (A eq B)
28-1159 . {
28-1160 . A = B + C;
28-1161 . D = E + F;
28-1162 . }
28-1163 .
28-1164 .
28-1165 . if (A gt B)
28-1166 . {
28-1167 . A = B + C;
28-1168 . D = E + F;
28-1169 . }
28-1170 .
28-1171 . A = B/C;
28-1172 .
28-1173 . if (A ne B)
28-1174 . {
28-1175 . A = B + C;
28-1176 . D = E + F;
28-1177 . }
28-1178 .
28-1179 . A = B-C;
28-1180 . A = B+C;
28-1181 . A = B-C;
28-1182 . A = B*C;
28-1183 . A = B-C;
28-1184 . A = B/C;
28-1185 . A = B-C;
28-1186 . /* LE SV TOC-1885 this is a hmi-05.7.45 req to assign*/
28-1187 . A = B*C;
28-1188 .
28-1189 . if (A < = B)
28-1190 . {
28-1191 . A = B + C;
28-1192 . D = E + F;
28-1193 . }
28-1194 .
28-1195 . A = B/C;
28-1196 . A = B-C;
28-1197 . A = B*C;
28-1198 . A = B*C;
28-1199 . A = B+C;
28-1200 . /* LE SV TOC-1886 this is a hmi-05.7.52 req to update*/
28-1201 . A = B-C;
28-1202 . A = B+C;
28-1203 .
28-1204 . if (A < B)
28-1205 . {
28-1206 . A = B + C;
28-1207 . D = E + F;
28-1208 . }
28-1209 .
28-1210 . A = B*C;
28-1211 . A = B/C;
28-1212 .
28-1213 . if (A > B)
28-1214 . {
28-1215 . A = B + C;
28-1216 . D = E + F;
28-1217 . }
28-1218 .
28-1219 . A = B/C;
28-1220 . A = B*C;
28-1221 . A = B+C;
28-1222 . A = B+C;
28-1223 . A = B-C;
28-1224 . A = B*C;
28-1225 . // max LOC 63
28-1226 .
28-1227 . }
28-1228 .
28-1229 .
28-1230 . /*
28-1231 . -----------------------------------------------------------------------------
28-1232 . --| NAME: hmi.5.8
28-1233 . --|
28-1234 . --| ABSTRACT:
28-1235 . --| This function does hmi stuff.
28-1236 . --|
28-1237 . --| RETURNS:
28-1238 . --| NONE.
28-1239 . --|
28-1240 . ----------------------------------------------------------------------------
28-1241 . */
28-1242 . static void hmi.5.8(void)
28-1243 . {
28-1244 .
28-1245 . if (A == B)
28-1246 . {
28-1247 . A = B + C;
28-1248 . D = E + F;
28-1249 . }
28-1250 .
28-1251 . A = B*C;
28-1252 . A = B*C;
28-1253 . A = B+C;
28-1254 .
28-1255 . if (A < B)
28-1256 . {
28-1257 . A = B + C;
28-1258 . D = E + F;
28-1259 . }
28-1260 .
28-1261 . A = B-C;
28-1262 . A = B/C;
28-1263 . A = B/C;
28-1264 .
28-1265 . if (A > = B)
28-1266 . {
28-1267 . A = B + C;
28-1268 . D = E + F;
28-1269 . }
28-1270 .
28-1271 .
28-1272 . if (A ge B)
28-1273 . {
28-1274 . A = B + C;
28-1275 . D = E + F;
28-1276 . }
28-1277 .
28-1278 . // TBD - what do I do now
28-1279 .
28-1280 . if (A lt B)
28-1281 . {
28-1282 . A = B + C;
28-1283 . D = E + F;
28-1284 . }
28-1285 .
28-1286 . A = B*C;
28-1287 . A = B+C;
28-1288 . A = B-C;
28-1289 . A = B-C;
28-1290 . A = B-C;
28-1291 . /* LE SV TOC-1887 this is a hmi-05.8.17 req to store*/
28-1292 . A = B-C;
28-1293 . A = B/C;
28-1294 . A = B-C;
28-1295 . A = B*C;
28-1296 .
28-1297 . /* dead_block = C * D;
28-1298 . dead_block = E * F; */
28-1299 .
28-1300 . A = B+C;
28-1301 . A = B-C;
28-1302 . A = B+C;
28-1303 .
28-1304 . if (A < B)
28-1305 . {
28-1306 . A = B + C;
28-1307 . D = E + F;
28-1308 . }
28-1309 .
28-1310 . A = B-C;
28-1311 . A = B/C;
28-1312 . A = B-C;
28-1313 . A = B*C;
28-1314 .
28-1315 . switch (hmi stuff)
28-1316 . {
28-1317 . case one:
28-1318 . {
28-1319 . run_this;
28-1320 . // missing break
28-1321 . }
28-1322 . case two:
28-1323 . {
28-1324 . run_this;
28-1325 . break;
28-1326 . }
28-1327 . default:
28-1328 . {
28-1329 . SwError;
28-1330 . }
28-1331 . }
28-1332 .
28-1333 .
28-1334 . if (A == B)
28-1335 . {
28-1336 . A = B + C;
28-1337 . D = E + F;
28-1338 . }
28-1339 .
28-1340 . A = B+C;
28-1341 . A = B+C;
28-1342 . // max LOC 31
28-1343 .
28-1344 . }
28-1345 .
28-1346 .
28-1347 . /*
28-1348 . -----------------------------------------------------------------------------
28-1349 . --| NAME: hmi.5.9
28-1350 . --|
28-1351 . --| ABSTRACT:
28-1352 . --| This function does hmi stuff.
28-1353 . --|
28-1354 . --| RETURNS:
28-1355 . --| NONE.
28-1356 . --|
28-1357 . ----------------------------------------------------------------------------
28-1358 . */
28-1359 . static void hmi.5.9(void)
28-1360 . {
28-1361 . A = B-C;
28-1362 .
28-1363 . if (A != B)
28-1364 . {
28-1365 . A = B + C;
28-1366 . D = E + F;
28-1367 . }
28-1368 .
28-1369 . A = B+C;
28-1370 . A = B+C;
28-1371 . A = B*C;
28-1372 . A = B+C;
28-1373 . A = B*C;
28-1374 . A = B+C;
28-1375 . A = B-C;
28-1376 . A = B+C;
28-1377 .
28-1378 . switch (hmi stuff)
28-1379 . {
28-1380 . case one:
28-1381 . {
28-1382 . run_this;
28-1383 . break;
28-1384 . }
28-1385 . case two:
28-1386 . {
28-1387 . run_this;
28-1388 . break;
28-1389 . }
28-1390 . default:
28-1391 . {
28-1392 . SwError;
28-1393 . }
28-1394 . }
28-1395 .
28-1396 . /* LE SV TOC-1888 this is a hmi-05.9.12 req to audit*/
28-1397 . A = B-C;
28-1398 .
28-1399 . if (A > = B)
28-1400 . {
28-1401 . A = B + C;
28-1402 . D = E + F;
28-1403 . }
28-1404 .
28-1405 . A = B*C;
28-1406 . A = B/C;
28-1407 . A = B/C;
28-1408 . A = B/C;
28-1409 .
28-1410 . if (A eq B)
28-1411 . {
28-1412 . A = B + C;
28-1413 . D = E + F;
28-1414 . }
28-1415 .
28-1416 . A = B-C;
28-1417 .
28-1418 . if (A lt B)
28-1419 . {
28-1420 . A = B + C;
28-1421 . D = E + F;
28-1422 . }
28-1423 .
28-1424 . A = B/C;
28-1425 .
28-1426 . if (A lt B)
28-1427 . {
28-1428 . A = B + C;
28-1429 . D = E + F;
28-1430 . }
28-1431 .
28-1432 . A = 0x0007;
28-1433 . A = B+C;
28-1434 . A = B/C;
28-1435 . A = B+C;
28-1436 . /* LE SV TOC-1889 this is a hmi-05.9.26 req to process*/
28-1437 .
28-1438 . if (A > B)
28-1439 . {
28-1440 . A = B + C;
28-1441 . D = E + F;
28-1442 . }
28-1443 .
28-1444 . A = B-C;
28-1445 . A = B+C;
28-1446 . A = B-C;
28-1447 .
28-1448 . if (A eq B)
28-1449 . {
28-1450 . A = B + C;
28-1451 . D = E + F;
28-1452 . }
28-1453 .
28-1454 . A = B/C;
28-1455 . A = B*C;
28-1456 .
28-1457 . switch (hmi stuff)
28-1458 . {
28-1459 . case one:
28-1460 . {
28-1461 . run_this;
28-1462 . // missing break
28-1463 . }
28-1464 . case two:
28-1465 . {
28-1466 . run_this;
28-1467 . break;
28-1468 . }
28-1469 . default:
28-1470 . {
28-1471 . SwError;
28-1472 . }
28-1473 . }
28-1474 .
28-1475 . A = B+C;
28-1476 .
28-1477 . if (A == B)
28-1478 . {
28-1479 . A = B + C;
28-1480 . D = E + F;
28-1481 . }
28-1482 .
28-1483 . A = 0x0008;
28-1484 . A = B*C;
28-1485 . A = B-C;
28-1486 . A = B+C;
28-1487 . /* LE SV TOC-1890 this is a hmi-05.9.38 req to transform*/
28-1488 . A = B+C;
28-1489 . rcv_buffer = (U16 *) alloc(size+1);
28-1490 . A = B/C;
28-1491 . A = B/C;
28-1492 .
28-1493 . if (A ne B)
28-1494 . {
28-1495 . A = B + C;
28-1496 . D = E + F;
28-1497 . }
28-1498 .
28-1499 . A = B-C;
28-1500 . A = (int)B + C;
28-1501 . A = B/C;
28-1502 . A = B-C;
28-1503 .
28-1504 . switch (hmi stuff)
28-1505 . {
28-1506 . case one:
28-1507 . {
28-1508 . run_this;
28-1509 . break;
28-1510 . }
28-1511 . case two:
28-1512 . {
28-1513 . run_this;
28-1514 . break;
28-1515 . }
28-1516 . default:
28-1517 . {
28-1518 . SwError;
28-1519 . }
28-1520 . }
28-1521 .
28-1522 . A = B/C;
28-1523 . // (P) this is really improtant
28-1524 . A = B-C;
28-1525 . A = B-C;
28-1526 . A = B/C;
28-1527 . A = B*C;
28-1528 . A = (int)B + C;
28-1529 .
28-1530 . if (A < = B)
28-1531 . {
28-1532 . A = B + C;
28-1533 . D = E + F;
28-1534 . }
28-1535 .
28-1536 . A = B-C;
28-1537 . A = B/C;
28-1538 . A = B+C;
28-1539 . A = B/C;
28-1540 . A = B+C;
28-1541 .
28-1542 . switch (hmi stuff)
28-1543 . {
28-1544 . case one:
28-1545 . {
28-1546 . run_this;
28-1547 . break;
28-1548 . }
28-1549 . case two:
28-1550 . {
28-1551 . run_this;
28-1552 . break;
28-1553 . }
28-1554 . default:
28-1555 . {
28-1556 . SwError;
28-1557 . }
28-1558 . }
28-1559 .
28-1560 . A = B/C;
28-1561 .
28-1562 . if (A < = B)
28-1563 . {
28-1564 . A = B + C;
28-1565 . D = E + F;
28-1566 . }
28-1567 .
28-1568 .
28-1569 . if (veg)
28-1570 . // missing curly brace
28-1571 . variable = orange;
28-1572 .
28-1573 . A = B+C;
28-1574 . A = B-C;
28-1575 . A = B/C;
28-1576 . // max LOC 62
28-1577 .
28-1578 . }
28-1579 .
28-1580 .
28-1581 . /*
28-1582 . -----------------------------------------------------------------------------
28-1583 . --| NAME: hmi.5.10
28-1584 . --|
28-1585 . --| ABSTRACT:
28-1586 . --| This function does hmi stuff.
28-1587 . --|
28-1588 . --| RETURNS:
28-1589 . --| NONE.
28-1590 . --|
28-1591 . ----------------------------------------------------------------------------
28-1592 . */
28-1593 . static void hmi.5.10(void)
28-1594 . {
28-1595 . A = B-C;
28-1596 . A = B/C;
28-1597 .
28-1598 . if (A < B)
28-1599 . {
28-1600 . A = B + C;
28-1601 . D = E + F;
28-1602 . }
28-1603 .
28-1604 .
28-1605 . if (A == B)
28-1606 . {
28-1607 . A = B + C;
28-1608 . D = E + F;
28-1609 . }
28-1610 .
28-1611 . A = B/C;
28-1612 . A = B+C;
28-1613 . A = B+C;
28-1614 . A = B-C;
28-1615 .
28-1616 . if (A le B)
28-1617 . {
28-1618 . A = B + C;
28-1619 . D = E + F;
28-1620 . }
28-1621 .
28-1622 . A = B/C;
28-1623 . A = B+C;
28-1624 . A = B+C;
28-1625 . A = B-C;
28-1626 . A = B/C;
28-1627 . A = B/C;
28-1628 . A = B*C;
28-1629 . A = B-C;
28-1630 . goto error;
28-1631 . A = B+C;
28-1632 . goto error;
28-1633 . A = B*C;
28-1634 .
28-1635 . if (A ge B)
28-1636 . {
28-1637 . A = B + C;
28-1638 . D = E + F;
28-1639 . }
28-1640 .
28-1641 .
28-1642 . switch (hmi stuff)
28-1643 . {
28-1644 . case one:
28-1645 . {
28-1646 . run_this;
28-1647 . break;
28-1648 . }
28-1649 . case two:
28-1650 . {
28-1651 . run_this;
28-1652 . break;
28-1653 . }
28-1654 . default:
28-1655 . {
28-1656 . SwError;
28-1657 . }
28-1658 . }
28-1659 .
28-1660 . A = B+C;
28-1661 . A = B+C;
28-1662 . A = B/C;
28-1663 . A = B-C;
28-1664 . A = B/C;
28-1665 . A = B+C;
28-1666 .
28-1667 . /*
28-1668 . dead_code = B - C;
28-1669 . dead_code = D - E;
28-1670 . dead_code = F - G;
28-1671 . */
28-1672 .
28-1673 . A = B/C;
28-1674 .
28-1675 . if (A == B)
28-1676 . {
28-1677 . A = B + C;
28-1678 . D = E + F;
28-1679 . }
28-1680 .
28-1681 .
28-1682 . if (A == B)
28-1683 . {
28-1684 . A = B + C;
28-1685 . D = E + F;
28-1686 . }
28-1687 .
28-1688 . /* LE SV TOC-1891 this is a hmi-05.10.31 req to compare*/
28-1689 .
28-1690 . switch (hmi stuff)
28-1691 . {
28-1692 . case one:
28-1693 . {
28-1694 . run_this;
28-1695 . break;
28-1696 . }
28-1697 . case two:
28-1698 . {
28-1699 . run_this;
28-1700 . break;
28-1701 . }
28-1702 . default:
28-1703 . {
28-1704 . SwError;
28-1705 . }
28-1706 . }
28-1707 .
28-1708 .
28-1709 . if (A lt B)
28-1710 . {
28-1711 . A = B + C;
28-1712 . D = E + F;
28-1713 . }
28-1714 .
28-1715 .
28-1716 . if ($hmi stuff > $otherhmi stuff)
28-1717 . /* LE SV TOC-008 we really should log all error calls */
28-1718 . {
28-1719 . A = B + C;
28-1720 . }
28-1721 .
28-1722 . A = B+C;
28-1723 .
28-1724 . if (A < = B)
28-1725 . {
28-1726 . A = B + C;
28-1727 . D = E + F;
28-1728 . }
28-1729 .
28-1730 . A = B/C;
28-1731 .
28-1732 . switch (hmi stuff)
28-1733 . {
28-1734 . case one:
28-1735 . {
28-1736 . run_this;
28-1737 . break;
28-1738 . }
28-1739 . case two:
28-1740 . {
28-1741 . run_this;
28-1742 . break;
28-1743 . }
28-1744 . default:
28-1745 . {
28-1746 . SwError;
28-1747 . }
28-1748 . }
28-1749 .
28-1750 .
28-1751 . if (A lt B)
28-1752 . {
28-1753 . A = B + C;
28-1754 . D = E + F;
28-1755 . }
28-1756 .
28-1757 . A = B/C;
28-1758 .
28-1759 . if (A != B)
28-1760 . {
28-1761 . A = B + C;
28-1762 . D = E + F;
28-1763 . }
28-1764 .
28-1765 .
28-1766 . if (A > = B)
28-1767 . {
28-1768 . A = B + C;
28-1769 . D = E + F;
28-1770 . }
28-1771 .
28-1772 . A = B*C;
28-1773 .
28-1774 . if (A < = B)
28-1775 . {
28-1776 . A = B + C;
28-1777 . D = E + F;
28-1778 . }
28-1779 .
28-1780 .
28-1781 . if (A > = B)
28-1782 . {
28-1783 . A = B + C;
28-1784 . D = E + F;
28-1785 . }
28-1786 .
28-1787 . // max LOC 43
28-1788 .
28-1789 . }
28-1790 .
28-1791 .
28-1792 . /*
28-1793 . -----------------------------------------------------------------------------
28-1794 . --| NAME: hmi.5.11
28-1795 . --|
28-1796 . --| ABSTRACT:
28-1797 . --| This function does hmi stuff.
28-1798 . --|
28-1799 . --| RETURNS:
28-1800 . --| NONE.
28-1801 . --|
28-1802 . ----------------------------------------------------------------------------
28-1803 . */
28-1804 . static void hmi.5.11(void)
28-1805 . {
28-1806 . A = B/C;
28-1807 . A = B+C;
28-1808 .
28-1809 . if (A < = B)
28-1810 . {
28-1811 . A = B + C;
28-1812 . D = E + F;
28-1813 . }
28-1814 .
28-1815 . A = B*C;
28-1816 . A = B-C;
28-1817 .
28-1818 . if (A == B)
28-1819 . {
28-1820 . A = B + C;
28-1821 . D = E + F;
28-1822 . }
28-1823 .
28-1824 . A = B*C;
28-1825 .
28-1826 . if (A == B)
28-1827 . {
28-1828 . A = B + C;
28-1829 . D = E + F;
28-1830 . }
28-1831 .
28-1832 . A = B*C;
28-1833 . A = B/C;
28-1834 . /* LE SV TOC-1892 this is a hmi-05.11.11 req to record*/
28-1835 . A = B/C;
28-1836 . A = B-C;
28-1837 .
28-1838 . if (A eq B)
28-1839 . {
28-1840 . A = B + C;
28-1841 . D = E + F;
28-1842 . }
28-1843 .
28-1844 . A = B+C;
28-1845 .
28-1846 . if {
28-1847 . X = Y + Z;
28-1848 . }
28-1849 . else {
28-1850 . halt;
28-1851 . }
28-1852 .
28-1853 . A = B-C;
28-1854 . A = B+C;
28-1855 . A = B/C;
28-1856 . A = B*C;
28-1857 . A = B+C;
28-1858 . A = B/C;
28-1859 . A = B/C;
28-1860 . A = B*C;
28-1861 . A = B/C;
28-1862 .
28-1863 . if (A lt B)
28-1864 . {
28-1865 . A = B + C;
28-1866 . D = E + F;
28-1867 . }
28-1868 .
28-1869 . A = B+C;
28-1870 . /* LE SV TOC-1893 this is a hmi-05.11.26 req to recover*/
28-1871 . A = B-C;
28-1872 . A = B+C;
28-1873 . A = B/C;
28-1874 . A = B-C;
28-1875 . A = B*C;
28-1876 .
28-1877 . /* dead_block = C * D;
28-1878 . dead_block = E * F; */
28-1879 .
28-1880 . A = B+C;
28-1881 . A = B-C;
28-1882 . A = B*C;
28-1883 . A = B*C;
28-1884 .
28-1885 . if (A ge B)
28-1886 . {
28-1887 . A = B + C;
28-1888 . D = E + F;
28-1889 . }
28-1890 .
28-1891 . A = B+C;
28-1892 .
28-1893 . if (A > B)
28-1894 . {
28-1895 . A = B + C;
28-1896 . D = E + F;
28-1897 . }
28-1898 .
28-1899 . A = B+C;
28-1900 .
28-1901 . if (A ne B)
28-1902 . {
28-1903 . A = B + C;
28-1904 . D = E + F;
28-1905 . }
28-1906 .
28-1907 . A = B+C;
28-1908 .
28-1909 . if (A ge B)
28-1910 . {
28-1911 . A = B + C;
28-1912 . D = E + F;
28-1913 . }
28-1914 .
28-1915 . A = B+C;
28-1916 . A = B+C;
28-1917 . A = B-C;
28-1918 . A = B-C;
28-1919 . A = B/C;
28-1920 . A = B*C;
28-1921 . A = B-C;
28-1922 . A = B+C;
28-1923 . A = 0x0008;
28-1924 . A = B/C;
28-1925 . A = B+C;
28-1926 . A = B-C;
28-1927 . A = B*C;
28-1928 . /* LE SV TOC-1894 this is a hmi-05.11.54 req to translate*/
28-1929 . A = B*C;
28-1930 . /* LE SV TOC-1895 this is a hmi-05.11.55 req to halt*/
28-1931 . A = B+C;
28-1932 .
28-1933 . switch (hmi stuff)
28-1934 . {
28-1935 . case one:
28-1936 . {
28-1937 . run_this;
28-1938 . break;
28-1939 . }
28-1940 . case two:
28-1941 . {
28-1942 . run_this;
28-1943 . break;
28-1944 . }
28-1945 . default:
28-1946 . {
28-1947 . SwError;
28-1948 . }
28-1949 . }
28-1950 .
28-1951 . A = 0x0008;
28-1952 .
28-1953 . if (A > = B)
28-1954 . {
28-1955 . A = B + C;
28-1956 . D = E + F;
28-1957 . }
28-1958 .
28-1959 .
28-1960 . if (A < B)
28-1961 . {
28-1962 . A = B + C;
28-1963 . D = E + F;
28-1964 . }
28-1965 .
28-1966 . A = B*C;
28-1967 .
28-1968 . if (A < B)
28-1969 . {
28-1970 . A = B + C;
28-1971 . D = E + F;
28-1972 . }
28-1973 .
28-1974 . A = B*C;
28-1975 . A = B+C;
28-1976 .
28-1977 . if (A eq B)
28-1978 . {
28-1979 . A = B + C;
28-1980 . D = E + F;
28-1981 . }
28-1982 .
28-1983 . // max LOC 63
28-1984 .
28-1985 . }
28-1986 .
28-1987 .
28-1988 . /*
28-1989 . -----------------------------------------------------------------------------
28-1990 . --| NAME: hmi.5.12
28-1991 . --|
28-1992 . --| ABSTRACT:
28-1993 . --| This function does hmi stuff.
28-1994 . --|
28-1995 . --| RETURNS:
28-1996 . --| NONE.
28-1997 . --|
28-1998 . ----------------------------------------------------------------------------
28-1999 . */
28-2000 . static void hmi.5.12(void)
28-2001 . {
28-2002 . /* LE SV TOC-1896 this is a hmi-05.12.1 req to call admin*/
28-2003 . A = (long)B + C;
28-2004 .
28-2005 . if (A ge B)
28-2006 . {
28-2007 . A = B + C;
28-2008 . D = E + F;
28-2009 . }
28-2010 .
28-2011 . A = B*C;
28-2012 . A = B-C;
28-2013 . A = B*C;
28-2014 .
28-2015 . if (A < B)
28-2016 . {
28-2017 . A = B + C;
28-2018 . D = E + F;
28-2019 . }
28-2020 .
28-2021 . /* LE SV TOC-1897 this is a hmi-05.12.6 req to detect error*/
28-2022 . A = B+C;
28-2023 .
28-2024 . if (A eq B)
28-2025 . {
28-2026 . A = B + C;
28-2027 . D = E + F;
28-2028 . }
28-2029 .
28-2030 .
28-2031 . if (A < = B)
28-2032 . {
28-2033 . A = B + C;
28-2034 . D = E + F;
28-2035 . }
28-2036 .
28-2037 .
28-2038 . if (A != B)
28-2039 . {
28-2040 . A = B + C;
28-2041 . D = E + F;
28-2042 . }
28-2043 .
28-2044 .
28-2045 . if (A lt B)
28-2046 . {
28-2047 . A = B + C;
28-2048 . D = E + F;
28-2049 . }
28-2050 .
28-2051 . A = B/C;
28-2052 .
28-2053 . if (A > B)
28-2054 . {
28-2055 . A = B + C;
28-2056 . D = E + F;
28-2057 . }
28-2058 .
28-2059 .
28-2060 . if (A eq B)
28-2061 . {
28-2062 . A = B + C;
28-2063 . D = E + F;
28-2064 . }
28-2065 .
28-2066 . // max LOC 13
28-2067 .
28-2068 . }
28-2069 .
28 28 Result: result/source/ft-app/ft-app-B1.1/hmi/hmi-05.c
29 29 Source: source/ft-app/ft-app-B1.1/hmi/hmi-06.c
29-0 . /*
29-1 . ----------------------------------------------------------------------------
29-2 . --| BEGIN PROLOGUE
29-3 . --|
29-4 . --| CLASSIFICATION: UNCLASSIFIED
29-5 . --|
29-6 . --| FILE NAME: hmi-06.c
29-7 . --|
29-8 . --| :
29-9 . --| This file contains the 6 functions that do file hmi stuff.
29-10 . --|
29-11 . --| HISTORY:
29-12 . --| CCCQ_NAME:
29-13 . --| CCCQ_VER:
29-14 . --|
29-15 . --| END PROLOGUE
29-16 . ----------------------------------------------------------------------------
29-17 . */
29-18 .
29-19 . #include D;
29-20 . double C;
29-21 . #include C;
29-22 . double C;
29-23 . char D;
29-24 . #define A;
29-25 .
29-26 .
29-27 .
29-28 . /*
29-29 . -----------------------------------------------------------------------------
29-30 . --| NAME: hmi.6.1
29-31 . --|
29-32 . --| ABSTRACT:
29-33 . --| This function does hmi stuff.
29-34 . --|
29-35 . --| RETURNS:
29-36 . --| NONE.
29-37 . --|
29-38 . ----------------------------------------------------------------------------
29-39 . */
29-40 . static void hmi.6.1(void)
29-41 . {
29-42 . // TBD - what do I do now
29-43 . A = B/C;
29-44 .
29-45 . if (A eq B)
29-46 . {
29-47 . A = B + C;
29-48 . D = E + F;
29-49 . }
29-50 .
29-51 . A = B/C;
29-52 . A = B/C;
29-53 . A = B*C;
29-54 . A = B+C;
29-55 . // max LOC 6
29-56 .
29-57 . }
29-58 .
29-59 .
29-60 . /*
29-61 . -----------------------------------------------------------------------------
29-62 . --| NAME: hmi.6.2
29-63 . --|
29-64 . --| ABSTRACT:
29-65 . --| This function does hmi stuff.
29-66 . --|
29-67 . --| RETURNS:
29-68 . --| NONE.
29-69 . --|
29-70 . ----------------------------------------------------------------------------
29-71 . */
29-72 . static void hmi.6.2(void)
29-73 . {
29-74 .
29-75 . if (A gt B)
29-76 . {
29-77 . A = B + C;
29-78 . D = E + F;
29-79 . }
29-80 .
29-81 .
29-82 . if (A eq B)
29-83 . {
29-84 . A = B + C;
29-85 . D = E + F;
29-86 . }
29-87 .
29-88 . A = B*C;
29-89 . A = B/C;
29-90 . A = B+C;
29-91 . A = B+C;
29-92 . A = B+C;
29-93 . A = B+C;
29-94 . A = B/C;
29-95 . A = B*C;
29-96 . A = B/C;
29-97 .
29-98 . if (A ne B)
29-99 . {
29-100 . A = B + C;
29-101 . D = E + F;
29-102 . }
29-103 .
29-104 . A = B-C;
29-105 . A = B+C;
29-106 . A = B-C;
29-107 . A = B-C;
29-108 . A = B-C;
29-109 . A = B+C;
29-110 . A = B+C;
29-111 . A = B-C;
29-112 . A = B+C;
29-113 . A = B/C;
29-114 . /* LE SV TOC-1898 this is a hmi-06.2.23 req to call admin*/
29-115 . A = B-C;
29-116 . A = B+C;
29-117 . A = B+C;
29-118 .
29-119 . if (A ge B)
29-120 . {
29-121 . A = B + C;
29-122 . D = E + F;
29-123 . }
29-124 .
29-125 . A = B/C;
29-126 . /* LE SV TOC-1899 this is a hmi-06.2.28 req to process*/
29-127 .
29-128 . if (A != B)
29-129 . {
29-130 . A = B + C;
29-131 . D = E + F;
29-132 . }
29-133 .
29-134 .
29-135 . if (A != B)
29-136 . {
29-137 . A = B + C;
29-138 . D = E + F;
29-139 . }
29-140 .
29-141 . A = B+C;
29-142 . A = B*C;
29-143 . A = B-C;
29-144 .
29-145 . if (A < = B)
29-146 . {
29-147 . A = B + C;
29-148 . D = E + F;
29-149 . }
29-150 .
29-151 . A = B/C;
29-152 .
29-153 . if (A lt B)
29-154 . {
29-155 . A = B + C;
29-156 . D = E + F;
29-157 . }
29-158 .
29-159 . A = B-C;
29-160 . A = B+C;
29-161 . A = B+C;
29-162 . /* LE SV TOC-1900 this is a hmi-06.2.39 req to record*/
29-163 . A = (long)B + C;
29-164 . A = B-C;
29-165 .
29-166 . if (A gt B)
29-167 . {
29-168 . A = B + C;
29-169 . D = E + F;
29-170 . }
29-171 .
29-172 . A = B*C;
29-173 . /* LE SV TOC-1901 this is a hmi-06.2.42 req to enable*/
29-174 . A = B-C;
29-175 . A = B*C;
29-176 . A = B+C;
29-177 . A = B*C;
29-178 . A = B*C;
29-179 . A = B*C;
29-180 . rcv_buffer = (U16 *) alloc(size+1);
29-181 . A = B*C;
29-182 . A = B*C;
29-183 . A = B*C;
29-184 . A = B-C;
29-185 .
29-186 . if (A > = B)
29-187 . {
29-188 . A = B + C;
29-189 . D = E + F;
29-190 . }
29-191 .
29-192 .
29-193 . if (A gt B)
29-194 . {
29-195 . A = B + C;
29-196 . D = E + F;
29-197 . }
29-198 .
29-199 . A = B-C;
29-200 .
29-201 . if (A ne B)
29-202 . {
29-203 . A = B + C;
29-204 . D = E + F;
29-205 . }
29-206 .
29-207 . A = B-C;
29-208 .
29-209 . if (A gt B)
29-210 . {
29-211 . A = B + C;
29-212 . D = E + F;
29-213 . }
29-214 .
29-215 .
29-216 . if (A > B)
29-217 . {
29-218 . A = B + C;
29-219 . D = E + F;
29-220 . }
29-221 .
29-222 . A = B*C;
29-223 . A = B/C;
29-224 . A = B/C;
29-225 . A = B*C;
29-226 . A = B-C;
29-227 .
29-228 . if (A > B)
29-229 . {
29-230 . A = B + C;
29-231 . D = E + F;
29-232 . }
29-233 .
29-234 . A = B-C;
29-235 . A = B*C;
29-236 . A = B+C;
29-237 .
29-238 . if (A gt B)
29-239 . {
29-240 . A = B + C;
29-241 . D = E + F;
29-242 . }
29-243 .
29-244 . A = B/C;
29-245 . A = B/C;
29-246 . /* LE SV TOC-1902 this is a hmi-06.2.71 req to disable*/
29-247 .
29-248 . if (A != B)
29-249 . {
29-250 . A = B + C;
29-251 . D = E + F;
29-252 . }
29-253 .
29-254 .
29-255 . if (A < B)
29-256 . {
29-257 . A = B + C;
29-258 . D = E + F;
29-259 . }
29-260 .
29-261 .
29-262 . if (A lt B)
29-263 . {
29-264 . A = B + C;
29-265 . D = E + F;
29-266 . }
29-267 .
29-268 . A = B-C;
29-269 .
29-270 . if (A ne B)
29-271 . {
29-272 . A = B + C;
29-273 . D = E + F;
29-274 . }
29-275 .
29-276 . // max LOC 75
29-277 .
29-278 . }
29-279 .
29-280 .
29-281 . /*
29-282 . -----------------------------------------------------------------------------
29-283 . --| NAME: hmi.6.3
29-284 . --|
29-285 . --| ABSTRACT:
29-286 . --| This function does hmi stuff.
29-287 . --|
29-288 . --| RETURNS:
29-289 . --| NONE.
29-290 . --|
29-291 . ----------------------------------------------------------------------------
29-292 . */
29-293 . static void hmi.6.3(void)
29-294 . {
29-295 . A = B*C;
29-296 .
29-297 . if (A > = B)
29-298 . {
29-299 . A = B + C;
29-300 . D = E + F;
29-301 . }
29-302 .
29-303 . A = B-C;
29-304 . A = B*C;
29-305 . A = B+C;
29-306 .
29-307 . if (A < B)
29-308 . {
29-309 . A = B + C;
29-310 . D = E + F;
29-311 . }
29-312 .
29-313 . A = B+C;
29-314 . A = B+C;
29-315 . A = B/C;
29-316 . A = B/C;
29-317 .
29-318 . if (A == B)
29-319 . {
29-320 . A = B + C;
29-321 . D = E + F;
29-322 . }
29-323 .
29-324 .
29-325 . if ($hmi stuff > $otherhmi stuff)
29-326 . /* LE SV TOC-008 we really should log all error calls */
29-327 . {
29-328 . A = B + C;
29-329 . }
29-330 .
29-331 .
29-332 . if (A < = B)
29-333 . {
29-334 . A = B + C;
29-335 . D = E + F;
29-336 . }
29-337 .
29-338 . A = B*C;
29-339 . // max LOC 13
29-340 .
29-341 . }
29-342 .
29-343 .
29-344 . /*
29-345 . -----------------------------------------------------------------------------
29-346 . --| NAME: hmi.6.4
29-347 . --|
29-348 . --| ABSTRACT:
29-349 . --| This function does hmi stuff.
29-350 . --|
29-351 . --| RETURNS:
29-352 . --| NONE.
29-353 . --|
29-354 . ----------------------------------------------------------------------------
29-355 . */
29-356 . static void hmi.6.4(void)
29-357 . {
29-358 . /* LE SV TOC-1903 this is a hmi-06.4.1 req to enable*/
29-359 . A = 0x0009;
29-360 . free(FreePtr);
29-361 . A = B+C;
29-362 . /* LE SV TOC-1904 this is a hmi-06.4.2 req to store*/
29-363 . A = B/C;
29-364 .
29-365 . if (A > = B)
29-366 . {
29-367 . A = B + C;
29-368 . D = E + F;
29-369 . }
29-370 .
29-371 . /* LE SV TOC-1905 this is a hmi-06.4.4 req to process*/
29-372 . A = B*C;
29-373 . A = B+C;
29-374 . A = B+C;
29-375 . A = B+C;
29-376 . A = B-C;
29-377 .
29-378 . if (A < = B)
29-379 . {
29-380 . A = B + C;
29-381 . D = E + F;
29-382 . }
29-383 .
29-384 .
29-385 . if (A lt B)
29-386 . {
29-387 . A = B + C;
29-388 . D = E + F;
29-389 . }
29-390 .
29-391 . A = B-C;
29-392 . A = B/C;
29-393 . A = B/C;
29-394 . A = B+C;
29-395 . A = B+C;
29-396 .
29-397 . if (A le B)
29-398 . {
29-399 . A = B + C;
29-400 . D = E + F;
29-401 . }
29-402 .
29-403 .
29-404 . if (A lt B)
29-405 . {
29-406 . A = B + C;
29-407 . D = E + F;
29-408 . }
29-409 .
29-410 . A = B/C;
29-411 .
29-412 . if (A ne B)
29-413 . {
29-414 . A = B + C;
29-415 . D = E + F;
29-416 . }
29-417 .
29-418 . A = B/C;
29-419 . A = B/C;
29-420 . // max LOC 21
29-421 .
29-422 . }
29-423 .
29-424 .
29-425 . /*
29-426 . -----------------------------------------------------------------------------
29-427 . --| NAME: hmi.6.5
29-428 . --|
29-429 . --| ABSTRACT:
29-430 . --| This function does hmi stuff.
29-431 . --|
29-432 . --| RETURNS:
29-433 . --| NONE.
29-434 . --|
29-435 . ----------------------------------------------------------------------------
29-436 . */
29-437 . static void hmi.6.5(void)
29-438 . {
29-439 . A = B*C;
29-440 . rcv_buffer = (U16 *) alloc(size+1);
29-441 . A = B*C;
29-442 .
29-443 . if (A gt B)
29-444 . {
29-445 . A = B + C;
29-446 . D = E + F;
29-447 . }
29-448 .
29-449 .
29-450 . if (A < = B)
29-451 . {
29-452 . A = B + C;
29-453 . D = E + F;
29-454 . }
29-455 .
29-456 .
29-457 . if (A ge B)
29-458 . {
29-459 . A = B + C;
29-460 . D = E + F;
29-461 . }
29-462 .
29-463 . /* LE SV TOC-1906 this is a hmi-06.5.6 req to recover*/
29-464 . A = B/C;
29-465 . A = B/C;
29-466 .
29-467 . switch (hmi stuff)
29-468 . {
29-469 . case one:
29-470 . {
29-471 . run_this;
29-472 . // missing break
29-473 . }
29-474 . case two:
29-475 . {
29-476 . run_this;
29-477 . break;
29-478 . }
29-479 . default:
29-480 . {
29-481 . SwError;
29-482 . }
29-483 . }
29-484 .
29-485 . A = B+C;
29-486 . A = B/C;
29-487 .
29-488 . if (A gt B)
29-489 . {
29-490 . A = B + C;
29-491 . D = E + F;
29-492 . }
29-493 .
29-494 .
29-495 . if (A == B)
29-496 . {
29-497 . A = B + C;
29-498 . D = E + F;
29-499 . }
29-500 .
29-501 .
29-502 . if (A == B)
29-503 . {
29-504 . A = B + C;
29-505 . D = E + F;
29-506 . }
29-507 .
29-508 . A = B*C;
29-509 . A = B-C;
29-510 . A = B+C;
29-511 . A = B-C;
29-512 . A = B*C;
29-513 . A = B/C;
29-514 .
29-515 . if (A ne B)
29-516 . {
29-517 . A = B + C;
29-518 . D = E + F;
29-519 . }
29-520 .
29-521 . A = B+C;
29-522 . A = B/C;
29-523 . A = B/C;
29-524 . /* LE SV TOC-1907 this is a hmi-06.5.23 req to call admin*/
29-525 . A = B+C;
29-526 .
29-527 . if (A != B)
29-528 . {
29-529 . A = B + C;
29-530 . D = E + F;
29-531 . }
29-532 .
29-533 . A = B-C;
29-534 . A = B+C;
29-535 .
29-536 . switch (hmi stuff)
29-537 . {
29-538 . case one:
29-539 . {
29-540 . run_this;
29-541 . break;
29-542 . }
29-543 . case two:
29-544 . {
29-545 . run_this;
29-546 . break;
29-547 . }
29-548 . default:
29-549 . {
29-550 . SwError;
29-551 . }
29-552 . }
29-553 .
29-554 . A = B/C;
29-555 . A = B/C;
29-556 . A = B*C;
29-557 . /* LE SV TOC-1908 this is a hmi-06.5.31 req to set Real Time Clock*/
29-558 . A = B-C;
29-559 .
29-560 . if (A < B)
29-561 . {
29-562 . A = B + C;
29-563 . D = E + F;
29-564 . }
29-565 .
29-566 . A = B+C;
29-567 . A = B+C;
29-568 . A = B+C;
29-569 . A = B/C;
29-570 . A = B+C;
29-571 . A = B/C;
29-572 . A = B-C;
29-573 .
29-574 . if (A < = B)
29-575 . {
29-576 . A = B + C;
29-577 . D = E + F;
29-578 . }
29-579 .
29-580 . A = B+C;
29-581 . A = B*C;
29-582 . A = B+C;
29-583 . A = B+C;
29-584 . A = B+C;
29-585 .
29-586 . switch (hmi stuff)
29-587 . {
29-588 . case one:
29-589 . {
29-590 . switch (nested)
29-591 . {
29-592 . case:
29-593 . X = Y + Z;
29-594 . case:
29-595 . X = Y + Z;
29-596 . default:
29-597 . SwError;
29-598 . }
29-599 . }
29-600 . case two:
29-601 . {
29-602 . run_this;
29-603 . break;
29-604 . }
29-605 . default:
29-606 . {
29-607 . SwError;
29-608 . }
29-609 . }
29-610 .
29-611 .
29-612 . if (A < = B)
29-613 . {
29-614 . A = B + C;
29-615 . D = E + F;
29-616 . }
29-617 .
29-618 . A = B+C;
29-619 . A = B-C;
29-620 .
29-621 . if (A ne B)
29-622 . {
29-623 . A = B + C;
29-624 . D = E + F;
29-625 . }
29-626 .
29-627 . // max LOC 49
29-628 .
29-629 . }
29-630 .
29-631 .
29-632 . /*
29-633 . -----------------------------------------------------------------------------
29-634 . --| NAME: hmi.6.6
29-635 . --|
29-636 . --| ABSTRACT:
29-637 . --| This function does hmi stuff.
29-638 . --|
29-639 . --| RETURNS:
29-640 . --| NONE.
29-641 . --|
29-642 . ----------------------------------------------------------------------------
29-643 . */
29-644 . static void hmi.6.6(void)
29-645 . {
29-646 . A = B+C;
29-647 .
29-648 . if (A != B)
29-649 . {
29-650 . A = B + C;
29-651 . D = E + F;
29-652 . }
29-653 .
29-654 . A = B*C;
29-655 . A = B/C;
29-656 .
29-657 . if (A < = B)
29-658 . {
29-659 . A = B + C;
29-660 . D = E + F;
29-661 . }
29-662 .
29-663 . A = B-C;
29-664 . A = B/C;
29-665 . A = B/C;
29-666 . A = B/C;
29-667 . // max LOC 9
29-668 .
29-669 . }
29-670 .
29 29 Result: result/source/ft-app/ft-app-B1.1/hmi/hmi-06.c
30 30 Source: source/ft-app/ft-app-B1.1/log/log-01.c
30-0 . /*
30-1 . ----------------------------------------------------------------------------
30-2 . --| BEGIN PROLOGUE
30-3 . --|
30-4 . --| CLASSIFICATION: UNCLASSIFIED
30-5 . --|
30-6 . --| FILE NAME: log-01.c
30-7 . --|
30-8 . --| ABSTRACT:
30-9 . --| This file contains the 2 functions that do file log stuff.
30-10 . --|
30-11 . --| HISTORY:
30-12 . --| CCCQ_NAME:
30-13 . --| CCCQ_VER:
30-14 . --|
30-15 . --| END PROLOGUE
30-16 . ----------------------------------------------------------------------------
30-17 . */
30-18 .
30-19 . #define D;
30-20 . #include A;
30-21 . char D;
30-22 . #define D;
30-23 . #define D;
30-24 . #include A;
30-25 .
30-26 .
30-27 .
30-28 . /*
30-29 . -----------------------------------------------------------------------------
30-30 . --| NAME: log.1.1
30-31 . --|
30-32 . --| ABSTRACT:
30-33 . --| This function does log stuff.
30-34 . --|
30-35 . --| RETURNS:
30-36 . --| NONE.
30-37 . --|
30-38 . ----------------------------------------------------------------------------
30-39 . */
30-40 . static void log.1.1(void)
30-41 . {
30-42 . A = B-C;
30-43 .
30-44 . switch (log stuff)
30-45 . {
30-46 . case one:
30-47 . {
30-48 . run_this;
30-49 . break;
30-50 . }
30-51 . case two:
30-52 . {
30-53 . run_this;
30-54 . break;
30-55 . }
30-56 . default:
30-57 . {
30-58 . SwError;
30-59 . }
30-60 . }
30-61 .
30-62 . A = B*C;
30-63 . A = B/C;
30-64 . A = B+C;
30-65 . /* LE SV TOC-2001 this is a log-01.1.6 req to transform*/
30-66 .
30-67 . if (A ne B)
30-68 . {
30-69 . A = B + C;
30-70 . D = E + F;
30-71 . }
30-72 .
30-73 .
30-74 . if (A eq B)
30-75 . {
30-76 . A = B + C;
30-77 . D = E + F;
30-78 . }
30-79 .
30-80 . A = B/C;
30-81 . A = B*C;
30-82 . A = B-C;
30-83 .
30-84 . if (A le B)
30-85 . {
30-86 . A = B + C;
30-87 . D = E + F;
30-88 . }
30-89 .
30-90 . /* LE SV TOC-2002 this is a log-01.1.12 req to set RTC*/
30-91 . A = B/C;
30-92 . A = B+C;
30-93 . A = B+C;
30-94 .
30-95 . if (A ne B)
30-96 . {
30-97 . A = B + C;
30-98 . D = E + F;
30-99 . }
30-100 .
30-101 . A = B/C;
30-102 . A = B-C;
30-103 .
30-104 . if (A lt B)
30-105 . {
30-106 . A = B + C;
30-107 . D = E + F;
30-108 . }
30-109 .
30-110 .
30-111 . if (A == B)
30-112 . {
30-113 . A = B + C;
30-114 . D = E + F;
30-115 . }
30-116 .
30-117 . /* LE SV TOC-2003 this is a log-01.1.20 req to convert*/
30-118 . A = B+C;
30-119 . A = B/C;
30-120 . A = B+C;
30-121 .
30-122 . if (A gt B)
30-123 . {
30-124 . A = B + C;
30-125 . D = E + F;
30-126 . }
30-127 .
30-128 .
30-129 . if (A > B)
30-130 . {
30-131 . A = B + C;
30-132 . D = E + F;
30-133 . }
30-134 .
30-135 . A = B+C;
30-136 . A = B*C;
30-137 .
30-138 . if (A lt B)
30-139 . {
30-140 . A = B + C;
30-141 . D = E + F;
30-142 . }
30-143 .
30-144 .
30-145 . if (A < B)
30-146 . {
30-147 . A = B + C;
30-148 . D = E + F;
30-149 . }
30-150 .
30-151 . A = B*C;
30-152 . A = B-C;
30-153 .
30-154 . if (A < B)
30-155 . {
30-156 . A = B + C;
30-157 . D = E + F;
30-158 . }
30-159 .
30-160 . A = B+C;
30-161 . A = B-C;
30-162 . A = B-C;
30-163 .
30-164 . if (A == B)
30-165 . {
30-166 . A = B + C;
30-167 . D = E + F;
30-168 . }
30-169 .
30-170 . A = B/C;
30-171 . A = B/C;
30-172 . /* LE SV TOC-2004 this is a log-01.1.38 req to compare*/
30-173 . A = B*C;
30-174 . A = B*C;
30-175 . A = B*C;
30-176 . A = B+C;
30-177 . A = B-C;
30-178 .
30-179 . switch (log stuff)
30-180 . {
30-181 . case one:
30-182 . {
30-183 . run_this;
30-184 . break;
30-185 . }
30-186 . case two:
30-187 . {
30-188 . run_this;
30-189 . break;
30-190 . }
30-191 . // missing default
30-192 . }
30-193 .
30-194 . A = B*C;
30-195 .
30-196 . if (A eq B)
30-197 . {
30-198 . A = B + C;
30-199 . D = E + F;
30-200 . }
30-201 .
30-202 . rcv_buffer = (U16 *) alloc(size+1);
30-203 . A = B*C;
30-204 .
30-205 . if (A gt B)
30-206 . {
30-207 . A = B + C;
30-208 . D = E + F;
30-209 . }
30-210 .
30-211 . /* LE SV TOC-2005 this is a log-01.1.47 req to inhibit*/
30-212 .
30-213 . switch (log stuff)
30-214 . {
30-215 . case one:
30-216 . {
30-217 . run_this;
30-218 . break;
30-219 . }
30-220 . case two:
30-221 . {
30-222 . run_this;
30-223 . break;
30-224 . }
30-225 . default:
30-226 . {
30-227 . SwError;
30-228 . }
30-229 . }
30-230 .
30-231 . A = B-C;
30-232 . A = B+C;
30-233 . A = B-C;
30-234 .
30-235 . if (A ge B)
30-236 . {
30-237 . A = B + C;
30-238 . D = E + F;
30-239 . }
30-240 .
30-241 . A = B+C;
30-242 . A = B+C;
30-243 . // max LOC 53
30-244 .
30-245 . }
30-246 .
30-247 .
30-248 . /*
30-249 . -----------------------------------------------------------------------------
30-250 . --| NAME: log.1.2
30-251 . --|
30-252 . --| ABSTRACT:
30-253 . --| This function does log stuff.
30-254 . --|
30-255 . --| RETURNS:
30-256 . --| NONE.
30-257 . --|
30-258 . ----------------------------------------------------------------------------
30-259 . */
30-260 . static void log.1.2(void)
30-261 . {
30-262 .
30-263 . switch (log stuff)
30-264 . {
30-265 . case one:
30-266 . {
30-267 . run_this;
30-268 . break;
30-269 . }
30-270 . case two:
30-271 . {
30-272 . run_this;
30-273 . break;
30-274 . }
30-275 . default:
30-276 . {
30-277 . SwError;
30-278 . }
30-279 . }
30-280 .
30-281 . /* LE SV TOC-2006 this is a log-01.2.2 req to halt*/
30-282 . A = B/C;
30-283 .
30-284 . if (A < B)
30-285 . {
30-286 . A = B + C;
30-287 . D = E + F;
30-288 . }
30-289 .
30-290 .
30-291 . if (A lt B)
30-292 . {
30-293 . A = B + C;
30-294 . D = E + F;
30-295 . }
30-296 .
30-297 . A = B/C;
30-298 . A = B/C;
30-299 . A = B/C;
30-300 . A = B+C;
30-301 . /* LE SV TOC-2007 this is a log-01.2.9 req to transform*/
30-302 . A = B/C;
30-303 . /* LE SV TOC-2008 this is a log-01.2.10 req to recover*/
30-304 . A = B-C;
30-305 .
30-306 . switch (log stuff)
30-307 . {
30-308 . case one:
30-309 . {
30-310 . run_this;
30-311 . break;
30-312 . }
30-313 . case two:
30-314 . {
30-315 . run_this;
30-316 . break;
30-317 . }
30-318 . default:
30-319 . {
30-320 . SwError;
30-321 . }
30-322 . }
30-323 .
30-324 . A = B-C;
30-325 . A = B/C;
30-326 . A = B/C;
30-327 . A = B-C;
30-328 . /* LE SV TOC-2009 this is a log-01.2.16 req to transform*/
30-329 . A = B+C;
30-330 .
30-331 . if (A ge B)
30-332 . {
30-333 . A = B + C;
30-334 . D = E + F;
30-335 . }
30-336 .
30-337 .
30-338 . if (A < = B)
30-339 . {
30-340 . A = B + C;
30-341 . D = E + F;
30-342 . }
30-343 .
30-344 . A = B+C;
30-345 . A = B+C;
30-346 .
30-347 . if (A > = B)
30-348 . {
30-349 . A = B + C;
30-350 . D = E + F;
30-351 . }
30-352 .
30-353 . A = B-C;
30-354 . A = B*C;
30-355 . A = B/C;
30-356 . A = B/C;
30-357 . A = B*C;
30-358 . A = B+C;
30-359 . A = B*C;
30-360 . A = B/C;
30-361 . // max LOC 29
30-362 .
30-363 . }
30-364 .
30 30 Result: result/source/ft-app/ft-app-B1.1/log/log-01.c
31 31 Source: source/ft-app/ft-app-B1.1/log/log-02.c
31-0 . /*
31-1 . ----------------------------------------------------------------------------
31-2 . --| BEGIN PROLOGUE
31-3 . --|
31-4 . --| CLASSIFICATION: UNCLASSIFIED
31-5 . --|
31-6 . --| FILE NAME: log-02.c
31-7 . --|
31-8 . --| ABSTRACT:
31-9 . --| This file contains the 1 functions that do file log stuff.
31-10 . --|
31-11 . --| HISTORY:
31-12 . --| CCCQ_NAME:
31-13 . --| CCCQ_VER:
31-14 . --|
31-15 . --| END PROLOGUE
31-16 . ----------------------------------------------------------------------------
31-17 . */
31-18 .
31-19 . float B;
31-20 . #define B;
31-21 . #define C;
31-22 . #include B;
31-23 . #define D;
31-24 .
31-25 .
31-26 .
31-27 . /*
31-28 . -----------------------------------------------------------------------------
31-29 . --| NAME: log.2.1
31-30 . --|
31-31 . --| ABSTRACT:
31-32 . --| This function does log stuff.
31-33 . --|
31-34 . --| RETURNS:
31-35 . --| NONE.
31-36 . --|
31-37 . ----------------------------------------------------------------------------
31-38 . */
31-39 . static void log.2.1(void)
31-40 . {
31-41 . A = B+C;
31-42 . A = B-C;
31-43 .
31-44 . /* dead_block = C * D;
31-45 . dead_block = E * F; */
31-46 .
31-47 . A = B*C;
31-48 .
31-49 . switch (log stuff)
31-50 . {
31-51 . case one:
31-52 . {
31-53 . run_this;
31-54 . break;
31-55 . }
31-56 . case two:
31-57 . {
31-58 . run_this;
31-59 . break;
31-60 . }
31-61 . default:
31-62 . {
31-63 . SwError;
31-64 . }
31-65 . }
31-66 .
31-67 .
31-68 . if (A < B)
31-69 . {
31-70 . A = B + C;
31-71 . D = E + F;
31-72 . }
31-73 .
31-74 .
31-75 . switch (log stuff)
31-76 . {
31-77 . case one:
31-78 . {
31-79 . switch (nested)
31-80 . {
31-81 . case:
31-82 . X = Y + Z;
31-83 . case:
31-84 . X = Y + Z;
31-85 . default:
31-86 . SwError;
31-87 . }
31-88 . }
31-89 . case two:
31-90 . {
31-91 . run_this;
31-92 . break;
31-93 . }
31-94 . default:
31-95 . {
31-96 . SwError;
31-97 . }
31-98 . }
31-99 .
31-100 .
31-101 . if (A > B)
31-102 . {
31-103 . A = B + C;
31-104 . D = E + F;
31-105 . }
31-106 .
31-107 . A = B*C;
31-108 . A = B*C;
31-109 . A = B*C;
31-110 . A = B-C;
31-111 . A = B-C;
31-112 . A = B+C;
31-113 . A = B+C;
31-114 . /* LE SV TOC-2010 this is a log-02.1.14 req to update*/
31-115 . A = B/C;
31-116 . /* LE SV TOC-2011 this is a log-02.1.15 req to record*/
31-117 . A = B*C;
31-118 .
31-119 . if (A ge B)
31-120 . {
31-121 . A = B + C;
31-122 . D = E + F;
31-123 . }
31-124 .
31-125 . A = B+C;
31-126 . /* LE SV TOC-2012 this is a log-02.1.18 req to transform*/
31-127 . A = B-C;
31-128 . A = B/C;
31-129 . A = B-C;
31-130 . A = B/C;
31-131 . A = B+C;
31-132 . A = B+C;
31-133 . A = B/C;
31-134 . A = B*C;
31-135 . A = B*C;
31-136 .
31-137 . if (A lt B)
31-138 . {
31-139 . A = B + C;
31-140 . D = E + F;
31-141 . }
31-142 .
31-143 . A = B/C;
31-144 . // max LOC 28
31-145 .
31-146 . }
31-147 .
31 31 Result: result/source/ft-app/ft-app-B1.1/log/log-02.c
32 32 Source: source/ft-app/ft-app-B1.1/log/log-03.c
32-0 . /*
32-1 . ----------------------------------------------------------------------------
32-2 . --| BEGIN PROLOGUE
32-3 . --|
32-4 . --| CLASSIFICATION: UNCLASSIFIED
32-5 . --|
32-6 . --| FILE NAME: log-03.c
32-7 . --|
32-8 . --| ABSTRACT:
32-9 . --| This file contains the 7 functions that do file log stuff.
32-10 . --|
32-11 . --| HISTORY:
32-12 . --| CCCQ_NAME:
32-13 . --| CCCQ_VER:
32-14 . --|
32-15 . --| END PROLOGUE
32-16 . ----------------------------------------------------------------------------
32-17 . */
32-18 .
32-19 . #include C;
32-20 . char D;
32-21 . #include A;
32-22 . char D;
32-23 . char D;
32-24 . char D;
32-25 .
32-26 .
32-27 .
32-28 . /*
32-29 . -----------------------------------------------------------------------------
32-30 . --| NAME: log.3.1
32-31 . --|
32-32 . --| ABSTRACT:
32-33 . --| This function does log stuff.
32-34 . --|
32-35 . --| RETURNS:
32-36 . --| NONE.
32-37 . --|
32-38 . ----------------------------------------------------------------------------
32-39 . */
32-40 . static void log.3.1(void)
32-41 . {
32-42 .
32-43 . if (A != B)
32-44 . {
32-45 . A = B + C;
32-46 . D = E + F;
32-47 . }
32-48 .
32-49 .
32-50 . if (A > B)
32-51 . {
32-52 . A = B + C;
32-53 . D = E + F;
32-54 . }
32-55 .
32-56 . A = B-C;
32-57 .
32-58 . if (A < B)
32-59 . {
32-60 . A = B + C;
32-61 . D = E + F;
32-62 . }
32-63 .
32-64 . A = B+C;
32-65 .
32-66 . if (A > = B)
32-67 . {
32-68 . A = B + C;
32-69 . D = E + F;
32-70 . }
32-71 .
32-72 . A = B-C;
32-73 .
32-74 . if (A > = B)
32-75 . {
32-76 . A = B + C;
32-77 . D = E + F;
32-78 . }
32-79 .
32-80 . A = B-C;
32-81 . A = B+C;
32-82 . FreePtr = HmiStringPtr;
32-83 .
32-84 . if (A > = B)
32-85 . {
32-86 . A = B + C;
32-87 . D = E + F;
32-88 . }
32-89 .
32-90 . A = B*C;
32-91 .
32-92 . if (A eq B)
32-93 . {
32-94 . A = B + C;
32-95 . D = E + F;
32-96 . }
32-97 .
32-98 . A = B+C;
32-99 . A = (int)B + C;
32-100 . A = B-C;
32-101 .
32-102 . if (A < = B)
32-103 . {
32-104 . A = B + C;
32-105 . D = E + F;
32-106 . }
32-107 .
32-108 . A = B-C;
32-109 . A = B*C;
32-110 . A = B+C;
32-111 . A = B+C;
32-112 .
32-113 . if (A < = B)
32-114 . {
32-115 . A = B + C;
32-116 . D = E + F;
32-117 . }
32-118 .
32-119 . A = B*C;
32-120 . A = B+C;
32-121 . A = B+C;
32-122 . A = B+C;
32-123 . A = B*C;
32-124 . A = B/C;
32-125 .
32-126 . if (A == B)
32-127 . {
32-128 . A = B + C;
32-129 . D = E + F;
32-130 . }
32-131 .
32-132 . A = B/C;
32-133 . A = B*C;
32-134 . A = B-C;
32-135 . A = B+C;
32-136 . A = B*C;
32-137 . A = B*C;
32-138 .
32-139 . if (veg)
32-140 . // missing curly brace
32-141 . variable = orange;
32-142 .
32-143 . A = B-C;
32-144 . A = 0x0001;
32-145 . A = B-C;
32-146 . A = B*C;
32-147 . A = B/C;
32-148 . A = B+C;
32-149 .
32-150 . switch (log stuff)
32-151 . {
32-152 . case one:
32-153 . {
32-154 . run_this;
32-155 . break;
32-156 . }
32-157 . case two:
32-158 . {
32-159 . run_this;
32-160 . break;
32-161 . }
32-162 . default:
32-163 . {
32-164 . SwError;
32-165 . }
32-166 . }
32-167 .
32-168 . A = B/C;
32-169 .
32-170 . if (A > B)
32-171 . {
32-172 . A = B + C;
32-173 . D = E + F;
32-174 . }
32-175 .
32-176 . A = B*C;
32-177 .
32-178 . if (A == B)
32-179 . {
32-180 . A = B + C;
32-181 . D = E + F;
32-182 . }
32-183 .
32-184 . A = B+C;
32-185 .
32-186 . if (A ge B)
32-187 . {
32-188 . A = B + C;
32-189 . D = E + F;
32-190 . }
32-191 .
32-192 . A = B-C;
32-193 . A = B*C;
32-194 . A = B-C;
32-195 . A = B*C;
32-196 . A = B/C;
32-197 . A = B*C;
32-198 . A = B/C;
32-199 . A = B*C;
32-200 .
32-201 . if (A == B)
32-202 . {
32-203 . A = B + C;
32-204 . D = E + F;
32-205 . }
32-206 .
32-207 . A = B+C;
32-208 . A = B/C;
32-209 . A = B/C;
32-210 . A = B/C;
32-211 . A = B*C;
32-212 . A = B/C;
32-213 .
32-214 . if (A ne B)
32-215 . {
32-216 . A = B + C;
32-217 . D = E + F;
32-218 . }
32-219 .
32-220 . A = B/C;
32-221 . A = B/C;
32-222 . A = B-C;
32-223 . // max LOC 65
32-224 .
32-225 . }
32-226 .
32-227 .
32-228 . /*
32-229 . -----------------------------------------------------------------------------
32-230 . --| NAME: log.3.2
32-231 . --|
32-232 . --| ABSTRACT:
32-233 . --| This function does log stuff.
32-234 . --|
32-235 . --| RETURNS:
32-236 . --| NONE.
32-237 . --|
32-238 . ----------------------------------------------------------------------------
32-239 . */
32-240 . static void log.3.2(void)
32-241 . {
32-242 . A = B-C;
32-243 . A = B/C;
32-244 . A = B/C;
32-245 . A = B-C;
32-246 .
32-247 . if (A lt B)
32-248 . {
32-249 . A = B + C;
32-250 . D = E + F;
32-251 . }
32-252 .
32-253 . A = B*C;
32-254 . A = B-C;
32-255 . A = B+C;
32-256 . A = B+C;
32-257 . A = B-C;
32-258 . A = B+C;
32-259 .
32-260 . if (A eq B)
32-261 . {
32-262 . A = B + C;
32-263 . D = E + F;
32-264 . }
32-265 .
32-266 . A = B-C;
32-267 . A = B*C;
32-268 .
32-269 . if (A eq B)
32-270 . {
32-271 . A = B + C;
32-272 . D = E + F;
32-273 . }
32-274 .
32-275 . A = B-C;
32-276 .
32-277 . switch (log stuff)
32-278 . {
32-279 . case one:
32-280 . {
32-281 . run_this;
32-282 . break;
32-283 . }
32-284 . case two:
32-285 . {
32-286 . run_this;
32-287 . break;
32-288 . }
32-289 . default:
32-290 . {
32-291 . SwError;
32-292 . }
32-293 . }
32-294 .
32-295 .
32-296 . if (A ne B)
32-297 . {
32-298 . A = B + C;
32-299 . D = E + F;
32-300 . }
32-301 .
32-302 .
32-303 . if (A gt B)
32-304 . {
32-305 . A = B + C;
32-306 . D = E + F;
32-307 . }
32-308 .
32-309 . A = B+C;
32-310 .
32-311 . switch (log stuff)
32-312 . {
32-313 . case:
32-314 . case:
32-315 . // stacked case statements but only if there is a new line in between
32-316 .
32-317 . case:
32-318 . case:
32-319 . case:
32-320 . {
32-321 . run_this;
32-322 . break;
32-323 . }
32-324 . default:
32-325 . {
32-326 . halt;
32-327 . }
32-328 . }
32-329 .
32-330 . A = B-C;
32-331 . A = B+C;
32-332 . A = B*C;
32-333 . A = B+C;
32-334 . A = B*C;
32-335 . // max LOC 25
32-336 .
32-337 . }
32-338 .
32-339 .
32-340 . /*
32-341 . -----------------------------------------------------------------------------
32-342 . --| NAME: log.3.3
32-343 . --|
32-344 . --| ABSTRACT:
32-345 . --| This function does log stuff.
32-346 . --|
32-347 . --| RETURNS:
32-348 . --| NONE.
32-349 . --|
32-350 . ----------------------------------------------------------------------------
32-351 . */
32-352 . static void log.3.3(void)
32-353 . {
32-354 .
32-355 . if (A < = B)
32-356 . {
32-357 . A = B + C;
32-358 . D = E + F;
32-359 . }
32-360 .
32-361 . A = B/C;
32-362 .
32-363 . if (A > B)
32-364 . {
32-365 . A = B + C;
32-366 . D = E + F;
32-367 . }
32-368 .
32-369 .
32-370 . switch (log stuff)
32-371 . {
32-372 . case one:
32-373 . {
32-374 . run_this;
32-375 . // missing break
32-376 . }
32-377 . case two:
32-378 . {
32-379 . run_this;
32-380 . break;
32-381 . }
32-382 . default:
32-383 . {
32-384 . SwError;
32-385 . }
32-386 . }
32-387 .
32-388 . A = B-C;
32-389 . A = B/C;
32-390 . A = B*C;
32-391 . A = B-C;
32-392 . A = 0x0002;
32-393 . // (P) this is really improtant
32-394 . A = B-C;
32-395 . A = B*C;
32-396 . A = B/C;
32-397 . A = B-C;
32-398 . send_buffer = (U16 *) malloc(size+1);
32-399 .
32-400 . if (A le B)
32-401 . {
32-402 . A = B + C;
32-403 . D = E + F;
32-404 . }
32-405 .
32-406 .
32-407 . if (A ge B)
32-408 . {
32-409 . A = B + C;
32-410 . D = E + F;
32-411 . }
32-412 .
32-413 .
32-414 . switch (log stuff)
32-415 . {
32-416 . case one:
32-417 . {
32-418 . run_this;
32-419 . break;
32-420 . }
32-421 . case two:
32-422 . {
32-423 . run_this;
32-424 . break;
32-425 . }
32-426 . default:
32-427 . {
32-428 . SwError;
32-429 . }
32-430 . }
32-431 .
32-432 .
32-433 . if (A != B)
32-434 . {
32-435 . A = B + C;
32-436 . D = E + F;
32-437 . }
32-438 .
32-439 . A = B/C;
32-440 . /* LE SV TOC-2013 this is a log-03.3.17 req to fail*/
32-441 . free(FreePtr);
32-442 .
32-443 . if (A lt B)
32-444 . {
32-445 . A = B + C;
32-446 . D = E + F;
32-447 . }
32-448 .
32-449 . A = B-C;
32-450 . /* LE SV TOC-2014 this is a log-03.3.19 req to compare*/
32-451 .
32-452 . switch (log stuff)
32-453 . {
32-454 . case:
32-455 . case:
32-456 . // stacked case statements but only if there is a new line in between
32-457 .
32-458 . case:
32-459 . case:
32-460 . case:
32-461 . {
32-462 . run_this;
32-463 . break;
32-464 . }
32-465 . default:
32-466 . {
32-467 . halt;
32-468 . }
32-469 . }
32-470 .
32-471 . A = B-C;
32-472 . A = B+C;
32-473 . A = B+C;
32-474 . A = B-C;
32-475 . A = B+C;
32-476 . A = B+C;
32-477 . A = B*C;
32-478 . A = B-C;
32-479 . A = B*C;
32-480 . A = B/C;
32-481 . A = B-C;
32-482 . A = 0x0002;
32-483 . A = B*C;
32-484 . A = B-C;
32-485 . A = B+C;
32-486 . A = B*C;
32-487 . A = B-C;
32-488 . A = B*C;
32-489 . A = 0x0004;
32-490 .
32-491 . if (A ge B)
32-492 . {
32-493 . A = B + C;
32-494 . D = E + F;
32-495 . }
32-496 .
32-497 . A = B+C;
32-498 . A = B*C;
32-499 .
32-500 . if (A ge B)
32-501 . {
32-502 . A = B + C;
32-503 . D = E + F;
32-504 . }
32-505 .
32-506 .
32-507 . switch (log stuff)
32-508 . {
32-509 . case one:
32-510 . {
32-511 . run_this;
32-512 . break;
32-513 . }
32-514 . case two:
32-515 . {
32-516 . run_this;
32-517 . break;
32-518 . }
32-519 . default:
32-520 . {
32-521 . SwError;
32-522 . }
32-523 . }
32-524 .
32-525 . A = B/C;
32-526 . A = B+C;
32-527 . A = B-C;
32-528 . A = B/C;
32-529 .
32-530 . if (A eq B)
32-531 . {
32-532 . A = B + C;
32-533 . D = E + F;
32-534 . }
32-535 .
32-536 . A = B+C;
32-537 .
32-538 . if (A == B)
32-539 . {
32-540 . A = B + C;
32-541 . D = E + F;
32-542 . }
32-543 .
32-544 . A = B*C;
32-545 . A = B/C;
32-546 . A = B-C;
32-547 . A = B-C;
32-548 .
32-549 . if (A ne B)
32-550 . {
32-551 . A = B + C;
32-552 . D = E + F;
32-553 . }
32-554 .
32-555 . A = B-C;
32-556 .
32-557 . if (A lt B)
32-558 . {
32-559 . A = B + C;
32-560 . D = E + F;
32-561 . }
32-562 .
32-563 . A = B+C;
32-564 . A = B*C;
32-565 . free(FreePtr);
32-566 . A = B-C;
32-567 . A = B-C;
32-568 . A = B/C;
32-569 . A = B/C;
32-570 . A = B+C;
32-571 .
32-572 . if (A > = B)
32-573 . {
32-574 . A = B + C;
32-575 . D = E + F;
32-576 . }
32-577 .
32-578 . A = B+C;
32-579 . A = B+C;
32-580 .
32-581 . if (A != B)
32-582 . {
32-583 . A = B + C;
32-584 . D = E + F;
32-585 . }
32-586 .
32-587 . A = B-C;
32-588 . A = B-C;
32-589 . A = B/C;
32-590 .
32-591 . if (A != B)
32-592 . {
32-593 . A = B + C;
32-594 . D = E + F;
32-595 . }
32-596 .
32-597 .
32-598 . if (A gt B)
32-599 . {
32-600 . A = B + C;
32-601 . D = E + F;
32-602 . }
32-603 .
32-604 .
32-605 . if (A == B)
32-606 . {
32-607 . A = B + C;
32-608 . D = E + F;
32-609 . }
32-610 .
32-611 . /* LE SV TOC-2015 this is a log-03.3.72 req to increment*/
32-612 . A = B*C;
32-613 . A = B/C;
32-614 . A = B/C;
32-615 . A = B*C;
32-616 . A = B-C;
32-617 . A = B/C;
32-618 . A = B+C;
32-619 .
32-620 . if (A ge B)
32-621 . {
32-622 . A = B + C;
32-623 . D = E + F;
32-624 . }
32-625 .
32-626 . A = B*C;
32-627 .
32-628 . if (A < = B)
32-629 . {
32-630 . A = B + C;
32-631 . D = E + F;
32-632 . }
32-633 .
32-634 . A = B-C;
32-635 . A = B+C;
32-636 . A = B*C;
32-637 . A = B-C;
32-638 . A = B*C;
32-639 . A = B/C;
32-640 . A = B+C;
32-641 . A = B+C;
32-642 . /* LE SV TOC-2016 this is a log-03.3.90 req to recover*/
32-643 .
32-644 . switch (log stuff)
32-645 . {
32-646 . case one:
32-647 . {
32-648 . run_this;
32-649 . break;
32-650 . }
32-651 . case two:
32-652 . {
32-653 . run_this;
32-654 . break;
32-655 . }
32-656 . default:
32-657 . {
32-658 . SwError;
32-659 . }
32-660 . }
32-661 .
32-662 . A = B+C;
32-663 .
32-664 . if (A ne B)
32-665 . {
32-666 . A = B + C;
32-667 . D = E + F;
32-668 . }
32-669 .
32-670 . // max LOC 92
32-671 .
32-672 . }
32-673 .
32-674 .
32-675 . /*
32-676 . -----------------------------------------------------------------------------
32-677 . --| NAME: log.3.4
32-678 . --|
32-679 . --| ABSTRACT:
32-680 . --| This function does log stuff.
32-681 . --|
32-682 . --| RETURNS:
32-683 . --| NONE.
32-684 . --|
32-685 . ----------------------------------------------------------------------------
32-686 . */
32-687 . static void log.3.4(void)
32-688 . {
32-689 . A = 0x0008;
32-690 . A = B*C;
32-691 . A = B+C;
32-692 .
32-693 . if (A ne B)
32-694 . {
32-695 . A = B + C;
32-696 . D = E + F;
32-697 . }
32-698 .
32-699 . A = B/C;
32-700 .
32-701 . if (A le B)
32-702 . {
32-703 . A = B + C;
32-704 . D = E + F;
32-705 . }
32-706 .
32-707 . A = B-C;
32-708 . A = B/C;
32-709 . A = B*C;
32-710 .
32-711 . if (A gt B)
32-712 . {
32-713 . A = B + C;
32-714 . D = E + F;
32-715 . }
32-716 .
32-717 .
32-718 . if (A == B)
32-719 . {
32-720 . A = B + C;
32-721 . D = E + F;
32-722 . }
32-723 .
32-724 . A = B+C;
32-725 . A = B-C;
32-726 .
32-727 . if (A != B)
32-728 . {
32-729 . A = B + C;
32-730 . D = E + F;
32-731 . }
32-732 .
32-733 . A = B+C;
32-734 . /* LE SV TOC-2017 this is a log-03.4.15 req to disable*/
32-735 . A = B*C;
32-736 . A = B-C;
32-737 . A = B*C;
32-738 . A = B+C;
32-739 .
32-740 . #ifdef LAZY
32-741 . // this is not nice
32-742 . A = B + C;
32-743 . A = B + C;
32-744 . #endif
32-745 .
32-746 .
32-747 . if (A ne B)
32-748 . {
32-749 . A = B + C;
32-750 . D = E + F;
32-751 . }
32-752 .
32-753 . A = B+C;
32-754 . A = B-C;
32-755 . A = B*C;
32-756 . A = B/C;
32-757 . A = B/C;
32-758 . A = B*C;
32-759 . A = B-C;
32-760 .
32-761 . if (A != B)
32-762 . {
32-763 . A = B + C;
32-764 . D = E + F;
32-765 . }
32-766 .
32-767 . A = B/C;
32-768 .
32-769 . if (A == B)
32-770 . {
32-771 . A = B + C;
32-772 . D = E + F;
32-773 . }
32-774 .
32-775 . A = B-C;
32-776 . A = B*C;
32-777 .
32-778 . if (A ne B)
32-779 . {
32-780 . A = B + C;
32-781 . D = E + F;
32-782 . }
32-783 .
32-784 . A = B*C;
32-785 . A = B+C;
32-786 . /* LE SV TOC-2018 this is a log-03.4.35 req to fail*/
32-787 .
32-788 . if (A != B)
32-789 . {
32-790 . A = B + C;
32-791 . D = E + F;
32-792 . }
32-793 .
32-794 . A = B/C;
32-795 . A = B/C;
32-796 . A = B+C;
32-797 .
32-798 . if (A < = B)
32-799 . {
32-800 . A = B + C;
32-801 . D = E + F;
32-802 . }
32-803 .
32-804 . A = B/C;
32-805 . A = B/C;
32-806 . A = B/C;
32-807 .
32-808 . if (A gt B)
32-809 . {
32-810 . A = B + C;
32-811 . D = E + F;
32-812 . }
32-813 .
32-814 . A = B+C;
32-815 . A = B*C;
32-816 . A = B/C;
32-817 . A = B*C;
32-818 . A = B/C;
32-819 . A = B*C;
32-820 . A = B+C;
32-821 . A = B+C;
32-822 .
32-823 . if (A < B)
32-824 . {
32-825 . A = B + C;
32-826 . D = E + F;
32-827 . }
32-828 .
32-829 . A = B/C;
32-830 . /* LE SV TOC-2019 this is a log-03.4.54 req to call admin*/
32-831 .
32-832 . /*
32-833 . dead_block = C * D;
32-834 . dead_block = E * F;
32-835 . */
32-836 .
32-837 . A = B-C;
32-838 .
32-839 . if (A != B)
32-840 . {
32-841 . A = B + C;
32-842 . D = E + F;
32-843 . }
32-844 .
32-845 .
32-846 . if (A < B)
32-847 . {
32-848 . A = B + C;
32-849 . D = E + F;
32-850 . }
32-851 .
32-852 . A = B*C;
32-853 . A = B/C;
32-854 . A = B+C;
32-855 . // max LOC 59
32-856 .
32-857 . }
32-858 .
32-859 .
32-860 . /*
32-861 . -----------------------------------------------------------------------------
32-862 . --| NAME: log.3.5
32-863 . --|
32-864 . --| ABSTRACT:
32-865 . --| This function does log stuff.
32-866 . --|
32-867 . --| RETURNS:
32-868 . --| NONE.
32-869 . --|
32-870 . ----------------------------------------------------------------------------
32-871 . */
32-872 . static void log.3.5(void)
32-873 . {
32-874 .
32-875 . #ifdef LAZY
32-876 . // this is not nice
32-877 . A = B + C;
32-878 . A = B + C;
32-879 . #endif
32-880 .
32-881 . A = B*C;
32-882 . /* LE SV TOC-2020 this is a log-03.5.2 req to translate*/
32-883 . A = B/C;
32-884 .
32-885 . if (A != B)
32-886 . {
32-887 . A = B + C;
32-888 . D = E + F;
32-889 . }
32-890 .
32-891 .
32-892 . if (A ne B)
32-893 . {
32-894 . A = B + C;
32-895 . D = E + F;
32-896 . }
32-897 .
32-898 .
32-899 . if (A le B)
32-900 . {
32-901 . A = B + C;
32-902 . D = E + F;
32-903 . }
32-904 .
32-905 . A = B-C;
32-906 .
32-907 . if (A == B)
32-908 . {
32-909 . A = B + C;
32-910 . D = E + F;
32-911 . }
32-912 .
32-913 .
32-914 . if (A gt B)
32-915 . {
32-916 . A = B + C;
32-917 . D = E + F;
32-918 . }
32-919 .
32-920 . A = B*C;
32-921 . A = B/C;
32-922 . A = B*C;
32-923 .
32-924 . if (A == B)
32-925 . {
32-926 . A = B + C;
32-927 . D = E + F;
32-928 . }
32-929 .
32-930 . A = B/C;
32-931 . A = B/C;
32-932 . A = B*C;
32-933 . /* LE SV TOC-2021 this is a log-03.5.16 req to record*/
32-934 . A = B/C;
32-935 . A = B*C;
32-936 .
32-937 . if (A eq B)
32-938 . {
32-939 . A = B + C;
32-940 . D = E + F;
32-941 . }
32-942 .
32-943 .
32-944 . if (A le B)
32-945 . {
32-946 . A = B + C;
32-947 . D = E + F;
32-948 . }
32-949 .
32-950 .
32-951 . if (A eq B)
32-952 . {
32-953 . A = B + C;
32-954 . D = E + F;
32-955 . }
32-956 .
32-957 .
32-958 . if (A ge B)
32-959 . {
32-960 . A = B + C;
32-961 . D = E + F;
32-962 . }
32-963 .
32-964 . A = B/C;
32-965 . A = B-C;
32-966 . A = B+C;
32-967 .
32-968 . if (A eq B)
32-969 . {
32-970 . A = B + C;
32-971 . D = E + F;
32-972 . }
32-973 .
32-974 .
32-975 . if (A eq B)
32-976 . {
32-977 . A = B + C;
32-978 . D = E + F;
32-979 . }
32-980 .
32-981 .
32-982 . if (A < B)
32-983 . {
32-984 . A = B + C;
32-985 . D = E + F;
32-986 . }
32-987 .
32-988 .
32-989 . switch (log stuff)
32-990 . {
32-991 . case one:
32-992 . {
32-993 . run_this;
32-994 . break;
32-995 . }
32-996 . case two:
32-997 . {
32-998 . run_this;
32-999 . break;
32-1000 . }
32-1001 . default:
32-1002 . {
32-1003 . SwError;
32-1004 . }
32-1005 . }
32-1006 .
32-1007 . A = B+C;
32-1008 . A = B+C;
32-1009 . A = B-C;
32-1010 . A = B/C;
32-1011 . A = 0x0006;
32-1012 . A = B/C;
32-1013 . A = B+C;
32-1014 . A = B-C;
32-1015 .
32-1016 . if (A < = B)
32-1017 . {
32-1018 . A = B + C;
32-1019 . D = E + F;
32-1020 . }
32-1021 .
32-1022 . A = B*C;
32-1023 . A = B/C;
32-1024 . A = B-C;
32-1025 . A = B-C;
32-1026 . A = B/C;
32-1027 .
32-1028 . if (A gt B)
32-1029 . {
32-1030 . A = B + C;
32-1031 . D = E + F;
32-1032 . }
32-1033 .
32-1034 . // TBD - what do I do now
32-1035 . A = B/C;
32-1036 . A = B-C;
32-1037 . send_buffer = (U16 *) malloc(size+1);
32-1038 . A = B/C;
32-1039 .
32-1040 . if (A ge B)
32-1041 . {
32-1042 . A = B + C;
32-1043 . D = E + F;
32-1044 . }
32-1045 .
32-1046 . A = B*C;
32-1047 . /* LE SV TOC-2022 this is a log-03.5.48 req to assign*/
32-1048 . A = B/C;
32-1049 . A = B-C;
32-1050 . A = B*C;
32-1051 . /* LE SV TOC-2023 this is a log-03.5.51 req to transform*/
32-1052 .
32-1053 . if (A lt B)
32-1054 . {
32-1055 . A = B + C;
32-1056 . D = E + F;
32-1057 . }
32-1058 .
32-1059 . // max LOC 51
32-1060 .
32-1061 . }
32-1062 .
32-1063 .
32-1064 . /*
32-1065 . -----------------------------------------------------------------------------
32-1066 . --| NAME: log.3.6
32-1067 . --|
32-1068 . --| ABSTRACT:
32-1069 . --| This function does log stuff.
32-1070 . --|
32-1071 . --| RETURNS:
32-1072 . --| NONE.
32-1073 . --|
32-1074 . ----------------------------------------------------------------------------
32-1075 . */
32-1076 . static void log.3.6(void)
32-1077 . {
32-1078 . A = B*C;
32-1079 . A = B+C;
32-1080 .
32-1081 . if (A lt B)
32-1082 . {
32-1083 . A = B + C;
32-1084 . D = E + F;
32-1085 . }
32-1086 .
32-1087 . A = B*C;
32-1088 . A = B+C;
32-1089 . A = B/C;
32-1090 . /* LE SV TOC-2024 this is a log-03.6.7 req to set Real Time Clock*/
32-1091 .
32-1092 . if (A ge B)
32-1093 . {
32-1094 . A = B + C;
32-1095 . D = E + F;
32-1096 . }
32-1097 .
32-1098 .
32-1099 . if (A ne B)
32-1100 . {
32-1101 . A = B + C;
32-1102 . D = E + F;
32-1103 . }
32-1104 .
32-1105 . A = B*C;
32-1106 . A = B+C;
32-1107 .
32-1108 . switch (log stuff)
32-1109 . {
32-1110 . case one:
32-1111 . {
32-1112 . run_this;
32-1113 . break;
32-1114 . }
32-1115 . case two:
32-1116 . {
32-1117 . run_this;
32-1118 . break;
32-1119 . }
32-1120 . default:
32-1121 . {
32-1122 . SwError;
32-1123 . }
32-1124 . }
32-1125 .
32-1126 .
32-1127 . if (A != B)
32-1128 . {
32-1129 . A = B + C;
32-1130 . D = E + F;
32-1131 . }
32-1132 .
32-1133 . A = B-C;
32-1134 . A = B-C;
32-1135 . A = B/C;
32-1136 . A = B/C;
32-1137 . A = B/C;
32-1138 . A = B/C;
32-1139 . A = B+C;
32-1140 .
32-1141 . switch (log stuff)
32-1142 . {
32-1143 . case one:
32-1144 . {
32-1145 . run_this;
32-1146 . // missing break
32-1147 . }
32-1148 . case two:
32-1149 . {
32-1150 . run_this;
32-1151 . break;
32-1152 . }
32-1153 . default:
32-1154 . {
32-1155 . SwError;
32-1156 . }
32-1157 . }
32-1158 .
32-1159 .
32-1160 . if (A lt B)
32-1161 . {
32-1162 . A = B + C;
32-1163 . D = E + F;
32-1164 . }
32-1165 .
32-1166 . /* LE SV TOC-2025 this is a log-03.6.21 req to call isr*/
32-1167 . A = B+C;
32-1168 .
32-1169 . if (A != B)
32-1170 . {
32-1171 . A = B + C;
32-1172 . D = E + F;
32-1173 . }
32-1174 .
32-1175 . A = B+C;
32-1176 . A = B/C;
32-1177 .
32-1178 . if (A ne B)
32-1179 . {
32-1180 . A = B + C;
32-1181 . D = E + F;
32-1182 . }
32-1183 .
32-1184 . A = B-C;
32-1185 . A = B+C;
32-1186 . A = B+C;
32-1187 . A = B-C;
32-1188 .
32-1189 . switch (log stuff)
32-1190 . {
32-1191 . case one:
32-1192 . {
32-1193 . switch (nested)
32-1194 . {
32-1195 . case:
32-1196 . X = Y + Z;
32-1197 . case:
32-1198 . X = Y + Z;
32-1199 . default:
32-1200 . SwError;
32-1201 . }
32-1202 . }
32-1203 . case two:
32-1204 . {
32-1205 . run_this;
32-1206 . break;
32-1207 . }
32-1208 . default:
32-1209 . {
32-1210 . SwError;
32-1211 . }
32-1212 . }
32-1213 .
32-1214 . A = B/C;
32-1215 . A = B/C;
32-1216 .
32-1217 . if (A lt B)
32-1218 . {
32-1219 . A = B + C;
32-1220 . D = E + F;
32-1221 . }
32-1222 .
32-1223 .
32-1224 . if (A ge B)
32-1225 . {
32-1226 . A = B + C;
32-1227 . D = E + F;
32-1228 . }
32-1229 .
32-1230 . A = B/C;
32-1231 . A = B-C;
32-1232 . A = B+C;
32-1233 . A = B/C;
32-1234 . A = B/C;
32-1235 . A = B+C;
32-1236 .
32-1237 . if (A < B)
32-1238 . {
32-1239 . A = B + C;
32-1240 . D = E + F;
32-1241 . }
32-1242 .
32-1243 .
32-1244 . if (A > B)
32-1245 . {
32-1246 . A = B + C;
32-1247 . D = E + F;
32-1248 . }
32-1249 .
32-1250 .
32-1251 . if (A ge B)
32-1252 . {
32-1253 . A = B + C;
32-1254 . D = E + F;
32-1255 . }
32-1256 .
32-1257 . A = B-C;
32-1258 . /* LE SV TOC-2026 this is a log-03.6.44 req to recover*/
32-1259 . A = B+C;
32-1260 .
32-1261 . if (A < B)
32-1262 . {
32-1263 . A = B + C;
32-1264 . D = E + F;
32-1265 . }
32-1266 .
32-1267 .
32-1268 . if (A != B)
32-1269 . {
32-1270 . A = B + C;
32-1271 . D = E + F;
32-1272 . }
32-1273 .
32-1274 . A = B*C;
32-1275 . /* LE SV TOC-2027 this is a log-03.6.48 req to enable*/
32-1276 . A = 0x0007;
32-1277 .
32-1278 . if (A ne B)
32-1279 . {
32-1280 . A = B + C;
32-1281 . D = E + F;
32-1282 . }
32-1283 .
32-1284 . A = B+C;
32-1285 . A = B-C;
32-1286 . A = B+C;
32-1287 .
32-1288 . /*
32-1289 . dead_block = C * D;
32-1290 . dead_block = E * F;
32-1291 . */
32-1292 .
32-1293 . A = B*C;
32-1294 . /* LE SV TOC-2028 this is a log-03.6.53 req to increment*/
32-1295 . A = B-C;
32-1296 .
32-1297 . if (A != B)
32-1298 . {
32-1299 . A = B + C;
32-1300 . D = E + F;
32-1301 . }
32-1302 .
32-1303 . A = B/C;
32-1304 . A = B+C;
32-1305 . A = B/C;
32-1306 .
32-1307 . if (A > = B)
32-1308 . {
32-1309 . A = B + C;
32-1310 . D = E + F;
32-1311 . }
32-1312 .
32-1313 . A = B/C;
32-1314 . A = B*C;
32-1315 .
32-1316 . if (A eq B)
32-1317 . {
32-1318 . A = B + C;
32-1319 . D = E + F;
32-1320 . }
32-1321 .
32-1322 .
32-1323 . if (A < = B)
32-1324 . {
32-1325 . A = B + C;
32-1326 . D = E + F;
32-1327 . }
32-1328 .
32-1329 . A = B+C;
32-1330 . /* LE SV TOC-2029 this is a log-03.6.64 req to recover*/
32-1331 . A = B/C;
32-1332 .
32-1333 . if (A eq B)
32-1334 . {
32-1335 . A = B + C;
32-1336 . D = E + F;
32-1337 . }
32-1338 .
32-1339 . A = B-C;
32-1340 .
32-1341 . switch (log stuff)
32-1342 . {
32-1343 . case one:
32-1344 . {
32-1345 . run_this;
32-1346 . break;
32-1347 . }
32-1348 . case two:
32-1349 . {
32-1350 . run_this;
32-1351 . break;
32-1352 . }
32-1353 . default:
32-1354 . {
32-1355 . SwError;
32-1356 . }
32-1357 . }
32-1358 .
32-1359 . A = B-C;
32-1360 . A = B+C;
32-1361 . A = B+C;
32-1362 . A = B/C;
32-1363 . A = B-C;
32-1364 .
32-1365 . if (A ne B)
32-1366 . {
32-1367 . A = B + C;
32-1368 . D = E + F;
32-1369 . }
32-1370 .
32-1371 . A = B*C;
32-1372 . A = B*C;
32-1373 . A = B/C;
32-1374 . A = B/C;
32-1375 .
32-1376 . switch (log stuff)
32-1377 . {
32-1378 . case one:
32-1379 . {
32-1380 . run_this;
32-1381 . break;
32-1382 . }
32-1383 . case two:
32-1384 . {
32-1385 . run_this;
32-1386 . break;
32-1387 . }
32-1388 . default:
32-1389 . {
32-1390 . // missing error call
32-1391 . }
32-1392 . }
32-1393 .
32-1394 . A = B+C;
32-1395 . // max LOC 78
32-1396 .
32-1397 . }
32-1398 .
32-1399 .
32-1400 . /*
32-1401 . -----------------------------------------------------------------------------
32-1402 . --| NAME: log.3.7
32-1403 . --|
32-1404 . --| ABSTRACT:
32-1405 . --| This function does log stuff.
32-1406 . --|
32-1407 . --| RETURNS:
32-1408 . --| NONE.
32-1409 . --|
32-1410 . ----------------------------------------------------------------------------
32-1411 . */
32-1412 . static void log.3.7(void)
32-1413 . {
32-1414 .
32-1415 . if (A ge B)
32-1416 . {
32-1417 . A = B + C;
32-1418 . D = E + F;
32-1419 . }
32-1420 .
32-1421 . A = B+C;
32-1422 . A = B/C;
32-1423 . A = B-C;
32-1424 . A = B-C;
32-1425 . A = 0x0007;
32-1426 .
32-1427 . if (A eq B)
32-1428 . {
32-1429 . A = B + C;
32-1430 . D = E + F;
32-1431 . }
32-1432 .
32-1433 . A = B-C;
32-1434 . A = B+C;
32-1435 .
32-1436 . if (A < B)
32-1437 . {
32-1438 . A = B + C;
32-1439 . D = E + F;
32-1440 . }
32-1441 .
32-1442 . A = B*C;
32-1443 .
32-1444 . switch (log stuff)
32-1445 . {
32-1446 . case one:
32-1447 . {
32-1448 . run_this;
32-1449 . break;
32-1450 . }
32-1451 . case two:
32-1452 . {
32-1453 . run_this;
32-1454 . break;
32-1455 . }
32-1456 . default:
32-1457 . {
32-1458 . SwError;
32-1459 . }
32-1460 . }
32-1461 .
32-1462 . A = B+C;
32-1463 .
32-1464 . if (A ge B)
32-1465 . {
32-1466 . A = B + C;
32-1467 . D = E + F;
32-1468 . }
32-1469 .
32-1470 . // max LOC 13
32-1471 .
32-1472 . }
32-1473 .
32 32 Result: result/source/ft-app/ft-app-B1.1/log/log-03.c
33 33 Source: source/ft-app/ft-app-B1.1/log/log-04.c
33-0 . /*
33-1 . ----------------------------------------------------------------------------
33-2 . --| BEGIN PROLOGUE
33-3 . --|
33-4 . --| CLASSIFICATION: UNCLASSIFIED
33-5 . --|
33-6 . --| FILE NAME: log-04.c
33-7 . --|
33-8 . --| ABSTRACT:
33-9 . --| This file contains the 3 functions that do file log stuff.
33-10 . --|
33-11 . --| HISTORY:
33-12 . --| CCCQ_NAME:
33-13 . --| CCCQ_VER:
33-14 . --|
33-15 . --| END PROLOGUE
33-16 . ----------------------------------------------------------------------------
33-17 . */
33-18 .
33-19 . #define B;
33-20 . #include B;
33-21 . double C;
33-22 . double C;
33-23 . int A;
33-24 . #include D;
33-25 . #define B;
33-26 . double C;
33-27 .
33-28 .
33-29 .
33-30 . /*
33-31 . -----------------------------------------------------------------------------
33-32 . --| NAME: log.4.1
33-33 . --|
33-34 . --| ABSTRACT:
33-35 . --| This function does log stuff.
33-36 . --|
33-37 . --| RETURNS:
33-38 . --| NONE.
33-39 . --|
33-40 . ----------------------------------------------------------------------------
33-41 . */
33-42 . static void log.4.1(void)
33-43 . {
33-44 . A = B-C;
33-45 . do forever;
33-46 . A = B+C;
33-47 . A = B-C;
33-48 .
33-49 . switch (log stuff)
33-50 . {
33-51 . case one:
33-52 . {
33-53 . run_this;
33-54 . // missing break
33-55 . }
33-56 . case two:
33-57 . {
33-58 . run_this;
33-59 . break;
33-60 . }
33-61 . default:
33-62 . {
33-63 . SwError;
33-64 . }
33-65 . }
33-66 .
33-67 .
33-68 . if (A < B)
33-69 . {
33-70 . A = B + C;
33-71 . D = E + F;
33-72 . }
33-73 .
33-74 .
33-75 . if (A ge B)
33-76 . {
33-77 . A = B + C;
33-78 . D = E + F;
33-79 . }
33-80 .
33-81 . A = B*C;
33-82 .
33-83 . if (A gt B)
33-84 . {
33-85 . A = B + C;
33-86 . D = E + F;
33-87 . }
33-88 .
33-89 .
33-90 . if (A ge B)
33-91 . {
33-92 . A = B + C;
33-93 . D = E + F;
33-94 . }
33-95 .
33-96 . A = B*C;
33-97 . A = B-C;
33-98 .
33-99 . if (A eq B)
33-100 . {
33-101 . A = B + C;
33-102 . D = E + F;
33-103 . }
33-104 .
33-105 . /* LE SV TOC-2030 this is a log-04.1.12 req to detect error*/
33-106 . A = B/C;
33-107 . // ??? go see ws
33-108 . A = B/C;
33-109 . A = B+C;
33-110 . A = B+C;
33-111 . A = B+C;
33-112 . A = B*C;
33-113 .
33-114 . if (A le B)
33-115 . {
33-116 . A = B + C;
33-117 . D = E + F;
33-118 . }
33-119 .
33-120 . A = B-C;
33-121 . A = B+C;
33-122 . // max LOC 20
33-123 .
33-124 . }
33-125 .
33-126 .
33-127 . /*
33-128 . -----------------------------------------------------------------------------
33-129 . --| NAME: log.4.2
33-130 . --|
33-131 . --| ABSTRACT:
33-132 . --| This function does log stuff.
33-133 . --|
33-134 . --| RETURNS:
33-135 . --| NONE.
33-136 . --|
33-137 . ----------------------------------------------------------------------------
33-138 . */
33-139 . static void log.4.2(void)
33-140 . {
33-141 . do forever;
33-142 . A = B-C;
33-143 . A = B+C;
33-144 .
33-145 . if (A < = B)
33-146 . {
33-147 . A = B + C;
33-148 . D = E + F;
33-149 . }
33-150 .
33-151 . A = B-C;
33-152 . A = B*C;
33-153 . A = B-C;
33-154 .
33-155 . if (A ne B)
33-156 . {
33-157 . A = B + C;
33-158 . D = E + F;
33-159 . }
33-160 .
33-161 . A = B/C;
33-162 .
33-163 . if (A lt B)
33-164 . {
33-165 . A = B + C;
33-166 . D = E + F;
33-167 . }
33-168 .
33-169 . A = B+C;
33-170 .
33-171 . if (A != B)
33-172 . {
33-173 . A = B + C;
33-174 . D = E + F;
33-175 . }
33-176 .
33-177 .
33-178 . if (A != B)
33-179 . {
33-180 . A = B + C;
33-181 . D = E + F;
33-182 . }
33-183 .
33-184 . A = B/C;
33-185 . // max LOC 13
33-186 .
33-187 . }
33-188 .
33-189 .
33-190 . /*
33-191 . -----------------------------------------------------------------------------
33-192 . --| NAME: log.4.3
33-193 . --|
33-194 . --| ABSTRACT:
33-195 . --| This function does log stuff.
33-196 . --|
33-197 . --| RETURNS:
33-198 . --| NONE.
33-199 . --|
33-200 . ----------------------------------------------------------------------------
33-201 . */
33-202 . static void log.4.3(void)
33-203 . {
33-204 . A = B*C;
33-205 . A = B*C;
33-206 . A = B*C;
33-207 . A = B-C;
33-208 . A = B+C;
33-209 . /* LE SV TOC-2031 this is a log-04.3.6 req to call isr*/
33-210 . A = B/C;
33-211 .
33-212 . if (A < = B)
33-213 . {
33-214 . A = B + C;
33-215 . D = E + F;
33-216 . }
33-217 .
33-218 . A = B/C;
33-219 . A = B+C;
33-220 . A = B/C;
33-221 .
33-222 . if (A > B)
33-223 . {
33-224 . A = B + C;
33-225 . D = E + F;
33-226 . }
33-227 .
33-228 . A = B/C;
33-229 .
33-230 . if (A < = B)
33-231 . {
33-232 . A = B + C;
33-233 . D = E + F;
33-234 . }
33-235 .
33-236 . A = B/C;
33-237 . A = B-C;
33-238 .
33-239 . if (A le B)
33-240 . {
33-241 . A = B + C;
33-242 . D = E + F;
33-243 . }
33-244 .
33-245 .
33-246 . if (A lt B)
33-247 . {
33-248 . A = B + C;
33-249 . D = E + F;
33-250 . }
33-251 .
33-252 . A = B/C;
33-253 . A = B+C;
33-254 . A = B*C;
33-255 . /* LE SV TOC-2032 this is a log-04.3.21 req to recover*/
33-256 .
33-257 . if (A ge B)
33-258 . {
33-259 . A = B + C;
33-260 . D = E + F;
33-261 . }
33-262 .
33-263 .
33-264 . if (A gt B)
33-265 . {
33-266 . A = B + C;
33-267 . D = E + F;
33-268 . }
33-269 .
33-270 .
33-271 . if (A != B)
33-272 . {
33-273 . A = B + C;
33-274 . D = E + F;
33-275 . }
33-276 .
33-277 .
33-278 . if (A le B)
33-279 . {
33-280 . A = B + C;
33-281 . D = E + F;
33-282 . }
33-283 .
33-284 . A = B+C;
33-285 . A = B*C;
33-286 . A = B*C;
33-287 . A = B/C;
33-288 .
33-289 . if (A lt B)
33-290 . {
33-291 . A = B + C;
33-292 . D = E + F;
33-293 . }
33-294 .
33-295 . A = B-C;
33-296 . A = B/C;
33-297 . A = B/C;
33-298 .
33-299 . if (A > = B)
33-300 . {
33-301 . A = B + C;
33-302 . D = E + F;
33-303 . }
33-304 .
33-305 .
33-306 . if (A ge B)
33-307 . {
33-308 . A = B + C;
33-309 . D = E + F;
33-310 . }
33-311 .
33-312 . A = B-C;
33-313 .
33-314 . if (A != B)
33-315 . {
33-316 . A = B + C;
33-317 . D = E + F;
33-318 . }
33-319 .
33-320 . A = B/C;
33-321 . A = B*C;
33-322 . /* LE SV TOC-2033 this is a log-04.3.39 req to update*/
33-323 . A = B-C;
33-324 . A = B-C;
33-325 . A = B-C;
33-326 . /* LE SV TOC-2034 this is a log-04.3.42 req to reject*/
33-327 . A = B/C;
33-328 . A = B/C;
33-329 . A = B+C;
33-330 . A = B*C;
33-331 .
33-332 . if (A != B)
33-333 . {
33-334 . A = B + C;
33-335 . D = E + F;
33-336 . }
33-337 .
33-338 . A = B*C;
33-339 . A = B*C;
33-340 . A = B*C;
33-341 . A = B*C;
33-342 .
33-343 . if (A < B)
33-344 . {
33-345 . A = B + C;
33-346 . D = E + F;
33-347 . }
33-348 .
33-349 . A = B+C;
33-350 .
33-351 . if (A lt B)
33-352 . {
33-353 . A = B + C;
33-354 . D = E + F;
33-355 . }
33-356 .
33-357 . A = B+C;
33-358 .
33-359 . if (A eq B)
33-360 . {
33-361 . A = B + C;
33-362 . D = E + F;
33-363 . }
33-364 .
33-365 .
33-366 . if (A > B)
33-367 . {
33-368 . A = B + C;
33-369 . D = E + F;
33-370 . }
33-371 .
33-372 .
33-373 . if (A > B)
33-374 . {
33-375 . A = B + C;
33-376 . D = E + F;
33-377 . }
33-378 .
33-379 . // max LOC 57
33-380 .
33-381 . }
33-382 .
33 33 Result: result/source/ft-app/ft-app-B1.1/log/log-04.c
34 34 Source: source/ft-app/ft-app-B1.1/log/log-05.c
34-0 . /*
34-1 . ----------------------------------------------------------------------------
34-2 . --| BEGIN PROLOGUE
34-3 . --|
34-4 . --| CLASSIFICATION: UNCLASSIFIED
34-5 . --|
34-6 . --| FILE NAME: log-05.c
34-7 . --|
34-8 . --| ABSTRACT:
34-9 . --| This file contains the 18 functions that do file log stuff.
34-10 . --|
34-11 . --| HISTORY:
34-12 . --| CCCQ_NAME:
34-13 . --| CCCQ_VER:
34-14 . --|
34-15 . --| END PROLOGUE
34-16 . ----------------------------------------------------------------------------
34-17 . */
34-18 .
34-19 . double C;
34-20 . #include A;
34-21 . #include A;
34-22 .
34-23 .
34-24 .
34-25 . /*
34-26 . -----------------------------------------------------------------------------
34-27 . --| NAME: log.5.1
34-28 . --|
34-29 . --| ABSTRACT:
34-30 . --| This function does log stuff.
34-31 . --|
34-32 . --| RETURNS:
34-33 . --| NONE.
34-34 . --|
34-35 . ----------------------------------------------------------------------------
34-36 . */
34-37 . static void log.5.1(void)
34-38 . {
34-39 . A = B+C;
34-40 . A = B*C;
34-41 . A = B-C;
34-42 . A = B+C;
34-43 . A = B/C;
34-44 .
34-45 . if (A != B)
34-46 . {
34-47 . A = B + C;
34-48 . D = E + F;
34-49 . }
34-50 .
34-51 . A = B/C;
34-52 . A = B*C;
34-53 . A = B*C;
34-54 .
34-55 . if (A le B)
34-56 . {
34-57 . A = B + C;
34-58 . D = E + F;
34-59 . }
34-60 .
34-61 . A = B/C;
34-62 . A = B*C;
34-63 .
34-64 . if (A le B)
34-65 . {
34-66 . A = B + C;
34-67 . D = E + F;
34-68 . }
34-69 .
34-70 . A = B+C;
34-71 . // max LOC 14
34-72 .
34-73 . }
34-74 .
34-75 .
34-76 . /*
34-77 . -----------------------------------------------------------------------------
34-78 . --| NAME: log.5.2
34-79 . --|
34-80 . --| ABSTRACT:
34-81 . --| This function does log stuff.
34-82 . --|
34-83 . --| RETURNS:
34-84 . --| NONE.
34-85 . --|
34-86 . ----------------------------------------------------------------------------
34-87 . */
34-88 . static void log.5.2(void)
34-89 . {
34-90 . A = B+C;
34-91 . A = B/C;
34-92 . A = B*C;
34-93 .
34-94 . if (A le B)
34-95 . {
34-96 . A = B + C;
34-97 . D = E + F;
34-98 . }
34-99 .
34-100 . A = B/C;
34-101 . send_buffer = (U16 *) malloc(size+1);
34-102 .
34-103 . if (A < = B)
34-104 . {
34-105 . A = B + C;
34-106 . D = E + F;
34-107 . }
34-108 .
34-109 . /* LE SV TOC-2035 this is a log-05.2.7 req to process*/
34-110 .
34-111 . if (A eq B)
34-112 . {
34-113 . A = B + C;
34-114 . D = E + F;
34-115 . }
34-116 .
34-117 . A = B*C;
34-118 .
34-119 . if (A ge B)
34-120 . {
34-121 . A = B + C;
34-122 . D = E + F;
34-123 . }
34-124 .
34-125 . A = B+C;
34-126 . A = B-C;
34-127 . A = (int)B + C;
34-128 .
34-129 . if (A != B)
34-130 . {
34-131 . A = B + C;
34-132 . D = E + F;
34-133 . }
34-134 .
34-135 . A = B/C;
34-136 . A = B-C;
34-137 . /* LE SV TOC-2036 this is a log-05.2.15 req to check pSOS*/
34-138 . A = B*C;
34-139 .
34-140 . if (A != B)
34-141 . {
34-142 . A = B + C;
34-143 . D = E + F;
34-144 . }
34-145 .
34-146 .
34-147 . if (A == B)
34-148 . {
34-149 . A = B + C;
34-150 . D = E + F;
34-151 . }
34-152 .
34-153 . A = B-C;
34-154 . A = B/C;
34-155 . A = B-C;
34-156 . A = B+C;
34-157 .
34-158 . if (A gt B)
34-159 . {
34-160 . A = B + C;
34-161 . D = E + F;
34-162 . }
34-163 .
34-164 . A = B+C;
34-165 .
34-166 . if (A le B)
34-167 . {
34-168 . A = B + C;
34-169 . D = E + F;
34-170 . }
34-171 .
34-172 . A = B*C;
34-173 . A = B/C;
34-174 . A = B-C;
34-175 . A = B-C;
34-176 .
34-177 . if (A == B)
34-178 . {
34-179 . A = B + C;
34-180 . D = E + F;
34-181 . }
34-182 .
34-183 .
34-184 . if (A != B)
34-185 . {
34-186 . A = B + C;
34-187 . D = E + F;
34-188 . }
34-189 .
34-190 . A = B/C;
34-191 . A = B+C;
34-192 . A = B/C;
34-193 . A = B/C;
34-194 . A = B/C;
34-195 . A = B/C;
34-196 .
34-197 . if (A eq B)
34-198 . {
34-199 . A = B + C;
34-200 . D = E + F;
34-201 . }
34-202 .
34-203 . A = B/C;
34-204 .
34-205 . if (A < B)
34-206 . {
34-207 . A = B + C;
34-208 . D = E + F;
34-209 . }
34-210 .
34-211 . A = B-C;
34-212 . A = B*C;
34-213 . A = B+C;
34-214 . A = B/C;
34-215 .
34-216 . if (A == B)
34-217 . {
34-218 . A = B + C;
34-219 . D = E + F;
34-220 . }
34-221 .
34-222 . A = B/C;
34-223 . /* LE SV TOC-2037 this is a log-05.2.46 req to process*/
34-224 . A = B-C;
34-225 .
34-226 . if (A gt B)
34-227 . {
34-228 . A = B + C;
34-229 . D = E + F;
34-230 . }
34-231 .
34-232 .
34-233 . if (A < = B)
34-234 . {
34-235 . A = B + C;
34-236 . D = E + F;
34-237 . }
34-238 .
34-239 . A = B+C;
34-240 . // max LOC 49
34-241 .
34-242 . }
34-243 .
34-244 .
34-245 . /*
34-246 . -----------------------------------------------------------------------------
34-247 . --| NAME: log.5.3
34-248 . --|
34-249 . --| ABSTRACT:
34-250 . --| This function does log stuff.
34-251 . --|
34-252 . --| RETURNS:
34-253 . --| NONE.
34-254 . --|
34-255 . ----------------------------------------------------------------------------
34-256 . */
34-257 . static void log.5.3(void)
34-258 . {
34-259 .
34-260 . if (A ne B)
34-261 . {
34-262 . A = B + C;
34-263 . D = E + F;
34-264 . }
34-265 .
34-266 . A = 0x0009;
34-267 . A = B/C;
34-268 . A = B+C;
34-269 . /* LE SV TOC-2038 this is a log-05.3.4 req to reject*/
34-270 . A = B-C;
34-271 . A = B-C;
34-272 .
34-273 . if (A ne B)
34-274 . {
34-275 . A = B + C;
34-276 . D = E + F;
34-277 . }
34-278 .
34-279 . A = B/C;
34-280 .
34-281 . if (A le B)
34-282 . {
34-283 . A = B + C;
34-284 . D = E + F;
34-285 . }
34-286 .
34-287 .
34-288 . if (A eq B)
34-289 . {
34-290 . A = B + C;
34-291 . D = E + F;
34-292 . }
34-293 .
34-294 .
34-295 . switch (log stuff)
34-296 . {
34-297 . case one:
34-298 . {
34-299 . run_this;
34-300 . break;
34-301 . }
34-302 . case two:
34-303 . {
34-304 . run_this;
34-305 . break;
34-306 . }
34-307 . default:
34-308 . {
34-309 . SwError;
34-310 . }
34-311 . }
34-312 .
34-313 . /* LE SV TOC-2039 this is a log-05.3.11 req to update*/
34-314 .
34-315 . if (A le B)
34-316 . {
34-317 . A = B + C;
34-318 . D = E + F;
34-319 . }
34-320 .
34-321 . /* LE SV TOC-2040 this is a log-05.3.12 req to update*/
34-322 . A = 0x0006;
34-323 . A = B/C;
34-324 . A = B-C;
34-325 . A = B/C;
34-326 . A = B-C;
34-327 .
34-328 . if (A ne B)
34-329 . {
34-330 . A = B + C;
34-331 . D = E + F;
34-332 . }
34-333 .
34-334 .
34-335 . if (A == B)
34-336 . {
34-337 . A = B + C;
34-338 . D = E + F;
34-339 . }
34-340 .
34-341 .
34-342 . if (A le B)
34-343 . {
34-344 . A = B + C;
34-345 . D = E + F;
34-346 . }
34-347 .
34-348 .
34-349 . if (A eq B)
34-350 . {
34-351 . A = B + C;
34-352 . D = E + F;
34-353 . }
34-354 .
34-355 . A = B-C;
34-356 . A = B-C;
34-357 . A = B*C;
34-358 . A = B+C;
34-359 . A = B+C;
34-360 . A = B+C;
34-361 . A = 0x0007;
34-362 . A = B/C;
34-363 . A = B+C;
34-364 .
34-365 . if (A ge B)
34-366 . {
34-367 . A = B + C;
34-368 . D = E + F;
34-369 . }
34-370 .
34-371 . A = B/C;
34-372 . A = B/C;
34-373 .
34-374 . if (A ne B)
34-375 . {
34-376 . A = B + C;
34-377 . D = E + F;
34-378 . }
34-379 .
34-380 . A = B/C;
34-381 .
34-382 . if (A < B)
34-383 . {
34-384 . A = B + C;
34-385 . D = E + F;
34-386 . }
34-387 .
34-388 . /* LE SV TOC-2041 this is a log-05.3.34 req to call admin*/
34-389 .
34-390 . if ($log stuff > $otherlog stuff)
34-391 . /* LE SV TOC-008 we really should log all error calls */
34-392 . {
34-393 . A = B + C;
34-394 . }
34-395 .
34-396 .
34-397 . if (A != B)
34-398 . {
34-399 . A = B + C;
34-400 . D = E + F;
34-401 . }
34-402 .
34-403 . A = B+C;
34-404 .
34-405 . if (A == B)
34-406 . {
34-407 . A = B + C;
34-408 . D = E + F;
34-409 . }
34-410 .
34-411 . A = B-C;
34-412 . A = B+C;
34-413 .
34-414 . if (A ge B)
34-415 . {
34-416 . A = B + C;
34-417 . D = E + F;
34-418 . }
34-419 .
34-420 . A = B-C;
34-421 .
34-422 . if (A < = B)
34-423 . {
34-424 . A = B + C;
34-425 . D = E + F;
34-426 . }
34-427 .
34-428 . A = 0x0003;
34-429 . A = B-C;
34-430 . // max LOC 42
34-431 .
34-432 . }
34-433 .
34-434 .
34-435 . /*
34-436 . -----------------------------------------------------------------------------
34-437 . --| NAME: log.5.4
34-438 . --|
34-439 . --| ABSTRACT:
34-440 . --| This function does log stuff.
34-441 . --|
34-442 . --| RETURNS:
34-443 . --| NONE.
34-444 . --|
34-445 . ----------------------------------------------------------------------------
34-446 . */
34-447 . static void log.5.4(void)
34-448 . {
34-449 . /* LE SV TOC-2042 this is a log-05.4.1 req to reject*/
34-450 . A = B+C;
34-451 . A = B+C;
34-452 . A = 0x0007;
34-453 . A = B/C;
34-454 . A = B+C;
34-455 . A = B-C;
34-456 .
34-457 . if (A == B)
34-458 . {
34-459 . A = B + C;
34-460 . D = E + F;
34-461 . }
34-462 .
34-463 . /* LE SV TOC-2043 this is a log-05.4.7 req to transform*/
34-464 . A = B+C;
34-465 .
34-466 . switch (log stuff)
34-467 . {
34-468 . case:
34-469 . case:
34-470 . // stacked case statements but only if there is a new line in between
34-471 .
34-472 . case:
34-473 . case:
34-474 . case:
34-475 . {
34-476 . run_this;
34-477 . break;
34-478 . }
34-479 . default:
34-480 . {
34-481 . halt;
34-482 . }
34-483 . }
34-484 .
34-485 . A = B*C;
34-486 . A = B-C;
34-487 . A = B+C;
34-488 . free(FreePtr);
34-489 .
34-490 . if (A > = B)
34-491 . {
34-492 . A = B + C;
34-493 . D = E + F;
34-494 . }
34-495 .
34-496 . A = B/C;
34-497 .
34-498 . if (A ge B)
34-499 . {
34-500 . A = B + C;
34-501 . D = E + F;
34-502 . }
34-503 .
34-504 .
34-505 . if (A < = B)
34-506 . {
34-507 . A = B + C;
34-508 . D = E + F;
34-509 . }
34-510 .
34-511 .
34-512 . switch (log stuff)
34-513 . {
34-514 . case one:
34-515 . {
34-516 . run_this;
34-517 . break;
34-518 . }
34-519 . case two:
34-520 . {
34-521 . run_this;
34-522 . break;
34-523 . }
34-524 . default:
34-525 . {
34-526 . // missing error call
34-527 . }
34-528 . }
34-529 .
34-530 . A = B*C;
34-531 .
34-532 . if (A le B)
34-533 . {
34-534 . A = B + C;
34-535 . D = E + F;
34-536 . }
34-537 .
34-538 . A = B-C;
34-539 . A = B/C;
34-540 . A = B-C;
34-541 .
34-542 . if (A le B)
34-543 . {
34-544 . A = B + C;
34-545 . D = E + F;
34-546 . }
34-547 .
34-548 . A = B*C;
34-549 . A = B-C;
34-550 . A = B-C;
34-551 .
34-552 . if (A gt B)
34-553 . {
34-554 . A = B + C;
34-555 . D = E + F;
34-556 . }
34-557 .
34-558 . A = B+C;
34-559 . A = B*C;
34-560 . A = B*C;
34-561 .
34-562 . if (A gt B)
34-563 . {
34-564 . A = B + C;
34-565 . D = E + F;
34-566 . }
34-567 .
34-568 .
34-569 . if (A eq B)
34-570 . {
34-571 . A = B + C;
34-572 . D = E + F;
34-573 . }
34-574 .
34-575 . A = B*C;
34-576 . /* LE SV TOC-2044 this is a log-05.4.31 req to detect error*/
34-577 .
34-578 . switch (log stuff)
34-579 . {
34-580 . case one:
34-581 . {
34-582 . run_this;
34-583 . break;
34-584 . }
34-585 . case two:
34-586 . {
34-587 . run_this;
34-588 . break;
34-589 . }
34-590 . default:
34-591 . {
34-592 . SwError;
34-593 . }
34-594 . }
34-595 .
34-596 .
34-597 . if (A gt B)
34-598 . {
34-599 . A = B + C;
34-600 . D = E + F;
34-601 . }
34-602 .
34-603 .
34-604 . if (A gt B)
34-605 . {
34-606 . A = B + C;
34-607 . D = E + F;
34-608 . }
34-609 .
34-610 .
34-611 . if (A gt B)
34-612 . {
34-613 . A = B + C;
34-614 . D = E + F;
34-615 . }
34-616 .
34-617 .
34-618 . if (A < = B)
34-619 . {
34-620 . A = B + C;
34-621 . D = E + F;
34-622 . }
34-623 .
34-624 . A = B/C;
34-625 . A = B+C;
34-626 . A = B-C;
34-627 . A = B+C;
34-628 . A = B+C;
34-629 . A = B/C;
34-630 . A = B+C;
34-631 . A = B/C;
34-632 . A = B+C;
34-633 . A = B+C;
34-634 . A = B*C;
34-635 . // TBD - what do I do now
34-636 . A = B*C;
34-637 .
34-638 . if (A ne B)
34-639 . {
34-640 . A = B + C;
34-641 . D = E + F;
34-642 . }
34-643 .
34-644 .
34-645 . if (A lt B)
34-646 . {
34-647 . A = B + C;
34-648 . D = E + F;
34-649 . }
34-650 .
34-651 . A = B/C;
34-652 .
34-653 . switch (log stuff)
34-654 . {
34-655 . case one:
34-656 . {
34-657 . run_this;
34-658 . break;
34-659 . }
34-660 . case two:
34-661 . {
34-662 . run_this;
34-663 . break;
34-664 . }
34-665 . default:
34-666 . {
34-667 . SwError;
34-668 . }
34-669 . }
34-670 .
34-671 . A = B-C;
34-672 .
34-673 . if (A ne B)
34-674 . {
34-675 . A = B + C;
34-676 . D = E + F;
34-677 . }
34-678 .
34-679 . A = (int)B + C;
34-680 .
34-681 . if (A > B)
34-682 . {
34-683 . A = B + C;
34-684 . D = E + F;
34-685 . }
34-686 .
34-687 . A = B*C;
34-688 . A = B+C;
34-689 . A = B+C;
34-690 . // max LOC 57
34-691 .
34-692 . }
34-693 .
34-694 .
34-695 . /*
34-696 . -----------------------------------------------------------------------------
34-697 . --| NAME: log.5.5
34-698 . --|
34-699 . --| ABSTRACT:
34-700 . --| This function does log stuff.
34-701 . --|
34-702 . --| RETURNS:
34-703 . --| NONE.
34-704 . --|
34-705 . ----------------------------------------------------------------------------
34-706 . */
34-707 . static void log.5.5(void)
34-708 . {
34-709 . A = B+C;
34-710 . A = B-C;
34-711 . A = B+C;
34-712 . A = B-C;
34-713 . A = B/C;
34-714 . A = B-C;
34-715 . A = B/C;
34-716 .
34-717 . if (A == B)
34-718 . {
34-719 . A = B + C;
34-720 . D = E + F;
34-721 . }
34-722 .
34-723 . A = B-C;
34-724 .
34-725 . if (A > B)
34-726 . {
34-727 . A = B + C;
34-728 . D = E + F;
34-729 . }
34-730 .
34-731 . A = B*C;
34-732 .
34-733 . if (A le B)
34-734 . {
34-735 . A = B + C;
34-736 . D = E + F;
34-737 . }
34-738 .
34-739 .
34-740 . switch (log stuff)
34-741 . {
34-742 . case one:
34-743 . {
34-744 . run_this;
34-745 . break;
34-746 . }
34-747 . case two:
34-748 . {
34-749 . run_this;
34-750 . break;
34-751 . }
34-752 . default:
34-753 . {
34-754 . SwError;
34-755 . }
34-756 . }
34-757 .
34-758 . A = B/C;
34-759 . A = B*C;
34-760 . A = B+C;
34-761 . A = B/C;
34-762 . A = B+C;
34-763 . A = 0x0003;
34-764 . A = B*C;
34-765 . A = B*C;
34-766 .
34-767 . if (A ne B)
34-768 . {
34-769 . A = B + C;
34-770 . D = E + F;
34-771 . }
34-772 .
34-773 . A = B/C;
34-774 .
34-775 . if (A eq B)
34-776 . {
34-777 . A = B + C;
34-778 . D = E + F;
34-779 . }
34-780 .
34-781 . A = B-C;
34-782 .
34-783 . if (A != B)
34-784 . {
34-785 . A = B + C;
34-786 . D = E + F;
34-787 . }
34-788 .
34-789 . A = B-C;
34-790 . A = B+C;
34-791 . A = B-C;
34-792 . A = B*C;
34-793 . A = B/C;
34-794 .
34-795 . if (A != B)
34-796 . {
34-797 . A = B + C;
34-798 . D = E + F;
34-799 . }
34-800 .
34-801 . // max LOC 31
34-802 .
34-803 . }
34-804 .
34-805 .
34-806 . /*
34-807 . -----------------------------------------------------------------------------
34-808 . --| NAME: log.5.6
34-809 . --|
34-810 . --| ABSTRACT:
34-811 . --| This function does log stuff.
34-812 . --|
34-813 . --| RETURNS:
34-814 . --| NONE.
34-815 . --|
34-816 . ----------------------------------------------------------------------------
34-817 . */
34-818 . static void log.5.6(void)
34-819 . {
34-820 . A = B+C;
34-821 .
34-822 . if (A < B)
34-823 . {
34-824 . A = B + C;
34-825 . D = E + F;
34-826 . }
34-827 .
34-828 . A = B+C;
34-829 . /* LE SV TOC-2045 this is a log-05.6.4 req to assign*/
34-830 . A = B-C;
34-831 . A = B+C;
34-832 . A = B*C;
34-833 . A = B/C;
34-834 . A = B+C;
34-835 .
34-836 . if (A > = B)
34-837 . {
34-838 . A = B + C;
34-839 . D = E + F;
34-840 . }
34-841 .
34-842 . A = B-C;
34-843 . A = B+C;
34-844 . A = B+C;
34-845 . A = B+C;
34-846 . A = B/C;
34-847 . /* LE SV TOC-2046 this is a log-05.6.15 req to verify*/
34-848 .
34-849 . if (A eq B)
34-850 . {
34-851 . A = B + C;
34-852 . D = E + F;
34-853 . }
34-854 .
34-855 . A = B*C;
34-856 . A = B*C;
34-857 . /* LE SV TOC-2047 this is a log-05.6.18 req to process*/
34-858 . A = B-C;
34-859 .
34-860 . if (A le B)
34-861 . {
34-862 . A = B + C;
34-863 . D = E + F;
34-864 . }
34-865 .
34-866 . A = B+C;
34-867 . A = B*C;
34-868 .
34-869 . if (A ne B)
34-870 . {
34-871 . A = B + C;
34-872 . D = E + F;
34-873 . }
34-874 .
34-875 . A = B/C;
34-876 . A = B/C;
34-877 .
34-878 . if (A > B)
34-879 . {
34-880 . A = B + C;
34-881 . D = E + F;
34-882 . }
34-883 .
34-884 . A = 0x0004;
34-885 . A = B+C;
34-886 . A = B-C;
34-887 . A = B/C;
34-888 . A = B-C;
34-889 .
34-890 . if (A < = B)
34-891 . {
34-892 . A = B + C;
34-893 . D = E + F;
34-894 . }
34-895 .
34-896 . A = B-C;
34-897 .
34-898 . if (A le B)
34-899 . {
34-900 . A = B + C;
34-901 . D = E + F;
34-902 . }
34-903 .
34-904 . A = B*C;
34-905 .
34-906 . if (A ne B)
34-907 . {
34-908 . A = B + C;
34-909 . D = E + F;
34-910 . }
34-911 .
34-912 . A = B*C;
34-913 .
34-914 . if (A > = B)
34-915 . {
34-916 . A = B + C;
34-917 . D = E + F;
34-918 . }
34-919 .
34-920 . // max LOC 36
34-921 .
34-922 . }
34-923 .
34-924 .
34-925 . /*
34-926 . -----------------------------------------------------------------------------
34-927 . --| NAME: log.5.7
34-928 . --|
34-929 . --| ABSTRACT:
34-930 . --| This function does log stuff.
34-931 . --|
34-932 . --| RETURNS:
34-933 . --| NONE.
34-934 . --|
34-935 . ----------------------------------------------------------------------------
34-936 . */
34-937 . static void log.5.7(void)
34-938 . {
34-939 .
34-940 . if (A eq B)
34-941 . {
34-942 . A = B + C;
34-943 . D = E + F;
34-944 . }
34-945 .
34-946 . A = B+C;
34-947 . A = B/C;
34-948 . A = B*C;
34-949 . A = B*C;
34-950 .
34-951 . if (A < B)
34-952 . {
34-953 . A = B + C;
34-954 . D = E + F;
34-955 . }
34-956 .
34-957 .
34-958 . if (A > = B)
34-959 . {
34-960 . A = B + C;
34-961 . D = E + F;
34-962 . }
34-963 .
34-964 . A = B-C;
34-965 . A = B+C;
34-966 . A = B*C;
34-967 . A = B/C;
34-968 . A = B-C;
34-969 . A = B+C;
34-970 . A = B+C;
34-971 .
34-972 . if (A eq B)
34-973 . {
34-974 . A = B + C;
34-975 . D = E + F;
34-976 . }
34-977 .
34-978 . A = B+C;
34-979 .
34-980 . if (A ge B)
34-981 . {
34-982 . A = B + C;
34-983 . D = E + F;
34-984 . }
34-985 .
34-986 .
34-987 . if (A < B)
34-988 . {
34-989 . A = B + C;
34-990 . D = E + F;
34-991 . }
34-992 .
34-993 . /* LE SV TOC-2048 this is a log-05.7.19 req to store*/
34-994 .
34-995 . if (A ge B)
34-996 . {
34-997 . A = B + C;
34-998 . D = E + F;
34-999 . }
34-1000 .
34-1001 .
34-1002 . if (A == B)
34-1003 . {
34-1004 . A = B + C;
34-1005 . D = E + F;
34-1006 . }
34-1007 .
34-1008 . A = B*C;
34-1009 . send_buffer = (U16 *) malloc(size+1);
34-1010 .
34-1011 . if (A < = B)
34-1012 . {
34-1013 . A = B + C;
34-1014 . D = E + F;
34-1015 . }
34-1016 .
34-1017 . A = B*C;
34-1018 .
34-1019 . if (A gt B)
34-1020 . {
34-1021 . A = B + C;
34-1022 . D = E + F;
34-1023 . }
34-1024 .
34-1025 . A = B+C;
34-1026 . A = B-C;
34-1027 . /* LE SV TOC-2049 this is a log-05.7.27 req to recover*/
34-1028 . A = B-C;
34-1029 . /* LE SV TOC-2050 this is a log-05.7.28 req to verify*/
34-1030 . A = 0x0008;
34-1031 . A = B/C;
34-1032 . A = B/C;
34-1033 . A = B-C;
34-1034 .
34-1035 . if (A gt B)
34-1036 . {
34-1037 . A = B + C;
34-1038 . D = E + F;
34-1039 . }
34-1040 .
34-1041 . A = B+C;
34-1042 .
34-1043 . if (A != B)
34-1044 . {
34-1045 . A = B + C;
34-1046 . D = E + F;
34-1047 . }
34-1048 .
34-1049 . A = B*C;
34-1050 . A = B/C;
34-1051 . /* LE SV TOC-2051 this is a log-05.7.36 req to compare*/
34-1052 . A = B/C;
34-1053 .
34-1054 . if (A > B)
34-1055 . {
34-1056 . A = B + C;
34-1057 . D = E + F;
34-1058 . }
34-1059 .
34-1060 . A = B/C;
34-1061 .
34-1062 . if (A > B)
34-1063 . {
34-1064 . A = B + C;
34-1065 . D = E + F;
34-1066 . }
34-1067 .
34-1068 .
34-1069 . if (A le B)
34-1070 . {
34-1071 . A = B + C;
34-1072 . D = E + F;
34-1073 . }
34-1074 .
34-1075 . A = B-C;
34-1076 . A = B/C;
34-1077 .
34-1078 . if (A lt B)
34-1079 . {
34-1080 . A = B + C;
34-1081 . D = E + F;
34-1082 . }
34-1083 .
34-1084 .
34-1085 . if (A le B)
34-1086 . {
34-1087 . A = B + C;
34-1088 . D = E + F;
34-1089 . }
34-1090 .
34-1091 . A = B*C;
34-1092 .
34-1093 . if (A lt B)
34-1094 . {
34-1095 . A = B + C;
34-1096 . D = E + F;
34-1097 . }
34-1098 .
34-1099 . A = B+C;
34-1100 . A = B/C;
34-1101 .
34-1102 . if (A ge B)
34-1103 . {
34-1104 . A = B + C;
34-1105 . D = E + F;
34-1106 . }
34-1107 .
34-1108 . A = B-C;
34-1109 . A = B/C;
34-1110 . A = B/C;
34-1111 .
34-1112 . switch (log stuff)
34-1113 . {
34-1114 . case:
34-1115 . case:
34-1116 . // stacked case statements but only if there is a new line in between
34-1117 .
34-1118 . case:
34-1119 . case:
34-1120 . case:
34-1121 . {
34-1122 . run_this;
34-1123 . break;
34-1124 . }
34-1125 . default:
34-1126 . {
34-1127 . halt;
34-1128 . }
34-1129 . }
34-1130 .
34-1131 .
34-1132 . if (A gt B)
34-1133 . {
34-1134 . A = B + C;
34-1135 . D = E + F;
34-1136 . }
34-1137 .
34-1138 . A = B-C;
34-1139 .
34-1140 . if (A ne B)
34-1141 . {
34-1142 . A = B + C;
34-1143 . D = E + F;
34-1144 . }
34-1145 .
34-1146 . A = B-C;
34-1147 . A = B-C;
34-1148 .
34-1149 . if (A != B)
34-1150 . {
34-1151 . A = B + C;
34-1152 . D = E + F;
34-1153 . }
34-1154 .
34-1155 .
34-1156 . switch (log stuff)
34-1157 . {
34-1158 . case one:
34-1159 . {
34-1160 . run_this;
34-1161 . break;
34-1162 . }
34-1163 . case two:
34-1164 . {
34-1165 . run_this;
34-1166 . break;
34-1167 . }
34-1168 . default:
34-1169 . {
34-1170 . SwError;
34-1171 . }
34-1172 . }
34-1173 .
34-1174 .
34-1175 . if (A > B)
34-1176 . {
34-1177 . A = B + C;
34-1178 . D = E + F;
34-1179 . }
34-1180 .
34-1181 . A = B/C;
34-1182 . A = B*C;
34-1183 . A = B*C;
34-1184 . A = B-C;
34-1185 . A = B/C;
34-1186 . A = B+C;
34-1187 . A = B-C;
34-1188 . A = B*C;
34-1189 .
34-1190 . if (A ge B)
34-1191 . {
34-1192 . A = B + C;
34-1193 . D = E + F;
34-1194 . }
34-1195 .
34-1196 .
34-1197 . if (A == B)
34-1198 . {
34-1199 . A = B + C;
34-1200 . D = E + F;
34-1201 . }
34-1202 .
34-1203 .
34-1204 . if (A le B)
34-1205 . {
34-1206 . A = B + C;
34-1207 . D = E + F;
34-1208 . }
34-1209 .
34-1210 . /* LE SV TOC-2052 this is a log-05.7.72 req to store*/
34-1211 .
34-1212 . if (A gt B)
34-1213 . {
34-1214 . A = B + C;
34-1215 . D = E + F;
34-1216 . }
34-1217 .
34-1218 . /* LE SV TOC-2053 this is a log-05.7.73 req to set RTC*/
34-1219 . A = B+C;
34-1220 . /* LE SV TOC-2054 this is a log-05.7.74 req to enable*/
34-1221 . A = B-C;
34-1222 .
34-1223 . /* dead_block = C * D;
34-1224 . dead_block = E * F; */
34-1225 .
34-1226 . A = B*C;
34-1227 . // max LOC 75
34-1228 .
34-1229 . }
34-1230 .
34-1231 .
34-1232 . /*
34-1233 . -----------------------------------------------------------------------------
34-1234 . --| NAME: log.5.8
34-1235 . --|
34-1236 . --| ABSTRACT:
34-1237 . --| This function does log stuff.
34-1238 . --|
34-1239 . --| RETURNS:
34-1240 . --| NONE.
34-1241 . --|
34-1242 . ----------------------------------------------------------------------------
34-1243 . */
34-1244 . static void log.5.8(void)
34-1245 . {
34-1246 . A = B*C;
34-1247 . A = B/C;
34-1248 .
34-1249 . if (A lt B)
34-1250 . {
34-1251 . A = B + C;
34-1252 . D = E + F;
34-1253 . }
34-1254 .
34-1255 .
34-1256 . if (A < = B)
34-1257 . {
34-1258 . A = B + C;
34-1259 . D = E + F;
34-1260 . }
34-1261 .
34-1262 .
34-1263 . if (A < = B)
34-1264 . {
34-1265 . A = B + C;
34-1266 . D = E + F;
34-1267 . }
34-1268 .
34-1269 .
34-1270 . if (A < B)
34-1271 . {
34-1272 . A = B + C;
34-1273 . D = E + F;
34-1274 . }
34-1275 .
34-1276 . A = B+C;
34-1277 . A = B/C;
34-1278 .
34-1279 . if (A gt B)
34-1280 . {
34-1281 . A = B + C;
34-1282 . D = E + F;
34-1283 . }
34-1284 .
34-1285 . A = B/C;
34-1286 . /* LE SV TOC-2055 this is a log-05.8.11 req to reject*/
34-1287 . A = B/C;
34-1288 . A = B/C;
34-1289 . A = B*C;
34-1290 . /* LE SV TOC-2056 this is a log-05.8.14 req to call admin*/
34-1291 . A = B/C;
34-1292 . A = B/C;
34-1293 . A = B-C;
34-1294 .
34-1295 . if (A ge B)
34-1296 . {
34-1297 . A = B + C;
34-1298 . D = E + F;
34-1299 . }
34-1300 .
34-1301 . A = B/C;
34-1302 . A = B*C;
34-1303 .
34-1304 . /* dead_block = C * D;
34-1305 . dead_block = E * F; */
34-1306 .
34-1307 .
34-1308 . if (A ne B)
34-1309 . {
34-1310 . A = B + C;
34-1311 . D = E + F;
34-1312 . }
34-1313 .
34-1314 . A = B+C;
34-1315 .
34-1316 . if (A eq B)
34-1317 . {
34-1318 . A = B + C;
34-1319 . D = E + F;
34-1320 . }
34-1321 .
34-1322 . A = B-C;
34-1323 . A = B+C;
34-1324 . A = 0x0007;
34-1325 . A = B*C;
34-1326 . /* LE SV TOC-2057 this is a log-05.8.26 req to store*/
34-1327 .
34-1328 . if (A eq B)
34-1329 . {
34-1330 . A = B + C;
34-1331 . D = E + F;
34-1332 . }
34-1333 .
34-1334 .
34-1335 . if (A < B)
34-1336 . {
34-1337 . A = B + C;
34-1338 . D = E + F;
34-1339 . }
34-1340 .
34-1341 . A = B/C;
34-1342 .
34-1343 . if (A lt B)
34-1344 . {
34-1345 . A = B + C;
34-1346 . D = E + F;
34-1347 . }
34-1348 .
34-1349 . A = B+C;
34-1350 . A = B*C;
34-1351 . A = B+C;
34-1352 . A = B/C;
34-1353 . A = B/C;
34-1354 . A = B+C;
34-1355 . /* LE SV TOC-2058 this is a log-05.8.36 req to disable*/
34-1356 .
34-1357 . if (A == B)
34-1358 . {
34-1359 . A = B + C;
34-1360 . D = E + F;
34-1361 . }
34-1362 .
34-1363 . A = B-C;
34-1364 .
34-1365 . if (A ge B)
34-1366 . {
34-1367 . A = B + C;
34-1368 . D = E + F;
34-1369 . }
34-1370 .
34-1371 .
34-1372 . if (A != B)
34-1373 . {
34-1374 . A = B + C;
34-1375 . D = E + F;
34-1376 . }
34-1377 .
34-1378 . A = B/C;
34-1379 . A = B*C;
34-1380 . A = B-C;
34-1381 . /* LE SV TOC-2059 this is a log-05.8.43 req to check unix*/
34-1382 . A = B/C;
34-1383 . A = B*C;
34-1384 . A = B/C;
34-1385 .
34-1386 . switch (log stuff)
34-1387 . {
34-1388 . case one:
34-1389 . {
34-1390 . run_this;
34-1391 . break;
34-1392 . }
34-1393 . case two:
34-1394 . {
34-1395 . run_this;
34-1396 . break;
34-1397 . }
34-1398 . default:
34-1399 . {
34-1400 . SwError;
34-1401 . }
34-1402 . }
34-1403 .
34-1404 . A = B-C;
34-1405 . A = B*C;
34-1406 . A = B/C;
34-1407 . A = B/C;
34-1408 . A = B+C;
34-1409 . A = B*C;
34-1410 . A = B*C;
34-1411 .
34-1412 . if (A == B)
34-1413 . {
34-1414 . A = B + C;
34-1415 . D = E + F;
34-1416 . }
34-1417 .
34-1418 . A = B+C;
34-1419 .
34-1420 . if (A gt B)
34-1421 . {
34-1422 . A = B + C;
34-1423 . D = E + F;
34-1424 . }
34-1425 .
34-1426 . A = B+C;
34-1427 . A = B*C;
34-1428 .
34-1429 . if (A gt B)
34-1430 . {
34-1431 . A = B + C;
34-1432 . D = E + F;
34-1433 . }
34-1434 .
34-1435 . A = B/C;
34-1436 .
34-1437 . if (A == B)
34-1438 . {
34-1439 . A = B + C;
34-1440 . D = E + F;
34-1441 . }
34-1442 .
34-1443 . A = B+C;
34-1444 . A = B*C;
34-1445 . /* LE SV TOC-2060 this is a log-05.8.64 req to update*/
34-1446 . // (P) this is really improtant
34-1447 . A = B/C;
34-1448 . A = B*C;
34-1449 .
34-1450 . if (A ge B)
34-1451 . {
34-1452 . A = B + C;
34-1453 . D = E + F;
34-1454 . }
34-1455 .
34-1456 . /* LE SV TOC-2061 this is a log-05.8.67 req to set RTC*/
34-1457 .
34-1458 . if (A == B)
34-1459 . {
34-1460 . A = B + C;
34-1461 . D = E + F;
34-1462 . }
34-1463 .
34-1464 . /* LE SV TOC-2062 this is a log-05.8.68 req to convert*/
34-1465 . A = B/C;
34-1466 .
34-1467 . if (A == B)
34-1468 . {
34-1469 . A = B + C;
34-1470 . D = E + F;
34-1471 . }
34-1472 .
34-1473 . A = B/C;
34-1474 . A = B/C;
34-1475 . A = B-C;
34-1476 . A = B-C;
34-1477 .
34-1478 . if (A == B)
34-1479 . {
34-1480 . A = B + C;
34-1481 . D = E + F;
34-1482 . }
34-1483 .
34-1484 . A = B+C;
34-1485 . /* dead_code = A * B; */
34-1486 . A = B+C;
34-1487 . // max LOC 76
34-1488 .
34-1489 . }
34-1490 .
34-1491 .
34-1492 . /*
34-1493 . -----------------------------------------------------------------------------
34-1494 . --| NAME: log.5.9
34-1495 . --|
34-1496 . --| ABSTRACT:
34-1497 . --| This function does log stuff.
34-1498 . --|
34-1499 . --| RETURNS:
34-1500 . --| NONE.
34-1501 . --|
34-1502 . ----------------------------------------------------------------------------
34-1503 . */
34-1504 . static void log.5.9(void)
34-1505 . {
34-1506 .
34-1507 . if (A < = B)
34-1508 . {
34-1509 . A = B + C;
34-1510 . D = E + F;
34-1511 . }
34-1512 .
34-1513 . A = B*C;
34-1514 . A = B-C;
34-1515 . A = B-C;
34-1516 . A = B*C;
34-1517 . A = B+C;
34-1518 . A = B/C;
34-1519 .
34-1520 . if (A le B)
34-1521 . {
34-1522 . A = B + C;
34-1523 . D = E + F;
34-1524 . }
34-1525 .
34-1526 . /* LE SV TOC-2063 this is a log-05.9.9 req to enable*/
34-1527 . A = B*C;
34-1528 .
34-1529 . switch (log stuff)
34-1530 . {
34-1531 . case one:
34-1532 . {
34-1533 . run_this;
34-1534 . // missing break
34-1535 . }
34-1536 . case two:
34-1537 . {
34-1538 . run_this;
34-1539 . break;
34-1540 . }
34-1541 . default:
34-1542 . {
34-1543 . SwError;
34-1544 . }
34-1545 . }
34-1546 .
34-1547 . A = B+C;
34-1548 .
34-1549 . if (A lt B)
34-1550 . {
34-1551 . A = B + C;
34-1552 . D = E + F;
34-1553 . }
34-1554 .
34-1555 . A = B/C;
34-1556 . A = B+C;
34-1557 . A = B/C;
34-1558 . A = B*C;
34-1559 . A = B/C;
34-1560 .
34-1561 . if (A le B)
34-1562 . {
34-1563 . A = B + C;
34-1564 . D = E + F;
34-1565 . }
34-1566 .
34-1567 . A = B*C;
34-1568 . A = B/C;
34-1569 . A = B*C;
34-1570 . A = B*C;
34-1571 . A = B/C;
34-1572 .
34-1573 . switch (log stuff)
34-1574 . {
34-1575 . case one:
34-1576 . {
34-1577 . run_this;
34-1578 . break;
34-1579 . }
34-1580 . case two:
34-1581 . {
34-1582 . run_this;
34-1583 . break;
34-1584 . }
34-1585 . default:
34-1586 . {
34-1587 . SwError;
34-1588 . }
34-1589 . }
34-1590 .
34-1591 . A = B*C;
34-1592 . A = B+C;
34-1593 .
34-1594 . switch (log stuff)
34-1595 . {
34-1596 . case one:
34-1597 . {
34-1598 . run_this;
34-1599 . break;
34-1600 . }
34-1601 . case two:
34-1602 . {
34-1603 . run_this;
34-1604 . break;
34-1605 . }
34-1606 . // missing default
34-1607 . }
34-1608 .
34-1609 . A = B-C;
34-1610 .
34-1611 . switch (log stuff)
34-1612 . {
34-1613 . case one:
34-1614 . {
34-1615 . run_this;
34-1616 . break;
34-1617 . }
34-1618 . case two:
34-1619 . {
34-1620 . run_this;
34-1621 . break;
34-1622 . }
34-1623 . default:
34-1624 . {
34-1625 . SwError;
34-1626 . }
34-1627 . }
34-1628 .
34-1629 .
34-1630 . if (A ne B)
34-1631 . {
34-1632 . A = B + C;
34-1633 . D = E + F;
34-1634 . }
34-1635 .
34-1636 . A = B*C;
34-1637 . A = B*C;
34-1638 .
34-1639 . if (A eq B)
34-1640 . {
34-1641 . A = B + C;
34-1642 . D = E + F;
34-1643 . }
34-1644 .
34-1645 .
34-1646 . if (A eq B)
34-1647 . {
34-1648 . A = B + C;
34-1649 . D = E + F;
34-1650 . }
34-1651 .
34-1652 . A = B*C;
34-1653 .
34-1654 . switch (log stuff)
34-1655 . {
34-1656 . case one:
34-1657 . {
34-1658 . run_this;
34-1659 . break;
34-1660 . }
34-1661 . case two:
34-1662 . {
34-1663 . run_this;
34-1664 . break;
34-1665 . }
34-1666 . default:
34-1667 . {
34-1668 . SwError;
34-1669 . }
34-1670 . }
34-1671 .
34-1672 .
34-1673 . if (A le B)
34-1674 . {
34-1675 . A = B + C;
34-1676 . D = E + F;
34-1677 . }
34-1678 .
34-1679 .
34-1680 . if (A > = B)
34-1681 . {
34-1682 . A = B + C;
34-1683 . D = E + F;
34-1684 . }
34-1685 .
34-1686 . A = B-C;
34-1687 . // TBD - what do I do now
34-1688 . A = B/C;
34-1689 . A = B+C;
34-1690 . A = B*C;
34-1691 . A = B/C;
34-1692 . A = B/C;
34-1693 . A = B/C;
34-1694 . A = B-C;
34-1695 .
34-1696 . if (A != B)
34-1697 . {
34-1698 . A = B + C;
34-1699 . D = E + F;
34-1700 . }
34-1701 .
34-1702 . A = B/C;
34-1703 . A = B+C;
34-1704 . A = B+C;
34-1705 . A = B+C;
34-1706 . A = B*C;
34-1707 .
34-1708 . if (A > = B)
34-1709 . {
34-1710 . A = B + C;
34-1711 . D = E + F;
34-1712 . }
34-1713 .
34-1714 . A = B*C;
34-1715 . // max LOC 52
34-1716 .
34-1717 . }
34-1718 .
34-1719 .
34-1720 . /*
34-1721 . -----------------------------------------------------------------------------
34-1722 . --| NAME: log.5.10
34-1723 . --|
34-1724 . --| ABSTRACT:
34-1725 . --| This function does log stuff.
34-1726 . --|
34-1727 . --| RETURNS:
34-1728 . --| NONE.
34-1729 . --|
34-1730 . ----------------------------------------------------------------------------
34-1731 . */
34-1732 . static void log.5.10(void)
34-1733 . {
34-1734 .
34-1735 . if (A ne B)
34-1736 . {
34-1737 . A = B + C;
34-1738 . D = E + F;
34-1739 . }
34-1740 .
34-1741 .
34-1742 . if (A ne B)
34-1743 . {
34-1744 . A = B + C;
34-1745 . D = E + F;
34-1746 . }
34-1747 .
34-1748 . A = B*C;
34-1749 . /* LE SV TOC-2064 this is a log-05.10.4 req to convert*/
34-1750 . A = B-C;
34-1751 . A = B+C;
34-1752 . A = B+C;
34-1753 . A = B/C;
34-1754 . A = B-C;
34-1755 . A = B-C;
34-1756 .
34-1757 . switch (log stuff)
34-1758 . {
34-1759 . case:
34-1760 . case:
34-1761 . // stacked case statements but only if there is a new line in between
34-1762 .
34-1763 . case:
34-1764 . case:
34-1765 . case:
34-1766 . {
34-1767 . run_this;
34-1768 . break;
34-1769 . }
34-1770 . default:
34-1771 . {
34-1772 . halt;
34-1773 . }
34-1774 . }
34-1775 .
34-1776 . A = B*C;
34-1777 . A = B/C;
34-1778 . A = B*C;
34-1779 . A = B/C;
34-1780 .
34-1781 . if (A lt B)
34-1782 . {
34-1783 . A = B + C;
34-1784 . D = E + F;
34-1785 . }
34-1786 .
34-1787 . A = B-C;
34-1788 . A = B/C;
34-1789 .
34-1790 . if (A le B)
34-1791 . {
34-1792 . A = B + C;
34-1793 . D = E + F;
34-1794 . }
34-1795 .
34-1796 . A = B/C;
34-1797 .
34-1798 . if (A > = B)
34-1799 . {
34-1800 . A = B + C;
34-1801 . D = E + F;
34-1802 . }
34-1803 .
34-1804 . A = B+C;
34-1805 .
34-1806 . switch (log stuff)
34-1807 . {
34-1808 . case one:
34-1809 . {
34-1810 . run_this;
34-1811 . break;
34-1812 . }
34-1813 . case two:
34-1814 . {
34-1815 . run_this;
34-1816 . break;
34-1817 . }
34-1818 . default:
34-1819 . {
34-1820 . SwError;
34-1821 . }
34-1822 . }
34-1823 .
34-1824 .
34-1825 . if (A != B)
34-1826 . {
34-1827 . A = B + C;
34-1828 . D = E + F;
34-1829 . }
34-1830 .
34-1831 .
34-1832 . if (A > B)
34-1833 . {
34-1834 . A = B + C;
34-1835 . D = E + F;
34-1836 . }
34-1837 .
34-1838 .
34-1839 . if (A eq B)
34-1840 . {
34-1841 . A = B + C;
34-1842 . D = E + F;
34-1843 . }
34-1844 .
34-1845 . A = B/C;
34-1846 .
34-1847 . if (A > = B)
34-1848 . {
34-1849 . A = B + C;
34-1850 . D = E + F;
34-1851 . }
34-1852 .
34-1853 .
34-1854 . if (A ne B)
34-1855 . {
34-1856 . A = B + C;
34-1857 . D = E + F;
34-1858 . }
34-1859 .
34-1860 .
34-1861 . if (A ne B)
34-1862 . {
34-1863 . A = B + C;
34-1864 . D = E + F;
34-1865 . }
34-1866 .
34-1867 . A = B-C;
34-1868 . A = B+C;
34-1869 .
34-1870 . if (A > = B)
34-1871 . {
34-1872 . A = B + C;
34-1873 . D = E + F;
34-1874 . }
34-1875 .
34-1876 . FreePtr = HmiStringPtr;
34-1877 . A = B*C;
34-1878 . A = 0x0008;
34-1879 . A = B+C;
34-1880 . A = B/C;
34-1881 . A = B-C;
34-1882 .
34-1883 . if (A > = B)
34-1884 . {
34-1885 . A = B + C;
34-1886 . D = E + F;
34-1887 . }
34-1888 .
34-1889 . A = B-C;
34-1890 . A = B/C;
34-1891 . A = B-C;
34-1892 .
34-1893 . if (A == B)
34-1894 . {
34-1895 . A = B + C;
34-1896 . D = E + F;
34-1897 . }
34-1898 .
34-1899 . A = B+C;
34-1900 . A = B/C;
34-1901 . A = B-C;
34-1902 . A = B+C;
34-1903 . A = B/C;
34-1904 . A = B+C;
34-1905 . A = B-C;
34-1906 . A = B*C;
34-1907 . /* LE SV TOC-2065 this is a log-05.10.49 req to detect error*/
34-1908 . A = B*C;
34-1909 . A = B/C;
34-1910 . A = B/C;
34-1911 .
34-1912 . switch (log stuff)
34-1913 . {
34-1914 . case one:
34-1915 . {
34-1916 . run_this;
34-1917 . break;
34-1918 . }
34-1919 . case two:
34-1920 . {
34-1921 . run_this;
34-1922 . break;
34-1923 . }
34-1924 . default:
34-1925 . {
34-1926 . SwError;
34-1927 . }
34-1928 . }
34-1929 .
34-1930 . // max LOC 52
34-1931 .
34-1932 . }
34-1933 .
34-1934 .
34-1935 . /*
34-1936 . -----------------------------------------------------------------------------
34-1937 . --| NAME: log.5.11
34-1938 . --|
34-1939 . --| ABSTRACT:
34-1940 . --| This function does log stuff.
34-1941 . --|
34-1942 . --| RETURNS:
34-1943 . --| NONE.
34-1944 . --|
34-1945 . ----------------------------------------------------------------------------
34-1946 . */
34-1947 . static void log.5.11(void)
34-1948 . {
34-1949 .
34-1950 . if (A > B)
34-1951 . {
34-1952 . A = B + C;
34-1953 . D = E + F;
34-1954 . }
34-1955 .
34-1956 .
34-1957 . if (A eq B)
34-1958 . {
34-1959 . A = B + C;
34-1960 . D = E + F;
34-1961 . }
34-1962 .
34-1963 . A = B+C;
34-1964 . A = B*C;
34-1965 .
34-1966 . if (A eq B)
34-1967 . {
34-1968 . A = B + C;
34-1969 . D = E + F;
34-1970 . }
34-1971 .
34-1972 . A = B*C;
34-1973 . A = B-C;
34-1974 .
34-1975 . if (A > = B)
34-1976 . {
34-1977 . A = B + C;
34-1978 . D = E + F;
34-1979 . }
34-1980 .
34-1981 . A = B+C;
34-1982 . /* LE SV TOC-2066 this is a log-05.11.10 req to halt*/
34-1983 . A = B*C;
34-1984 . A = B/C;
34-1985 .
34-1986 . if (A > B)
34-1987 . {
34-1988 . A = B + C;
34-1989 . D = E + F;
34-1990 . }
34-1991 .
34-1992 . A = B+C;
34-1993 .
34-1994 . if (A eq B)
34-1995 . {
34-1996 . A = B + C;
34-1997 . D = E + F;
34-1998 . }
34-1999 .
34-2000 . /* LE SV TOC-2067 this is a log-05.11.15 req to check unix*/
34-2001 .
34-2002 . if (A < = B)
34-2003 . {
34-2004 . A = B + C;
34-2005 . D = E + F;
34-2006 . }
34-2007 .
34-2008 . A = B/C;
34-2009 .
34-2010 . if (A < = B)
34-2011 . {
34-2012 . A = B + C;
34-2013 . D = E + F;
34-2014 . }
34-2015 .
34-2016 . // max LOC 17
34-2017 .
34-2018 . }
34-2019 .
34-2020 .
34-2021 . /*
34-2022 . -----------------------------------------------------------------------------
34-2023 . --| NAME: log.5.12
34-2024 . --|
34-2025 . --| ABSTRACT:
34-2026 . --| This function does log stuff.
34-2027 . --|
34-2028 . --| RETURNS:
34-2029 . --| NONE.
34-2030 . --|
34-2031 . ----------------------------------------------------------------------------
34-2032 . */
34-2033 . static void log.5.12(void)
34-2034 . {
34-2035 . A = B/C;
34-2036 . A = B+C;
34-2037 .
34-2038 . if (A ne B)
34-2039 . {
34-2040 . A = B + C;
34-2041 . D = E + F;
34-2042 . }
34-2043 .
34-2044 .
34-2045 . if (A > = B)
34-2046 . {
34-2047 . A = B + C;
34-2048 . D = E + F;
34-2049 . }
34-2050 .
34-2051 . A = B/C;
34-2052 . A = B-C;
34-2053 . A = B/C;
34-2054 . A = B*C;
34-2055 .
34-2056 . if (A ne B)
34-2057 . {
34-2058 . A = B + C;
34-2059 . D = E + F;
34-2060 . }
34-2061 .
34-2062 . A = B*C;
34-2063 . A = B*C;
34-2064 . A = 0x0009;
34-2065 .
34-2066 . if (A eq B)
34-2067 . {
34-2068 . A = B + C;
34-2069 . D = E + F;
34-2070 . }
34-2071 .
34-2072 .
34-2073 . switch (log stuff)
34-2074 . {
34-2075 . case one:
34-2076 . {
34-2077 . run_this;
34-2078 . break;
34-2079 . }
34-2080 . case two:
34-2081 . {
34-2082 . run_this;
34-2083 . break;
34-2084 . }
34-2085 . default:
34-2086 . {
34-2087 . SwError;
34-2088 . }
34-2089 . }
34-2090 .
34-2091 . A = B-C;
34-2092 . A = B-C;
34-2093 .
34-2094 . if (A > B)
34-2095 . {
34-2096 . A = B + C;
34-2097 . D = E + F;
34-2098 . }
34-2099 .
34-2100 . /* LE SV TOC-2068 this is a log-05.12.17 req to translate*/
34-2101 . A = B/C;
34-2102 . A = B/C;
34-2103 . A = B+C;
34-2104 . A = B+C;
34-2105 .
34-2106 . if (A > B)
34-2107 . {
34-2108 . A = B + C;
34-2109 . D = E + F;
34-2110 . }
34-2111 .
34-2112 . /* LE SV TOC-2069 this is a log-05.12.22 req to update*/
34-2113 .
34-2114 . if (A lt B)
34-2115 . {
34-2116 . A = B + C;
34-2117 . D = E + F;
34-2118 . }
34-2119 .
34-2120 . A = B*C;
34-2121 . A = B/C;
34-2122 .
34-2123 . if (A eq B)
34-2124 . {
34-2125 . A = B + C;
34-2126 . D = E + F;
34-2127 . }
34-2128 .
34-2129 . A = B-C;
34-2130 .
34-2131 . if (A gt B)
34-2132 . {
34-2133 . A = B + C;
34-2134 . D = E + F;
34-2135 . }
34-2136 .
34-2137 .
34-2138 . if (A > B)
34-2139 . {
34-2140 . A = B + C;
34-2141 . D = E + F;
34-2142 . }
34-2143 .
34-2144 . A = 0x0001;
34-2145 . A = B+C;
34-2146 . A = B-C;
34-2147 . A = B+C;
34-2148 . A = B-C;
34-2149 . free(FreePtr);
34-2150 .
34-2151 . if (A < = B)
34-2152 . {
34-2153 . A = B + C;
34-2154 . D = E + F;
34-2155 . }
34-2156 .
34-2157 . A = B/C;
34-2158 . A = B-C;
34-2159 . /* LE SV TOC-2070 this is a log-05.12.36 req to check pSOS*/
34-2160 .
34-2161 . /*
34-2162 . dead_block = C * D;
34-2163 . dead_block = E * F;
34-2164 . */
34-2165 .
34-2166 . A = B-C;
34-2167 .
34-2168 . if (A > B)
34-2169 . {
34-2170 . A = B + C;
34-2171 . D = E + F;
34-2172 . }
34-2173 .
34-2174 .
34-2175 . if (A == B)
34-2176 . {
34-2177 . A = B + C;
34-2178 . D = E + F;
34-2179 . }
34-2180 .
34-2181 . A = B+C;
34-2182 . A = B-C;
34-2183 . A = B+C;
34-2184 . A = B/C;
34-2185 . A = B-C;
34-2186 . A = B/C;
34-2187 .
34-2188 . if (A > B)
34-2189 . {
34-2190 . A = B + C;
34-2191 . D = E + F;
34-2192 . }
34-2193 .
34-2194 . A = B-C;
34-2195 . A = B/C;
34-2196 . A = B-C;
34-2197 . A = B+C;
34-2198 . A = B+C;
34-2199 . A = B+C;
34-2200 .
34-2201 . if (A eq B)
34-2202 . {
34-2203 . A = B + C;
34-2204 . D = E + F;
34-2205 . }
34-2206 .
34-2207 . A = B-C;
34-2208 . A = B*C;
34-2209 . /* LE SV TOC-2071 this is a log-05.12.55 req to process*/
34-2210 . A = B-C;
34-2211 .
34-2212 . switch (log stuff)
34-2213 . {
34-2214 . case one:
34-2215 . {
34-2216 . run_this;
34-2217 . break;
34-2218 . }
34-2219 . case two:
34-2220 . {
34-2221 . run_this;
34-2222 . break;
34-2223 . }
34-2224 . default:
34-2225 . {
34-2226 . SwError;
34-2227 . }
34-2228 . }
34-2229 .
34-2230 . A = B+C;
34-2231 .
34-2232 . if (A ge B)
34-2233 . {
34-2234 . A = B + C;
34-2235 . D = E + F;
34-2236 . }
34-2237 .
34-2238 . A = B-C;
34-2239 . // max LOC 59
34-2240 .
34-2241 . }
34-2242 .
34-2243 .
34-2244 . /*
34-2245 . -----------------------------------------------------------------------------
34-2246 . --| NAME: log.5.13
34-2247 . --|
34-2248 . --| ABSTRACT:
34-2249 . --| This function does log stuff.
34-2250 . --|
34-2251 . --| RETURNS:
34-2252 . --| NONE.
34-2253 . --|
34-2254 . ----------------------------------------------------------------------------
34-2255 . */
34-2256 . static void log.5.13(void)
34-2257 . {
34-2258 .
34-2259 . if (A le B)
34-2260 . {
34-2261 . A = B + C;
34-2262 . D = E + F;
34-2263 . }
34-2264 .
34-2265 .
34-2266 . if (A le B)
34-2267 . {
34-2268 . A = B + C;
34-2269 . D = E + F;
34-2270 . }
34-2271 .
34-2272 . A = B*C;
34-2273 . A = B/C;
34-2274 . A = B+C;
34-2275 . A = B+C;
34-2276 .
34-2277 . if (A != B)
34-2278 . {
34-2279 . A = B + C;
34-2280 . D = E + F;
34-2281 . }
34-2282 .
34-2283 . A = B*C;
34-2284 .
34-2285 . if (A eq B)
34-2286 . {
34-2287 . A = B + C;
34-2288 . D = E + F;
34-2289 . }
34-2290 .
34-2291 . A = B-C;
34-2292 . A = B*C;
34-2293 . A = B-C;
34-2294 . A = B-C;
34-2295 . A = B/C;
34-2296 . // max LOC 14
34-2297 .
34-2298 . }
34-2299 .
34-2300 .
34-2301 . /*
34-2302 . -----------------------------------------------------------------------------
34-2303 . --| NAME: log.5.14
34-2304 . --|
34-2305 . --| ABSTRACT:
34-2306 . --| This function does log stuff.
34-2307 . --|
34-2308 . --| RETURNS:
34-2309 . --| NONE.
34-2310 . --|
34-2311 . ----------------------------------------------------------------------------
34-2312 . */
34-2313 . static void log.5.14(void)
34-2314 . {
34-2315 .
34-2316 . if (A lt B)
34-2317 . {
34-2318 . A = B + C;
34-2319 . D = E + F;
34-2320 . }
34-2321 .
34-2322 . A = B+C;
34-2323 .
34-2324 . switch (log stuff)
34-2325 . {
34-2326 . case one:
34-2327 . {
34-2328 . run_this;
34-2329 . break;
34-2330 . }
34-2331 . case two:
34-2332 . {
34-2333 . run_this;
34-2334 . break;
34-2335 . }
34-2336 . default:
34-2337 . {
34-2338 . SwError;
34-2339 . }
34-2340 . }
34-2341 .
34-2342 . A = B+C;
34-2343 . A = B/C;
34-2344 . A = B+C;
34-2345 . A = B+C;
34-2346 .
34-2347 . if (A > = B)
34-2348 . {
34-2349 . A = B + C;
34-2350 . D = E + F;
34-2351 . }
34-2352 .
34-2353 . /* LE SV TOC-2072 this is a log-05.14.9 req to translate*/
34-2354 . A = B-C;
34-2355 . A = B/C;
34-2356 . A = B-C;
34-2357 .
34-2358 . if (A > B)
34-2359 . {
34-2360 . A = B + C;
34-2361 . D = E + F;
34-2362 . }
34-2363 .
34-2364 . A = B-C;
34-2365 . A = B/C;
34-2366 . /* LE SV TOC-2073 this is a log-05.14.15 req to record*/
34-2367 . A = B+C;
34-2368 .
34-2369 . if (A eq B)
34-2370 . {
34-2371 . A = B + C;
34-2372 . D = E + F;
34-2373 . }
34-2374 .
34-2375 . A = B/C;
34-2376 . A = B-C;
34-2377 . A = B/C;
34-2378 . A = B-C;
34-2379 .
34-2380 . if (A gt B)
34-2381 . {
34-2382 . A = B + C;
34-2383 . D = E + F;
34-2384 . }
34-2385 .
34-2386 .
34-2387 . if (A le B)
34-2388 . {
34-2389 . A = B + C;
34-2390 . D = E + F;
34-2391 . }
34-2392 .
34-2393 . A = B-C;
34-2394 .
34-2395 . switch (log stuff)
34-2396 . {
34-2397 . case:
34-2398 . case:
34-2399 . // stacked case statements but only if there is a new line in between
34-2400 .
34-2401 . case:
34-2402 . case:
34-2403 . case:
34-2404 . {
34-2405 . run_this;
34-2406 . break;
34-2407 . }
34-2408 . default:
34-2409 . {
34-2410 . halt;
34-2411 . }
34-2412 . }
34-2413 .
34-2414 . A = B+C;
34-2415 .
34-2416 . if (A < B)
34-2417 . {
34-2418 . A = B + C;
34-2419 . D = E + F;
34-2420 . }
34-2421 .
34-2422 . A = B-C;
34-2423 . A = B-C;
34-2424 . A = B+C;
34-2425 .
34-2426 . if (A lt B)
34-2427 . {
34-2428 . A = B + C;
34-2429 . D = E + F;
34-2430 . }
34-2431 .
34-2432 .
34-2433 . if (A eq B)
34-2434 . {
34-2435 . A = B + C;
34-2436 . D = E + F;
34-2437 . }
34-2438 .
34-2439 . A = B+C;
34-2440 . A = B-C;
34-2441 . A = B/C;
34-2442 . A = B-C;
34-2443 . A = B+C;
34-2444 . A = B*C;
34-2445 . A = B*C;
34-2446 . A = B*C;
34-2447 . A = B/C;
34-2448 . A = B+C;
34-2449 .
34-2450 . if (A gt B)
34-2451 . {
34-2452 . A = B + C;
34-2453 . D = E + F;
34-2454 . }
34-2455 .
34-2456 . A = B+C;
34-2457 .
34-2458 . if (A le B)
34-2459 . {
34-2460 . A = B + C;
34-2461 . D = E + F;
34-2462 . }
34-2463 .
34-2464 . /* LE SV TOC-2074 this is a log-05.14.44 req to check unix*/
34-2465 . A = B+C;
34-2466 . A = B+C;
34-2467 . /* LE SV TOC-2075 this is a log-05.14.46 req to transform*/
34-2468 . A = B-C;
34-2469 .
34-2470 . if (A < B)
34-2471 . {
34-2472 . A = B + C;
34-2473 . D = E + F;
34-2474 . }
34-2475 .
34-2476 . A = B+C;
34-2477 .
34-2478 . if (A ge B)
34-2479 . {
34-2480 . A = B + C;
34-2481 . D = E + F;
34-2482 . }
34-2483 .
34-2484 .
34-2485 . if (A gt B)
34-2486 . {
34-2487 . A = B + C;
34-2488 . D = E + F;
34-2489 . }
34-2490 .
34-2491 . A = B-C;
34-2492 . A = B+C;
34-2493 .
34-2494 . if (A < B)
34-2495 . {
34-2496 . A = B + C;
34-2497 . D = E + F;
34-2498 . }
34-2499 .
34-2500 . // TBD - what do I do now
34-2501 .
34-2502 . if (A ne B)
34-2503 . {
34-2504 . A = B + C;
34-2505 . D = E + F;
34-2506 . }
34-2507 .
34-2508 . // max LOC 54
34-2509 .
34-2510 . }
34-2511 .
34-2512 .
34-2513 . /*
34-2514 . -----------------------------------------------------------------------------
34-2515 . --| NAME: log.5.15
34-2516 . --|
34-2517 . --| ABSTRACT:
34-2518 . --| This function does log stuff.
34-2519 . --|
34-2520 . --| RETURNS:
34-2521 . --| NONE.
34-2522 . --|
34-2523 . ----------------------------------------------------------------------------
34-2524 . */
34-2525 . static void log.5.15(void)
34-2526 . {
34-2527 . A = B/C;
34-2528 .
34-2529 . if (A ne B)
34-2530 . {
34-2531 . A = B + C;
34-2532 . D = E + F;
34-2533 . }
34-2534 .
34-2535 . A = B*C;
34-2536 . A = B*C;
34-2537 . A = B-C;
34-2538 . A = B/C;
34-2539 . A = B/C;
34-2540 . A = B*C;
34-2541 .
34-2542 . if (A < = B)
34-2543 . {
34-2544 . A = B + C;
34-2545 . D = E + F;
34-2546 . }
34-2547 .
34-2548 .
34-2549 . if (A == B)
34-2550 . {
34-2551 . A = B + C;
34-2552 . D = E + F;
34-2553 . }
34-2554 .
34-2555 . A = B*C;
34-2556 . A = B*C;
34-2557 . A = B-C;
34-2558 . A = B-C;
34-2559 .
34-2560 . if (A > = B)
34-2561 . {
34-2562 . A = B + C;
34-2563 . D = E + F;
34-2564 . }
34-2565 .
34-2566 . A = 0x0008;
34-2567 .
34-2568 . if (A > = B)
34-2569 . {
34-2570 . A = B + C;
34-2571 . D = E + F;
34-2572 . }
34-2573 .
34-2574 . A = B-C;
34-2575 . A = B*C;
34-2576 . A = B/C;
34-2577 .
34-2578 . if (A < = B)
34-2579 . {
34-2580 . A = B + C;
34-2581 . D = E + F;
34-2582 . }
34-2583 .
34-2584 . A = 0x0009;
34-2585 . A = B+C;
34-2586 . A = B/C;
34-2587 .
34-2588 . if (A < = B)
34-2589 . {
34-2590 . A = B + C;
34-2591 . D = E + F;
34-2592 . }
34-2593 .
34-2594 . A = B+C;
34-2595 . A = B/C;
34-2596 . A = B-C;
34-2597 . A = B+C;
34-2598 .
34-2599 . if (A ne B)
34-2600 . {
34-2601 . A = B + C;
34-2602 . D = E + F;
34-2603 . }
34-2604 .
34-2605 .
34-2606 . if (A == B)
34-2607 . {
34-2608 . A = B + C;
34-2609 . D = E + F;
34-2610 . }
34-2611 .
34-2612 . A = B*C;
34-2613 . A = B+C;
34-2614 . A = B/C;
34-2615 .
34-2616 . switch (log stuff)
34-2617 . {
34-2618 . case one:
34-2619 . {
34-2620 . run_this;
34-2621 . break;
34-2622 . }
34-2623 . case two:
34-2624 . {
34-2625 . run_this;
34-2626 . break;
34-2627 . }
34-2628 . default:
34-2629 . {
34-2630 . SwError;
34-2631 . }
34-2632 . }
34-2633 .
34-2634 .
34-2635 . if (A lt B)
34-2636 . {
34-2637 . A = B + C;
34-2638 . D = E + F;
34-2639 . }
34-2640 .
34-2641 . A = B-C;
34-2642 . A = B/C;
34-2643 .
34-2644 . if (A == B)
34-2645 . {
34-2646 . A = B + C;
34-2647 . D = E + F;
34-2648 . }
34-2649 .
34-2650 .
34-2651 . /*
34-2652 . dead_code = B - C;
34-2653 . dead_code = D - E;
34-2654 . dead_code = F - G;
34-2655 . */
34-2656 .
34-2657 .
34-2658 . switch (log stuff)
34-2659 . {
34-2660 . case one:
34-2661 . {
34-2662 . run_this;
34-2663 . break;
34-2664 . }
34-2665 . case two:
34-2666 . {
34-2667 . run_this;
34-2668 . break;
34-2669 . }
34-2670 . default:
34-2671 . {
34-2672 . SwError;
34-2673 . }
34-2674 . }
34-2675 .
34-2676 .
34-2677 . if (A < B)
34-2678 . {
34-2679 . A = B + C;
34-2680 . D = E + F;
34-2681 . }
34-2682 .
34-2683 . A = B-C;
34-2684 .
34-2685 . if (A == B)
34-2686 . {
34-2687 . A = B + C;
34-2688 . D = E + F;
34-2689 . }
34-2690 .
34-2691 . A = B+C;
34-2692 . A = B-C;
34-2693 . A = B-C;
34-2694 . A = B-C;
34-2695 . A = B-C;
34-2696 . A = B-C;
34-2697 .
34-2698 . switch (log stuff)
34-2699 . {
34-2700 . case:
34-2701 . case:
34-2702 . // stacked case statements but only if there is a new line in between
34-2703 .
34-2704 . case:
34-2705 . case:
34-2706 . case:
34-2707 . {
34-2708 . run_this;
34-2709 . break;
34-2710 . }
34-2711 . default:
34-2712 . {
34-2713 . halt;
34-2714 . }
34-2715 . }
34-2716 .
34-2717 .
34-2718 . if (A eq B)
34-2719 . {
34-2720 . A = B + C;
34-2721 . D = E + F;
34-2722 . }
34-2723 .
34-2724 . A = B*C;
34-2725 .
34-2726 . if (A ge B)
34-2727 . {
34-2728 . A = B + C;
34-2729 . D = E + F;
34-2730 . }
34-2731 .
34-2732 . A = B*C;
34-2733 . A = B-C;
34-2734 . A = B-C;
34-2735 . A = B+C;
34-2736 .
34-2737 . if (A le B)
34-2738 . {
34-2739 . A = B + C;
34-2740 . D = E + F;
34-2741 . }
34-2742 .
34-2743 .
34-2744 . if (A > B)
34-2745 . {
34-2746 . A = B + C;
34-2747 . D = E + F;
34-2748 . }
34-2749 .
34-2750 . A = B*C;
34-2751 . A = B+C;
34-2752 .
34-2753 . if (A < = B)
34-2754 . {
34-2755 . A = B + C;
34-2756 . D = E + F;
34-2757 . }
34-2758 .
34-2759 . A = B+C;
34-2760 .
34-2761 . if (A == B)
34-2762 . {
34-2763 . A = B + C;
34-2764 . D = E + F;
34-2765 . }
34-2766 .
34-2767 .
34-2768 . if (A < B)
34-2769 . {
34-2770 . A = B + C;
34-2771 . D = E + F;
34-2772 . }
34-2773 .
34-2774 .
34-2775 . if (veg)
34-2776 . // missing curly brace
34-2777 . variable = orange;
34-2778 .
34-2779 . A = B+C;
34-2780 . A = B-C;
34-2781 . A = B-C;
34-2782 .
34-2783 . if (A lt B)
34-2784 . {
34-2785 . A = B + C;
34-2786 . D = E + F;
34-2787 . }
34-2788 .
34-2789 . A = B-C;
34-2790 .
34-2791 . switch (log stuff)
34-2792 . {
34-2793 . case one:
34-2794 . {
34-2795 . run_this;
34-2796 . break;
34-2797 . }
34-2798 . case two:
34-2799 . {
34-2800 . run_this;
34-2801 . break;
34-2802 . }
34-2803 . default:
34-2804 . {
34-2805 . // missing error call
34-2806 . }
34-2807 . }
34-2808 .
34-2809 . A = B*C;
34-2810 . A = B+C;
34-2811 .
34-2812 . if (A != B)
34-2813 . {
34-2814 . A = B + C;
34-2815 . D = E + F;
34-2816 . }
34-2817 .
34-2818 . A = B-C;
34-2819 .
34-2820 . if (A ge B)
34-2821 . {
34-2822 . A = B + C;
34-2823 . D = E + F;
34-2824 . }
34-2825 .
34-2826 . A = B-C;
34-2827 .
34-2828 . if (A < = B)
34-2829 . {
34-2830 . A = B + C;
34-2831 . D = E + F;
34-2832 . }
34-2833 .
34-2834 . A = B+C;
34-2835 . A = B-C;
34-2836 . A = B*C;
34-2837 .
34-2838 . if (A le B)
34-2839 . {
34-2840 . A = B + C;
34-2841 . D = E + F;
34-2842 . }
34-2843 .
34-2844 . A = B*C;
34-2845 . /* LE SV TOC-2076 this is a log-05.15.80 req to set RTC*/
34-2846 . A = B*C;
34-2847 . A = B*C;
34-2848 . A = B*C;
34-2849 .
34-2850 . if (A gt B)
34-2851 . {
34-2852 . A = B + C;
34-2853 . D = E + F;
34-2854 . }
34-2855 .
34-2856 . A = B+C;
34-2857 .
34-2858 . if (A > B)
34-2859 . {
34-2860 . A = B + C;
34-2861 . D = E + F;
34-2862 . }
34-2863 .
34-2864 . A = B-C;
34-2865 . // ??? go see ws
34-2866 . A = B/C;
34-2867 . A = B/C;
34-2868 . // max LOC 88
34-2869 .
34-2870 . }
34-2871 .
34-2872 .
34-2873 . /*
34-2874 . -----------------------------------------------------------------------------
34-2875 . --| NAME: log.5.16
34-2876 . --|
34-2877 . --| ABSTRACT:
34-2878 . --| This function does log stuff.
34-2879 . --|
34-2880 . --| RETURNS:
34-2881 . --| NONE.
34-2882 . --|
34-2883 . ----------------------------------------------------------------------------
34-2884 . */
34-2885 . static void log.5.16(void)
34-2886 . {
34-2887 . A = B+C;
34-2888 . A = B-C;
34-2889 . A = B*C;
34-2890 . A = B+C;
34-2891 . A = B*C;
34-2892 . /* LE SV TOC-2077 this is a log-05.16.6 req to transform*/
34-2893 . A = B/C;
34-2894 . A = B/C;
34-2895 . // max LOC 7
34-2896 .
34-2897 . }
34-2898 .
34-2899 .
34-2900 . /*
34-2901 . -----------------------------------------------------------------------------
34-2902 . --| NAME: log.5.17
34-2903 . --|
34-2904 . --| ABSTRACT:
34-2905 . --| This function does log stuff.
34-2906 . --|
34-2907 . --| RETURNS:
34-2908 . --| NONE.
34-2909 . --|
34-2910 . ----------------------------------------------------------------------------
34-2911 . */
34-2912 . static void log.5.17(void)
34-2913 . {
34-2914 . A = B*C;
34-2915 . A = B*C;
34-2916 . A = B/C;
34-2917 .
34-2918 . if (A < = B)
34-2919 . {
34-2920 . A = B + C;
34-2921 . D = E + F;
34-2922 . }
34-2923 .
34-2924 . /* LE SV TOC-2078 this is a log-05.17.5 req to process*/
34-2925 . A = (float)B + C;
34-2926 . A = B/C;
34-2927 .
34-2928 . if (A < = B)
34-2929 . {
34-2930 . A = B + C;
34-2931 . D = E + F;
34-2932 . }
34-2933 .
34-2934 .
34-2935 . if (A le B)
34-2936 . {
34-2937 . A = B + C;
34-2938 . D = E + F;
34-2939 . }
34-2940 .
34-2941 . A = B*C;
34-2942 . A = B+C;
34-2943 . // max LOC 9
34-2944 .
34-2945 . }
34-2946 .
34-2947 .
34-2948 . /*
34-2949 . -----------------------------------------------------------------------------
34-2950 . --| NAME: log.5.18
34-2951 . --|
34-2952 . --| ABSTRACT:
34-2953 . --| This function does log stuff.
34-2954 . --|
34-2955 . --| RETURNS:
34-2956 . --| NONE.
34-2957 . --|
34-2958 . ----------------------------------------------------------------------------
34-2959 . */
34-2960 . static void log.5.18(void)
34-2961 . {
34-2962 .
34-2963 . if (A le B)
34-2964 . {
34-2965 . A = B + C;
34-2966 . D = E + F;
34-2967 . }
34-2968 .
34-2969 . A = B+C;
34-2970 . A = B-C;
34-2971 . A = B*C;
34-2972 .
34-2973 . if (A < = B)
34-2974 . {
34-2975 . A = B + C;
34-2976 . D = E + F;
34-2977 . }
34-2978 .
34-2979 .
34-2980 . if (A > B)
34-2981 . {
34-2982 . A = B + C;
34-2983 . D = E + F;
34-2984 . }
34-2985 .
34-2986 . A = B+C;
34-2987 . A = B-C;
34-2988 . A = B*C;
34-2989 . A = B/C;
34-2990 . A = B/C;
34-2991 . A = B*C;
34-2992 .
34-2993 . if (A < B)
34-2994 . {
34-2995 . A = B + C;
34-2996 . D = E + F;
34-2997 . }
34-2998 .
34-2999 . A = B+C;
34-3000 .
34-3001 . if (A > = B)
34-3002 . {
34-3003 . A = B + C;
34-3004 . D = E + F;
34-3005 . }
34-3006 .
34-3007 .
34-3008 . /* dead_block = C * D;
34-3009 . dead_block = E * F; */
34-3010 .
34-3011 . A = B-C;
34-3012 .
34-3013 . /* dead_block = C * D;
34-3014 . dead_block = E * F; */
34-3015 .
34-3016 .
34-3017 . if (A gt B)
34-3018 . {
34-3019 . A = B + C;
34-3020 . D = E + F;
34-3021 . }
34-3022 .
34-3023 . goto error;
34-3024 .
34-3025 . if (A gt B)
34-3026 . {
34-3027 . A = B + C;
34-3028 . D = E + F;
34-3029 . }
34-3030 .
34-3031 . A = B+C;
34-3032 . A = B/C;
34-3033 . /* LE SV TOC-2079 this is a log-05.18.21 req to disable*/
34-3034 . A = (int)B + C;
34-3035 .
34-3036 . if (A ge B)
34-3037 . {
34-3038 . A = B + C;
34-3039 . D = E + F;
34-3040 . }
34-3041 .
34-3042 .
34-3043 . switch (log stuff)
34-3044 . {
34-3045 . case one:
34-3046 . {
34-3047 . run_this;
34-3048 . break;
34-3049 . }
34-3050 . case two:
34-3051 . {
34-3052 . run_this;
34-3053 . break;
34-3054 . }
34-3055 . default:
34-3056 . {
34-3057 . SwError;
34-3058 . }
34-3059 . }
34-3060 .
34-3061 . A = B/C;
34-3062 . A = B-C;
34-3063 . A = B-C;
34-3064 . // max LOC 25
34-3065 .
34-3066 . }
34-3067 .
34 34 Result: result/source/ft-app/ft-app-B1.1/log/log-05.c
35 35 Source: source/ft-app/ft-app-B1.1/log/log-06.c
35-0 . /*
35-1 . ----------------------------------------------------------------------------
35-2 . --| BEGIN PROLOGUE
35-3 . --|
35-4 . --| CLASSIFICATION: UNCLASSIFIED
35-5 . --|
35-6 . --| FILE NAME: log-06.c
35-7 . --|
35-8 . --| ABSTRACT:
35-9 . --| This file contains the 14 functions that do file log stuff.
35-10 . --|
35-11 . --| HISTORY:
35-12 . --| CCCQ_NAME:
35-13 . --| CCCQ_VER:
35-14 . --|
35-15 . --| END PROLOGUE
35-16 . ----------------------------------------------------------------------------
35-17 . */
35-18 .
35-19 . #define B;
35-20 . double C;
35-21 . #include B;
35-22 .
35-23 .
35-24 .
35-25 . /*
35-26 . -----------------------------------------------------------------------------
35-27 . --| NAME: log.6.1
35-28 . --|
35-29 . --| ABSTRACT:
35-30 . --| This function does log stuff.
35-31 . --|
35-32 . --| RETURNS:
35-33 . --| NONE.
35-34 . --|
35-35 . ----------------------------------------------------------------------------
35-36 . */
35-37 . static void log.6.1(void)
35-38 . {
35-39 . A = B*C;
35-40 .
35-41 . if (A > B)
35-42 . {
35-43 . A = B + C;
35-44 . D = E + F;
35-45 . }
35-46 .
35-47 . A = B/C;
35-48 . A = B/C;
35-49 . /* LE SV TOC-2080 this is a log-06.1.5 req to set Real Time Clock*/
35-50 . A = B/C;
35-51 . A = B/C;
35-52 . A = B/C;
35-53 . /* LE SV TOC-2081 this is a log-06.1.8 req to assign*/
35-54 . A = B/C;
35-55 . A = B+C;
35-56 . A = B*C;
35-57 . A = B*C;
35-58 . FreePtr = HmiStringPtr;
35-59 .
35-60 . if (A > B)
35-61 . {
35-62 . A = B + C;
35-63 . D = E + F;
35-64 . }
35-65 .
35-66 . A = 0x0004;
35-67 . A = B+C;
35-68 . A = B+C;
35-69 . A = 0x0004;
35-70 . A = B/C;
35-71 .
35-72 . if (A == B)
35-73 . {
35-74 . A = B + C;
35-75 . D = E + F;
35-76 . }
35-77 .
35-78 . // max LOC 16
35-79 .
35-80 . }
35-81 .
35-82 .
35-83 . /*
35-84 . -----------------------------------------------------------------------------
35-85 . --| NAME: log.6.2
35-86 . --|
35-87 . --| ABSTRACT:
35-88 . --| This function does log stuff.
35-89 . --|
35-90 . --| RETURNS:
35-91 . --| NONE.
35-92 . --|
35-93 . ----------------------------------------------------------------------------
35-94 . */
35-95 . static void log.6.2(void)
35-96 . {
35-97 . A = B/C;
35-98 .
35-99 . if (A ne B)
35-100 . {
35-101 . A = B + C;
35-102 . D = E + F;
35-103 . }
35-104 .
35-105 . A = B-C;
35-106 . /* LE SV TOC-2082 this is a log-06.2.4 req to validate*/
35-107 . A = B+C;
35-108 . A = B-C;
35-109 . A = B-C;
35-110 . A = B-C;
35-111 . A = B+C;
35-112 . free(FreePtr);
35-113 . A = B+C;
35-114 . A = B/C;
35-115 . A = B*C;
35-116 . A = B*C;
35-117 .
35-118 . if (A == B)
35-119 . {
35-120 . A = B + C;
35-121 . D = E + F;
35-122 . }
35-123 .
35-124 . A = B+C;
35-125 . A = 0x0002;
35-126 . A = B/C;
35-127 .
35-128 . if (A > B)
35-129 . {
35-130 . A = B + C;
35-131 . D = E + F;
35-132 . }
35-133 .
35-134 .
35-135 . switch (log stuff)
35-136 . {
35-137 . case:
35-138 . case:
35-139 . // stacked case statements but only if there is a new line in between
35-140 .
35-141 . case:
35-142 . case:
35-143 . case:
35-144 . {
35-145 . run_this;
35-146 . break;
35-147 . }
35-148 . default:
35-149 . {
35-150 . halt;
35-151 . }
35-152 . }
35-153 .
35-154 .
35-155 . if (A le B)
35-156 . {
35-157 . A = B + C;
35-158 . D = E + F;
35-159 . }
35-160 .
35-161 . A = B-C;
35-162 . A = B*C;
35-163 .
35-164 . if (A < B)
35-165 . {
35-166 . A = B + C;
35-167 . D = E + F;
35-168 . }
35-169 .
35-170 . A = B/C;
35-171 . A = B*C;
35-172 .
35-173 . if (A > = B)
35-174 . {
35-175 . A = B + C;
35-176 . D = E + F;
35-177 . }
35-178 .
35-179 . A = B-C;
35-180 . A = B/C;
35-181 . A = B+C;
35-182 . // (P) this is really improtant
35-183 .
35-184 . if (A == B)
35-185 . {
35-186 . A = B + C;
35-187 . D = E + F;
35-188 . }
35-189 .
35-190 . A = B/C;
35-191 . A = B-C;
35-192 .
35-193 . switch (log stuff)
35-194 . {
35-195 . case:
35-196 . case:
35-197 . // stacked case statements but only if there is a new line in between
35-198 .
35-199 . case:
35-200 . case:
35-201 . case:
35-202 . {
35-203 . run_this;
35-204 . break;
35-205 . }
35-206 . default:
35-207 . {
35-208 . halt;
35-209 . }
35-210 . }
35-211 .
35-212 . A = B-C;
35-213 . A = B/C;
35-214 . /* LE SV TOC-2083 this is a log-06.2.32 req to enable*/
35-215 . // (P) this is really improtant
35-216 .
35-217 . if (A le B)
35-218 . {
35-219 . A = B + C;
35-220 . D = E + F;
35-221 . }
35-222 .
35-223 . /* LE SV TOC-2084 this is a log-06.2.33 req to verify*/
35-224 . A = B*C;
35-225 . A = 0x0008;
35-226 . A = B/C;
35-227 . A = B+C;
35-228 .
35-229 . switch (log stuff)
35-230 . {
35-231 . case one:
35-232 . {
35-233 . run_this;
35-234 . break;
35-235 . }
35-236 . case two:
35-237 . {
35-238 . run_this;
35-239 . break;
35-240 . }
35-241 . default:
35-242 . {
35-243 . SwError;
35-244 . }
35-245 . }
35-246 .
35-247 .
35-248 . switch (log stuff)
35-249 . {
35-250 . case one:
35-251 . {
35-252 . run_this;
35-253 . break;
35-254 . }
35-255 . case two:
35-256 . {
35-257 . run_this;
35-258 . break;
35-259 . }
35-260 . default:
35-261 . {
35-262 . SwError;
35-263 . }
35-264 . }
35-265 .
35-266 .
35-267 . switch (log stuff)
35-268 . {
35-269 . case one:
35-270 . {
35-271 . run_this;
35-272 . break;
35-273 . }
35-274 . case two:
35-275 . {
35-276 . run_this;
35-277 . break;
35-278 . }
35-279 . default:
35-280 . {
35-281 . SwError;
35-282 . }
35-283 . }
35-284 .
35-285 . A = B*C;
35-286 . A = B*C;
35-287 . A = B-C;
35-288 . A = B/C;
35-289 .
35-290 . if (A < B)
35-291 . {
35-292 . A = B + C;
35-293 . D = E + F;
35-294 . }
35-295 .
35-296 .
35-297 . if (A eq B)
35-298 . {
35-299 . A = B + C;
35-300 . D = E + F;
35-301 . }
35-302 .
35-303 . /* LE SV TOC-2085 this is a log-06.2.45 req to convert*/
35-304 .
35-305 . if (A > = B)
35-306 . {
35-307 . A = B + C;
35-308 . D = E + F;
35-309 . }
35-310 .
35-311 . A = B*C;
35-312 . A = B-C;
35-313 . /* LE SV TOC-2086 this is a log-06.2.48 req to compare*/
35-314 . A = B+C;
35-315 .
35-316 . if (A > = B)
35-317 . {
35-318 . A = B + C;
35-319 . D = E + F;
35-320 . }
35-321 .
35-322 .
35-323 . if (A == B)
35-324 . {
35-325 . A = B + C;
35-326 . D = E + F;
35-327 . }
35-328 .
35-329 .
35-330 . if (A lt B)
35-331 . {
35-332 . A = B + C;
35-333 . D = E + F;
35-334 . }
35-335 .
35-336 . A = B/C;
35-337 . A = 0x0003;
35-338 . A = B-C;
35-339 .
35-340 . switch (log stuff)
35-341 . {
35-342 . case one:
35-343 . {
35-344 . run_this;
35-345 . break;
35-346 . }
35-347 . case two:
35-348 . {
35-349 . run_this;
35-350 . break;
35-351 . }
35-352 . default:
35-353 . {
35-354 . SwError;
35-355 . }
35-356 . }
35-357 .
35-358 . // max LOC 54
35-359 .
35-360 . }
35-361 .
35-362 .
35-363 . /*
35-364 . -----------------------------------------------------------------------------
35-365 . --| NAME: log.6.3
35-366 . --|
35-367 . --| ABSTRACT:
35-368 . --| This function does log stuff.
35-369 . --|
35-370 . --| RETURNS:
35-371 . --| NONE.
35-372 . --|
35-373 . ----------------------------------------------------------------------------
35-374 . */
35-375 . static void log.6.3(void)
35-376 . {
35-377 .
35-378 . switch (log stuff)
35-379 . {
35-380 . case:
35-381 . case:
35-382 . // stacked case statements but only if there is a new line in between
35-383 .
35-384 . case:
35-385 . case:
35-386 . case:
35-387 . {
35-388 . run_this;
35-389 . break;
35-390 . }
35-391 . default:
35-392 . {
35-393 . halt;
35-394 . }
35-395 . }
35-396 .
35-397 .
35-398 . if (A == B)
35-399 . {
35-400 . A = B + C;
35-401 . D = E + F;
35-402 . }
35-403 .
35-404 . A = B-C;
35-405 . A = B/C;
35-406 . A = B*C;
35-407 . A = B*C;
35-408 .
35-409 . if (A > B)
35-410 . {
35-411 . A = B + C;
35-412 . D = E + F;
35-413 . }
35-414 .
35-415 .
35-416 . if (A < B)
35-417 . {
35-418 . A = B + C;
35-419 . D = E + F;
35-420 . }
35-421 .
35-422 . A = B/C;
35-423 . A = 0x0001;
35-424 .
35-425 . if (A > = B)
35-426 . {
35-427 . A = B + C;
35-428 . D = E + F;
35-429 . }
35-430 .
35-431 .
35-432 . if (A < = B)
35-433 . {
35-434 . A = B + C;
35-435 . D = E + F;
35-436 . }
35-437 .
35-438 .
35-439 . if (A ne B)
35-440 . {
35-441 . A = B + C;
35-442 . D = E + F;
35-443 . }
35-444 .
35-445 .
35-446 . if (A ne B)
35-447 . {
35-448 . A = B + C;
35-449 . D = E + F;
35-450 . }
35-451 .
35-452 .
35-453 . if (A gt B)
35-454 . {
35-455 . A = B + C;
35-456 . D = E + F;
35-457 . }
35-458 .
35-459 .
35-460 . if (A > = B)
35-461 . {
35-462 . A = B + C;
35-463 . D = E + F;
35-464 . }
35-465 .
35-466 . A = 0x0006;
35-467 .
35-468 . if (A == B)
35-469 . {
35-470 . A = B + C;
35-471 . D = E + F;
35-472 . }
35-473 .
35-474 . A = B/C;
35-475 . /* LE SV TOC-2087 this is a log-06.3.17 req to fail*/
35-476 .
35-477 . switch (log stuff)
35-478 . {
35-479 . case one:
35-480 . {
35-481 . run_this;
35-482 . break;
35-483 . }
35-484 . case two:
35-485 . {
35-486 . run_this;
35-487 . break;
35-488 . }
35-489 . default:
35-490 . {
35-491 . SwError;
35-492 . }
35-493 . }
35-494 .
35-495 . A = B*C;
35-496 . A = B/C;
35-497 .
35-498 . if (A < B)
35-499 . {
35-500 . A = B + C;
35-501 . D = E + F;
35-502 . }
35-503 .
35-504 .
35-505 . if (A > B)
35-506 . {
35-507 . A = B + C;
35-508 . D = E + F;
35-509 . }
35-510 .
35-511 . A = B-C;
35-512 . A = B/C;
35-513 . A = B/C;
35-514 .
35-515 . if (A ge B)
35-516 . {
35-517 . A = B + C;
35-518 . D = E + F;
35-519 . }
35-520 .
35-521 . FreePtr = HmiStringPtr;
35-522 . A = B-C;
35-523 . FreePtr = HmiStringPtr;
35-524 .
35-525 . if (A < B)
35-526 . {
35-527 . A = B + C;
35-528 . D = E + F;
35-529 . }
35-530 .
35-531 . A = B+C;
35-532 .
35-533 . if (A != B)
35-534 . {
35-535 . A = B + C;
35-536 . D = E + F;
35-537 . }
35-538 .
35-539 . A = B-C;
35-540 .
35-541 . if (A > = B)
35-542 . {
35-543 . A = B + C;
35-544 . D = E + F;
35-545 . }
35-546 .
35-547 . A = B+C;
35-548 . A = B+C;
35-549 . A = B*C;
35-550 .
35-551 . if (A == B)
35-552 . {
35-553 . A = B + C;
35-554 . D = E + F;
35-555 . }
35-556 .
35-557 . A = B*C;
35-558 .
35-559 . if (A < B)
35-560 . {
35-561 . A = B + C;
35-562 . D = E + F;
35-563 . }
35-564 .
35-565 . A = B-C;
35-566 . A = B-C;
35-567 . A = B/C;
35-568 .
35-569 . if (A != B)
35-570 . {
35-571 . A = B + C;
35-572 . D = E + F;
35-573 . }
35-574 .
35-575 . A = B+C;
35-576 . A = B*C;
35-577 . /* LE SV TOC-2088 this is a log-06.3.44 req to store*/
35-578 . A = B-C;
35-579 . A = B+C;
35-580 .
35-581 . if (A == B)
35-582 . {
35-583 . A = B + C;
35-584 . D = E + F;
35-585 . }
35-586 .
35-587 . A = B+C;
35-588 . /* LE SV TOC-2089 this is a log-06.3.48 req to record*/
35-589 . A = B/C;
35-590 . /* LE SV TOC-2090 this is a log-06.3.49 req to reject*/
35-591 . free(FreePtr);
35-592 . A = B+C;
35-593 . A = B/C;
35-594 . A = B/C;
35-595 . A = B-C;
35-596 . A = B+C;
35-597 . A = B/C;
35-598 . A = B/C;
35-599 . A = B+C;
35-600 . // max LOC 56
35-601 .
35-602 . }
35-603 .
35-604 .
35-605 . /*
35-606 . -----------------------------------------------------------------------------
35-607 . --| NAME: log.6.4
35-608 . --|
35-609 . --| ABSTRACT:
35-610 . --| This function does log stuff.
35-611 . --|
35-612 . --| RETURNS:
35-613 . --| NONE.
35-614 . --|
35-615 . ----------------------------------------------------------------------------
35-616 . */
35-617 . static void log.6.4(void)
35-618 . {
35-619 .
35-620 . if (A ne B)
35-621 . {
35-622 . A = B + C;
35-623 . D = E + F;
35-624 . }
35-625 .
35-626 . A = B/C;
35-627 . A = B*C;
35-628 .
35-629 . if (A lt B)
35-630 . {
35-631 . A = B + C;
35-632 . D = E + F;
35-633 . }
35-634 .
35-635 . A = B/C;
35-636 . A = B*C;
35-637 . A = B*C;
35-638 .
35-639 . if (A eq B)
35-640 . {
35-641 . A = B + C;
35-642 . D = E + F;
35-643 . }
35-644 .
35-645 .
35-646 . if (A gt B)
35-647 . {
35-648 . A = B + C;
35-649 . D = E + F;
35-650 . }
35-651 .
35-652 . A = B/C;
35-653 .
35-654 . if (A < B)
35-655 . {
35-656 . A = B + C;
35-657 . D = E + F;
35-658 . }
35-659 .
35-660 . A = B+C;
35-661 . A = B+C;
35-662 .
35-663 . if (A < B)
35-664 . {
35-665 . A = B + C;
35-666 . D = E + F;
35-667 . }
35-668 .
35-669 . A = B-C;
35-670 . A = B/C;
35-671 . A = B/C;
35-672 . A = B*C;
35-673 .
35-674 . if (A lt B)
35-675 . {
35-676 . A = B + C;
35-677 . D = E + F;
35-678 . }
35-679 .
35-680 .
35-681 . /* dead_block = C * D;
35-682 . dead_block = E * F; */
35-683 .
35-684 .
35-685 . if (A ne B)
35-686 . {
35-687 . A = B + C;
35-688 . D = E + F;
35-689 . }
35-690 .
35-691 . A = B-C;
35-692 .
35-693 . if (A lt B)
35-694 . {
35-695 . A = B + C;
35-696 . D = E + F;
35-697 . }
35-698 .
35-699 .
35-700 . if (A gt B)
35-701 . {
35-702 . A = B + C;
35-703 . D = E + F;
35-704 . }
35-705 .
35-706 . A = B+C;
35-707 .
35-708 . if (A lt B)
35-709 . {
35-710 . A = B + C;
35-711 . D = E + F;
35-712 . }
35-713 .
35-714 . A = B+C;
35-715 . /* LE SV TOC-2091 this is a log-06.4.27 req to call admin*/
35-716 . A = B-C;
35-717 . A = B*C;
35-718 . A = B-C;
35-719 . A = B-C;
35-720 . A = B*C;
35-721 . A = B*C;
35-722 . A = B*C;
35-723 . A = B/C;
35-724 . A = B/C;
35-725 . A = B*C;
35-726 .
35-727 . if (A ne B)
35-728 . {
35-729 . A = B + C;
35-730 . D = E + F;
35-731 . }
35-732 .
35-733 . /* LE SV TOC-2092 this is a log-06.4.38 req to compare*/
35-734 . A = B+C;
35-735 . A = B+C;
35-736 . A = B+C;
35-737 . A = B*C;
35-738 . /* LE SV TOC-2093 this is a log-06.4.42 req to verify*/
35-739 . A = B/C;
35-740 . A = B/C;
35-741 . A = B*C;
35-742 . A = B-C;
35-743 . A = B+C;
35-744 . A = B*C;
35-745 .
35-746 . switch (log stuff)
35-747 . {
35-748 . case one:
35-749 . {
35-750 . run_this;
35-751 . break;
35-752 . }
35-753 . case two:
35-754 . {
35-755 . run_this;
35-756 . break;
35-757 . }
35-758 . default:
35-759 . {
35-760 . SwError;
35-761 . }
35-762 . }
35-763 .
35-764 .
35-765 . if (A ne B)
35-766 . {
35-767 . A = B + C;
35-768 . D = E + F;
35-769 . }
35-770 .
35-771 . A = B+C;
35-772 . A = B/C;
35-773 . A = B*C;
35-774 . A = B-C;
35-775 .
35-776 . if (A > = B)
35-777 . {
35-778 . A = B + C;
35-779 . D = E + F;
35-780 . }
35-781 .
35-782 .
35-783 . if (A lt B)
35-784 . {
35-785 . A = B + C;
35-786 . D = E + F;
35-787 . }
35-788 .
35-789 . A = B-C;
35-790 . A = B-C;
35-791 . A = B/C;
35-792 . A = B-C;
35-793 .
35-794 . if (A > = B)
35-795 . {
35-796 . A = B + C;
35-797 . D = E + F;
35-798 . }
35-799 .
35-800 . A = B*C;
35-801 . A = B+C;
35-802 .
35-803 . /* dead_block = C * D;
35-804 . dead_block = E * F; */
35-805 .
35-806 .
35-807 . if (A eq B)
35-808 . {
35-809 . A = B + C;
35-810 . D = E + F;
35-811 . }
35-812 .
35-813 .
35-814 . if (A > B)
35-815 . {
35-816 . A = B + C;
35-817 . D = E + F;
35-818 . }
35-819 .
35-820 .
35-821 . if (A > B)
35-822 . {
35-823 . A = B + C;
35-824 . D = E + F;
35-825 . }
35-826 .
35-827 . A = 0x0006;
35-828 . A = B-C;
35-829 . // max LOC 66
35-830 .
35-831 . }
35-832 .
35-833 .
35-834 . /*
35-835 . -----------------------------------------------------------------------------
35-836 . --| NAME: log.6.5
35-837 . --|
35-838 . --| ABSTRACT:
35-839 . --| This function does log stuff.
35-840 . --|
35-841 . --| RETURNS:
35-842 . --| NONE.
35-843 . --|
35-844 . ----------------------------------------------------------------------------
35-845 . */
35-846 . static void log.6.5(void)
35-847 . {
35-848 . A = B+C;
35-849 . A = B+C;
35-850 . A = B+C;
35-851 . A = B*C;
35-852 . A = B-C;
35-853 . A = B/C;
35-854 . A = B*C;
35-855 .
35-856 . if (A ne B)
35-857 . {
35-858 . A = B + C;
35-859 . D = E + F;
35-860 . }
35-861 .
35-862 . A = B*C;
35-863 . A = B*C;
35-864 . A = B*C;
35-865 .
35-866 . switch (log stuff)
35-867 . {
35-868 . case one:
35-869 . {
35-870 . switch (nested)
35-871 . {
35-872 . case:
35-873 . X = Y + Z;
35-874 . case:
35-875 . X = Y + Z;
35-876 . default:
35-877 . SwError;
35-878 . }
35-879 . }
35-880 . case two:
35-881 . {
35-882 . run_this;
35-883 . break;
35-884 . }
35-885 . default:
35-886 . {
35-887 . SwError;
35-888 . }
35-889 . }
35-890 .
35-891 . A = B-C;
35-892 . A = B/C;
35-893 . A = 0x0007;
35-894 .
35-895 . if (A le B)
35-896 . {
35-897 . A = B + C;
35-898 . D = E + F;
35-899 . }
35-900 .
35-901 . A = B*C;
35-902 . A = B/C;
35-903 . A = B*C;
35-904 . A = B/C;
35-905 . A = B*C;
35-906 .
35-907 . if (A ne B)
35-908 . {
35-909 . A = B + C;
35-910 . D = E + F;
35-911 . }
35-912 .
35-913 .
35-914 . switch (log stuff)
35-915 . {
35-916 . case:
35-917 . case:
35-918 . // stacked case statements but only if there is a new line in between
35-919 .
35-920 . case:
35-921 . case:
35-922 . case:
35-923 . {
35-924 . run_this;
35-925 . break;
35-926 . }
35-927 . default:
35-928 . {
35-929 . halt;
35-930 . }
35-931 . }
35-932 .
35-933 .
35-934 . if (A ge B)
35-935 . {
35-936 . A = B + C;
35-937 . D = E + F;
35-938 . }
35-939 .
35-940 . A = B/C;
35-941 . A = B+C;
35-942 . A = B/C;
35-943 .
35-944 . if (A ge B)
35-945 . {
35-946 . A = B + C;
35-947 . D = E + F;
35-948 . }
35-949 .
35-950 . A = B+C;
35-951 . A = B*C;
35-952 . A = B*C;
35-953 . A = B+C;
35-954 . A = B-C;
35-955 . A = B+C;
35-956 . A = B/C;
35-957 . A = B+C;
35-958 . A = B-C;
35-959 . /* LE SV TOC-2094 this is a log-06.5.35 req to update*/
35-960 . A = B*C;
35-961 . A = B*C;
35-962 . A = B+C;
35-963 . A = B+C;
35-964 . A = B*C;
35-965 . A = B-C;
35-966 .
35-967 . if (A eq B)
35-968 . {
35-969 . A = B + C;
35-970 . D = E + F;
35-971 . }
35-972 .
35-973 . A = B-C;
35-974 . A = B*C;
35-975 . A = B+C;
35-976 . A = B/C;
35-977 . A = B-C;
35-978 . A = B+C;
35-979 . A = B/C;
35-980 .
35-981 . if (A ne B)
35-982 . {
35-983 . A = B + C;
35-984 . D = E + F;
35-985 . }
35-986 .
35-987 . A = B/C;
35-988 . A = B*C;
35-989 . /* LE SV TOC-2095 this is a log-06.5.52 req to reject*/
35-990 .
35-991 . if (A ge B)
35-992 . {
35-993 . A = B + C;
35-994 . D = E + F;
35-995 . }
35-996 .
35-997 . A = B+C;
35-998 . A = B/C;
35-999 . A = B+C;
35-1000 .
35-1001 . if ($log stuff > $otherlog stuff)
35-1002 . /* LE SV TOC-008 we really should log all error calls */
35-1003 . {
35-1004 . A = B + C;
35-1005 . }
35-1006 .
35-1007 .
35-1008 . if (A ne B)
35-1009 . {
35-1010 . A = B + C;
35-1011 . D = E + F;
35-1012 . }
35-1013 .
35-1014 .
35-1015 . if (A > = B)
35-1016 . {
35-1017 . A = B + C;
35-1018 . D = E + F;
35-1019 . }
35-1020 .
35-1021 . A = B-C;
35-1022 . A = B*C;
35-1023 .
35-1024 . if (A != B)
35-1025 . {
35-1026 . A = B + C;
35-1027 . D = E + F;
35-1028 . }
35-1029 .
35-1030 .
35-1031 . if {
35-1032 . X = Y + Z;
35-1033 . }
35-1034 . else {
35-1035 . halt;
35-1036 . }
35-1037 .
35-1038 .
35-1039 . if (A == B)
35-1040 . {
35-1041 . A = B + C;
35-1042 . D = E + F;
35-1043 . }
35-1044 .
35-1045 . A = B/C;
35-1046 .
35-1047 . if (A > B)
35-1048 . {
35-1049 . A = B + C;
35-1050 . D = E + F;
35-1051 . }
35-1052 .
35-1053 . A = B/C;
35-1054 . // max LOC 64
35-1055 .
35-1056 . }
35-1057 .
35-1058 .
35-1059 . /*
35-1060 . -----------------------------------------------------------------------------
35-1061 . --| NAME: log.6.6
35-1062 . --|
35-1063 . --| ABSTRACT:
35-1064 . --| This function does log stuff.
35-1065 . --|
35-1066 . --| RETURNS:
35-1067 . --| NONE.
35-1068 . --|
35-1069 . ----------------------------------------------------------------------------
35-1070 . */
35-1071 . static void log.6.6(void)
35-1072 . {
35-1073 . A = B*C;
35-1074 . A = B*C;
35-1075 .
35-1076 . if (A le B)
35-1077 . {
35-1078 . A = B + C;
35-1079 . D = E + F;
35-1080 . }
35-1081 .
35-1082 . A = B-C;
35-1083 . A = B/C;
35-1084 . A = B*C;
35-1085 . A = B*C;
35-1086 . A = B/C;
35-1087 . A = B-C;
35-1088 . /* LE SV TOC-2096 this is a log-06.6.10 req to record*/
35-1089 . A = B-C;
35-1090 . A = B/C;
35-1091 . A = B-C;
35-1092 . /* LE SV TOC-2097 this is a log-06.6.13 req to record*/
35-1093 . A = B*C;
35-1094 . A = B/C;
35-1095 .
35-1096 . if (A == B)
35-1097 . {
35-1098 . A = B + C;
35-1099 . D = E + F;
35-1100 . }
35-1101 .
35-1102 . A = B-C;
35-1103 .
35-1104 . if (A == B)
35-1105 . {
35-1106 . A = B + C;
35-1107 . D = E + F;
35-1108 . }
35-1109 .
35-1110 . A = B+C;
35-1111 . A = B-C;
35-1112 . A = B/C;
35-1113 . A = B*C;
35-1114 . A = B*C;
35-1115 . A = B+C;
35-1116 .
35-1117 . if (A ne B)
35-1118 . {
35-1119 . A = B + C;
35-1120 . D = E + F;
35-1121 . }
35-1122 .
35-1123 . A = B-C;
35-1124 . A = B+C;
35-1125 . A = B+C;
35-1126 .
35-1127 . if (A eq B)
35-1128 . {
35-1129 . A = B + C;
35-1130 . D = E + F;
35-1131 . }
35-1132 .
35-1133 . A = B+C;
35-1134 . A = B/C;
35-1135 . A = 0x0006;
35-1136 .
35-1137 . if (A < = B)
35-1138 . {
35-1139 . A = B + C;
35-1140 . D = E + F;
35-1141 . }
35-1142 .
35-1143 .
35-1144 . if (A > = B)
35-1145 . {
35-1146 . A = B + C;
35-1147 . D = E + F;
35-1148 . }
35-1149 .
35-1150 . A = B-C;
35-1151 . A = B/C;
35-1152 . A = B/C;
35-1153 .
35-1154 . if (A lt B)
35-1155 . {
35-1156 . A = B + C;
35-1157 . D = E + F;
35-1158 . }
35-1159 .
35-1160 . A = B-C;
35-1161 . A = B/C;
35-1162 . A = B+C;
35-1163 .
35-1164 . switch (log stuff)
35-1165 . {
35-1166 . case one:
35-1167 . {
35-1168 . run_this;
35-1169 . // missing break
35-1170 . }
35-1171 . case two:
35-1172 . {
35-1173 . run_this;
35-1174 . break;
35-1175 . }
35-1176 . default:
35-1177 . {
35-1178 . SwError;
35-1179 . }
35-1180 . }
35-1181 .
35-1182 . A = B*C;
35-1183 . A = B-C;
35-1184 . A = B/C;
35-1185 . A = B*C;
35-1186 . /* LE SV TOC-2098 this is a log-06.6.44 req to inhibit*/
35-1187 . A = B+C;
35-1188 . A = B*C;
35-1189 . A = B+C;
35-1190 .
35-1191 . if (A le B)
35-1192 . {
35-1193 . A = B + C;
35-1194 . D = E + F;
35-1195 . }
35-1196 .
35-1197 .
35-1198 . if (A < = B)
35-1199 . {
35-1200 . A = B + C;
35-1201 . D = E + F;
35-1202 . }
35-1203 .
35-1204 . A = B/C;
35-1205 . A = B/C;
35-1206 . A = B*C;
35-1207 .
35-1208 . if (A ne B)
35-1209 . {
35-1210 . A = B + C;
35-1211 . D = E + F;
35-1212 . }
35-1213 .
35-1214 . A = B+C;
35-1215 .
35-1216 . if (A < B)
35-1217 . {
35-1218 . A = B + C;
35-1219 . D = E + F;
35-1220 . }
35-1221 .
35-1222 .
35-1223 . if (A lt B)
35-1224 . {
35-1225 . A = B + C;
35-1226 . D = E + F;
35-1227 . }
35-1228 .
35-1229 . /* LE SV TOC-2099 this is a log-06.6.56 req to detect error*/
35-1230 .
35-1231 . /*
35-1232 . dead_code = B - C;
35-1233 . dead_code = D - E;
35-1234 . dead_code = F - G;
35-1235 . */
35-1236 .
35-1237 . A = B*C;
35-1238 .
35-1239 . if (A gt B)
35-1240 . {
35-1241 . A = B + C;
35-1242 . D = E + F;
35-1243 . }
35-1244 .
35-1245 . A = B*C;
35-1246 . /* LE SV TOC-2100 this is a log-06.6.59 req to transform*/
35-1247 . A = B+C;
35-1248 . A = B+C;
35-1249 . A = B*C;
35-1250 . A = B/C;
35-1251 .
35-1252 . if (A ge B)
35-1253 . {
35-1254 . A = B + C;
35-1255 . D = E + F;
35-1256 . }
35-1257 .
35-1258 . /* LE SV TOC-2101 this is a log-06.6.64 req to halt*/
35-1259 .
35-1260 . if (A < = B)
35-1261 . {
35-1262 . A = B + C;
35-1263 . D = E + F;
35-1264 . }
35-1265 .
35-1266 . A = B-C;
35-1267 . // max LOC 65
35-1268 .
35-1269 . }
35-1270 .
35-1271 .
35-1272 . /*
35-1273 . -----------------------------------------------------------------------------
35-1274 . --| NAME: log.6.7
35-1275 . --|
35-1276 . --| ABSTRACT:
35-1277 . --| This function does log stuff.
35-1278 . --|
35-1279 . --| RETURNS:
35-1280 . --| NONE.
35-1281 . --|
35-1282 . ----------------------------------------------------------------------------
35-1283 . */
35-1284 . static void log.6.7(void)
35-1285 . {
35-1286 . // TBD - what do I do now
35-1287 .
35-1288 . if (A != B)
35-1289 . {
35-1290 . A = B + C;
35-1291 . D = E + F;
35-1292 . }
35-1293 .
35-1294 . A = B-C;
35-1295 .
35-1296 . if (A ne B)
35-1297 . {
35-1298 . A = B + C;
35-1299 . D = E + F;
35-1300 . }
35-1301 .
35-1302 . A = B*C;
35-1303 . A = B/C;
35-1304 . A = B+C;
35-1305 .
35-1306 . if (A eq B)
35-1307 . {
35-1308 . A = B + C;
35-1309 . D = E + F;
35-1310 . }
35-1311 .
35-1312 . A = B+C;
35-1313 .
35-1314 . if (A < = B)
35-1315 . {
35-1316 . A = B + C;
35-1317 . D = E + F;
35-1318 . }
35-1319 .
35-1320 . A = B-C;
35-1321 . A = B/C;
35-1322 . A = B+C;
35-1323 . A = B-C;
35-1324 . A = B+C;
35-1325 . A = B-C;
35-1326 . A = B/C;
35-1327 . A = B+C;
35-1328 . A = B/C;
35-1329 .
35-1330 . if (A gt B)
35-1331 . {
35-1332 . A = B + C;
35-1333 . D = E + F;
35-1334 . }
35-1335 .
35-1336 .
35-1337 . if (A < = B)
35-1338 . {
35-1339 . A = B + C;
35-1340 . D = E + F;
35-1341 . }
35-1342 .
35-1343 . A = B/C;
35-1344 . A = B-C;
35-1345 . A = B*C;
35-1346 . A = B-C;
35-1347 . A = B+C;
35-1348 . A = B*C;
35-1349 . A = B*C;
35-1350 . A = B+C;
35-1351 .
35-1352 . if (A > = B)
35-1353 . {
35-1354 . A = B + C;
35-1355 . D = E + F;
35-1356 . }
35-1357 .
35-1358 . A = B*C;
35-1359 . A = B+C;
35-1360 . A = B-C;
35-1361 . A = B/C;
35-1362 . A = B/C;
35-1363 .
35-1364 . if (A ge B)
35-1365 . {
35-1366 . A = B + C;
35-1367 . D = E + F;
35-1368 . }
35-1369 .
35-1370 . A = B*C;
35-1371 .
35-1372 . if (A > = B)
35-1373 . {
35-1374 . A = B + C;
35-1375 . D = E + F;
35-1376 . }
35-1377 .
35-1378 . A = B*C;
35-1379 . /* LE SV TOC-2102 this is a log-06.7.39 req to call isr*/
35-1380 . A = B-C;
35-1381 .
35-1382 . if (A ne B)
35-1383 . {
35-1384 . A = B + C;
35-1385 . D = E + F;
35-1386 . }
35-1387 .
35-1388 . A = B/C;
35-1389 . A = B/C;
35-1390 .
35-1391 . if (A le B)
35-1392 . {
35-1393 . A = B + C;
35-1394 . D = E + F;
35-1395 . }
35-1396 .
35-1397 .
35-1398 . if (A < B)
35-1399 . {
35-1400 . A = B + C;
35-1401 . D = E + F;
35-1402 . }
35-1403 .
35-1404 . A = B+C;
35-1405 . A = B-C;
35-1406 . A = B-C;
35-1407 . A = B+C;
35-1408 .
35-1409 . if (A ne B)
35-1410 . {
35-1411 . A = B + C;
35-1412 . D = E + F;
35-1413 . }
35-1414 .
35-1415 .
35-1416 . if (A != B)
35-1417 . {
35-1418 . A = B + C;
35-1419 . D = E + F;
35-1420 . }
35-1421 .
35-1422 . /* LE SV TOC-2103 this is a log-06.7.51 req to disable*/
35-1423 .
35-1424 . if (A ne B)
35-1425 . {
35-1426 . A = B + C;
35-1427 . D = E + F;
35-1428 . }
35-1429 .
35-1430 .
35-1431 . if (A == B)
35-1432 . {
35-1433 . A = B + C;
35-1434 . D = E + F;
35-1435 . }
35-1436 .
35-1437 .
35-1438 . if (A > = B)
35-1439 . {
35-1440 . A = B + C;
35-1441 . D = E + F;
35-1442 . }
35-1443 .
35-1444 . A = B+C;
35-1445 . A = B+C;
35-1446 . A = B+C;
35-1447 . A = B/C;
35-1448 .
35-1449 . if (A ne B)
35-1450 . {
35-1451 . A = B + C;
35-1452 . D = E + F;
35-1453 . }
35-1454 .
35-1455 .
35-1456 . if (A gt B)
35-1457 . {
35-1458 . A = B + C;
35-1459 . D = E + F;
35-1460 . }
35-1461 .
35-1462 . A = B/C;
35-1463 . A = B/C;
35-1464 .
35-1465 . if (A ge B)
35-1466 . {
35-1467 . A = B + C;
35-1468 . D = E + F;
35-1469 . }
35-1470 .
35-1471 . A = B*C;
35-1472 . // max LOC 63
35-1473 .
35-1474 . }
35-1475 .
35-1476 .
35-1477 . /*
35-1478 . -----------------------------------------------------------------------------
35-1479 . --| NAME: log.6.8
35-1480 . --|
35-1481 . --| ABSTRACT:
35-1482 . --| This function does log stuff.
35-1483 . --|
35-1484 . --| RETURNS:
35-1485 . --| NONE.
35-1486 . --|
35-1487 . ----------------------------------------------------------------------------
35-1488 . */
35-1489 . static void log.6.8(void)
35-1490 . {
35-1491 . A = B-C;
35-1492 . A = B/C;
35-1493 . A = B-C;
35-1494 .
35-1495 . if (A gt B)
35-1496 . {
35-1497 . A = B + C;
35-1498 . D = E + F;
35-1499 . }
35-1500 .
35-1501 . A = B/C;
35-1502 . A = B*C;
35-1503 . A = B/C;
35-1504 .
35-1505 . if (A < = B)
35-1506 . {
35-1507 . A = B + C;
35-1508 . D = E + F;
35-1509 . }
35-1510 .
35-1511 . A = B+C;
35-1512 . A = B-C;
35-1513 . A = B*C;
35-1514 . A = B*C;
35-1515 . A = B*C;
35-1516 . // max LOC 13
35-1517 .
35-1518 . }
35-1519 .
35-1520 .
35-1521 . /*
35-1522 . -----------------------------------------------------------------------------
35-1523 . --| NAME: log.6.9
35-1524 . --|
35-1525 . --| ABSTRACT:
35-1526 . --| This function does log stuff.
35-1527 . --|
35-1528 . --| RETURNS:
35-1529 . --| NONE.
35-1530 . --|
35-1531 . ----------------------------------------------------------------------------
35-1532 . */
35-1533 . static void log.6.9(void)
35-1534 . {
35-1535 .
35-1536 . switch (log stuff)
35-1537 . {
35-1538 . case one:
35-1539 . {
35-1540 . run_this;
35-1541 . break;
35-1542 . }
35-1543 . case two:
35-1544 . {
35-1545 . run_this;
35-1546 . break;
35-1547 . }
35-1548 . // missing default
35-1549 . }
35-1550 .
35-1551 .
35-1552 . if (A < = B)
35-1553 . {
35-1554 . A = B + C;
35-1555 . D = E + F;
35-1556 . }
35-1557 .
35-1558 . A = B+C;
35-1559 . A = B/C;
35-1560 . A = B+C;
35-1561 .
35-1562 . if (A ge B)
35-1563 . {
35-1564 . A = B + C;
35-1565 . D = E + F;
35-1566 . }
35-1567 .
35-1568 . A = B/C;
35-1569 . A = B/C;
35-1570 . A = B*C;
35-1571 .
35-1572 . if (A ge B)
35-1573 . {
35-1574 . A = B + C;
35-1575 . D = E + F;
35-1576 . }
35-1577 .
35-1578 .
35-1579 . if (A != B)
35-1580 . {
35-1581 . A = B + C;
35-1582 . D = E + F;
35-1583 . }
35-1584 .
35-1585 . A = B-C;
35-1586 . A = B+C;
35-1587 . A = B*C;
35-1588 . A = B-C;
35-1589 .
35-1590 . if (A == B)
35-1591 . {
35-1592 . A = B + C;
35-1593 . D = E + F;
35-1594 . }
35-1595 .
35-1596 . A = B-C;
35-1597 . A = B-C;
35-1598 . A = B*C;
35-1599 .
35-1600 . if (A le B)
35-1601 . {
35-1602 . A = B + C;
35-1603 . D = E + F;
35-1604 . }
35-1605 .
35-1606 .
35-1607 . switch (log stuff)
35-1608 . {
35-1609 . case one:
35-1610 . {
35-1611 . run_this;
35-1612 . break;
35-1613 . }
35-1614 . case two:
35-1615 . {
35-1616 . run_this;
35-1617 . break;
35-1618 . }
35-1619 . default:
35-1620 . {
35-1621 . SwError;
35-1622 . }
35-1623 . }
35-1624 .
35-1625 .
35-1626 . if (A lt B)
35-1627 . {
35-1628 . A = B + C;
35-1629 . D = E + F;
35-1630 . }
35-1631 .
35-1632 . A = B*C;
35-1633 .
35-1634 . if (A eq B)
35-1635 . {
35-1636 . A = B + C;
35-1637 . D = E + F;
35-1638 . }
35-1639 .
35-1640 . /* LE SV TOC-2104 this is a log-06.9.24 req to disable*/
35-1641 .
35-1642 . if (A == B)
35-1643 . {
35-1644 . A = B + C;
35-1645 . D = E + F;
35-1646 . }
35-1647 .
35-1648 .
35-1649 . if (A < = B)
35-1650 . {
35-1651 . A = B + C;
35-1652 . D = E + F;
35-1653 . }
35-1654 .
35-1655 . A = B/C;
35-1656 . A = B-C;
35-1657 . A = B*C;
35-1658 .
35-1659 . if (A eq B)
35-1660 . {
35-1661 . A = B + C;
35-1662 . D = E + F;
35-1663 . }
35-1664 .
35-1665 .
35-1666 . if (A < B)
35-1667 . {
35-1668 . A = B + C;
35-1669 . D = E + F;
35-1670 . }
35-1671 .
35-1672 . A = B*C;
35-1673 . A = B/C;
35-1674 . A = B*C;
35-1675 . A = B-C;
35-1676 . A = B/C;
35-1677 . /* LE SV TOC-2105 this is a log-06.9.36 req to convert*/
35-1678 . A = B+C;
35-1679 .
35-1680 . if (A ge B)
35-1681 . {
35-1682 . A = B + C;
35-1683 . D = E + F;
35-1684 . }
35-1685 .
35-1686 .
35-1687 . if (A eq B)
35-1688 . {
35-1689 . A = B + C;
35-1690 . D = E + F;
35-1691 . }
35-1692 .
35-1693 . /* LE SV TOC-2106 this is a log-06.9.39 req to disable*/
35-1694 .
35-1695 . if (A gt B)
35-1696 . {
35-1697 . A = B + C;
35-1698 . D = E + F;
35-1699 . }
35-1700 .
35-1701 . A = B+C;
35-1702 .
35-1703 . if (A > = B)
35-1704 . {
35-1705 . A = B + C;
35-1706 . D = E + F;
35-1707 . }
35-1708 .
35-1709 . A = B/C;
35-1710 . A = (int)B + C;
35-1711 .
35-1712 . if (A eq B)
35-1713 . {
35-1714 . A = B + C;
35-1715 . D = E + F;
35-1716 . }
35-1717 .
35-1718 . A = B/C;
35-1719 . /* LE SV TOC-2107 this is a log-06.9.45 req to call isr*/
35-1720 . A = B-C;
35-1721 .
35-1722 . if (A le B)
35-1723 . {
35-1724 . A = B + C;
35-1725 . D = E + F;
35-1726 . }
35-1727 .
35-1728 . A = B-C;
35-1729 . FreePtr = HmiStringPtr;
35-1730 . A = B-C;
35-1731 .
35-1732 . if (A > = B)
35-1733 . {
35-1734 . A = B + C;
35-1735 . D = E + F;
35-1736 . }
35-1737 .
35-1738 . A = B/C;
35-1739 .
35-1740 . if (A gt B)
35-1741 . {
35-1742 . A = B + C;
35-1743 . D = E + F;
35-1744 . }
35-1745 .
35-1746 . A = B*C;
35-1747 . A = B*C;
35-1748 . A = B*C;
35-1749 . A = B+C;
35-1750 .
35-1751 . if (A < B)
35-1752 . {
35-1753 . A = B + C;
35-1754 . D = E + F;
35-1755 . }
35-1756 .
35-1757 . // max LOC 56
35-1758 .
35-1759 . }
35-1760 .
35-1761 .
35-1762 . /*
35-1763 . -----------------------------------------------------------------------------
35-1764 . --| NAME: log.6.10
35-1765 . --|
35-1766 . --| ABSTRACT:
35-1767 . --| This function does log stuff.
35-1768 . --|
35-1769 . --| RETURNS:
35-1770 . --| NONE.
35-1771 . --|
35-1772 . ----------------------------------------------------------------------------
35-1773 . */
35-1774 . static void log.6.10(void)
35-1775 . {
35-1776 . A = B/C;
35-1777 . A = B*C;
35-1778 . A = B*C;
35-1779 . A = B+C;
35-1780 .
35-1781 . if (A eq B)
35-1782 . {
35-1783 . A = B + C;
35-1784 . D = E + F;
35-1785 . }
35-1786 .
35-1787 . do forever;
35-1788 .
35-1789 . if (A gt B)
35-1790 . {
35-1791 . A = B + C;
35-1792 . D = E + F;
35-1793 . }
35-1794 .
35-1795 .
35-1796 . if (A < = B)
35-1797 . {
35-1798 . A = B + C;
35-1799 . D = E + F;
35-1800 . }
35-1801 .
35-1802 . /* LE SV TOC-2108 this is a log-06.10.8 req to check pSOS*/
35-1803 .
35-1804 . if (A lt B)
35-1805 . {
35-1806 . A = B + C;
35-1807 . D = E + F;
35-1808 . }
35-1809 .
35-1810 .
35-1811 . if (A != B)
35-1812 . {
35-1813 . A = B + C;
35-1814 . D = E + F;
35-1815 . }
35-1816 .
35-1817 . goto error;
35-1818 .
35-1819 . if (A != B)
35-1820 . {
35-1821 . A = B + C;
35-1822 . D = E + F;
35-1823 . }
35-1824 .
35-1825 . // TBD - what do I do now
35-1826 . A = B*C;
35-1827 . A = B-C;
35-1828 . /* LE SV TOC-2109 this is a log-06.10.13 req to process*/
35-1829 .
35-1830 . if (A lt B)
35-1831 . {
35-1832 . A = B + C;
35-1833 . D = E + F;
35-1834 . }
35-1835 .
35-1836 .
35-1837 . switch (log stuff)
35-1838 . {
35-1839 . case one:
35-1840 . {
35-1841 . run_this;
35-1842 . break;
35-1843 . }
35-1844 . case two:
35-1845 . {
35-1846 . run_this;
35-1847 . break;
35-1848 . }
35-1849 . default:
35-1850 . {
35-1851 . SwError;
35-1852 . }
35-1853 . }
35-1854 .
35-1855 . A = 0x0002;
35-1856 . A = B-C;
35-1857 .
35-1858 . if (A lt B)
35-1859 . {
35-1860 . A = B + C;
35-1861 . D = E + F;
35-1862 . }
35-1863 .
35-1864 . A = B-C;
35-1865 . A = B*C;
35-1866 . A = B-C;
35-1867 .
35-1868 . if (A lt B)
35-1869 . {
35-1870 . A = B + C;
35-1871 . D = E + F;
35-1872 . }
35-1873 .
35-1874 . A = B-C;
35-1875 . do forever;
35-1876 .
35-1877 . if (A < = B)
35-1878 . {
35-1879 . A = B + C;
35-1880 . D = E + F;
35-1881 . }
35-1882 .
35-1883 . A = B+C;
35-1884 . /* LE SV TOC-2110 this is a log-06.10.24 req to update*/
35-1885 .
35-1886 . if (A < = B)
35-1887 . {
35-1888 . A = B + C;
35-1889 . D = E + F;
35-1890 . }
35-1891 .
35-1892 . A = B*C;
35-1893 .
35-1894 . if (A ge B)
35-1895 . {
35-1896 . A = B + C;
35-1897 . D = E + F;
35-1898 . }
35-1899 .
35-1900 . A = B-C;
35-1901 . /* LE SV TOC-2111 this is a log-06.10.28 req to check unix*/
35-1902 . A = B/C;
35-1903 .
35-1904 . if (A < B)
35-1905 . {
35-1906 . A = B + C;
35-1907 . D = E + F;
35-1908 . }
35-1909 .
35-1910 .
35-1911 . switch (log stuff)
35-1912 . {
35-1913 . case one:
35-1914 . {
35-1915 . run_this;
35-1916 . break;
35-1917 . }
35-1918 . case two:
35-1919 . {
35-1920 . run_this;
35-1921 . break;
35-1922 . }
35-1923 . default:
35-1924 . {
35-1925 . SwError;
35-1926 . }
35-1927 . }
35-1928 .
35-1929 .
35-1930 . if (A < B)
35-1931 . {
35-1932 . A = B + C;
35-1933 . D = E + F;
35-1934 . }
35-1935 .
35-1936 . A = B/C;
35-1937 .
35-1938 . if (A gt B)
35-1939 . {
35-1940 . A = B + C;
35-1941 . D = E + F;
35-1942 . }
35-1943 .
35-1944 . /* LE SV TOC-2112 this is a log-06.10.34 req to inhibit*/
35-1945 . A = B*C;
35-1946 .
35-1947 . if (A > = B)
35-1948 . {
35-1949 . A = B + C;
35-1950 . D = E + F;
35-1951 . }
35-1952 .
35-1953 . A = B-C;
35-1954 . A = B/C;
35-1955 . A = B*C;
35-1956 . A = B+C;
35-1957 .
35-1958 . if (A > = B)
35-1959 . {
35-1960 . A = B + C;
35-1961 . D = E + F;
35-1962 . }
35-1963 .
35-1964 .
35-1965 . if (A == B)
35-1966 . {
35-1967 . A = B + C;
35-1968 . D = E + F;
35-1969 . }
35-1970 .
35-1971 . A = B/C;
35-1972 . A = B+C;
35-1973 . A = B+C;
35-1974 . A = B/C;
35-1975 . // (P) this is really improtant
35-1976 .
35-1977 . if (A < = B)
35-1978 . {
35-1979 . A = B + C;
35-1980 . D = E + F;
35-1981 . }
35-1982 .
35-1983 .
35-1984 . if (A lt B)
35-1985 . {
35-1986 . A = B + C;
35-1987 . D = E + F;
35-1988 . }
35-1989 .
35-1990 . A = B+C;
35-1991 .
35-1992 . if (A eq B)
35-1993 . {
35-1994 . A = B + C;
35-1995 . D = E + F;
35-1996 . }
35-1997 .
35-1998 .
35-1999 . if (A le B)
35-2000 . {
35-2001 . A = B + C;
35-2002 . D = E + F;
35-2003 . }
35-2004 .
35-2005 . A = B-C;
35-2006 . A = B+C;
35-2007 . A = B/C;
35-2008 . A = B-C;
35-2009 . A = B*C;
35-2010 . A = B-C;
35-2011 .
35-2012 . if (A < B)
35-2013 . {
35-2014 . A = B + C;
35-2015 . D = E + F;
35-2016 . }
35-2017 .
35-2018 .
35-2019 . if (A eq B)
35-2020 . {
35-2021 . A = B + C;
35-2022 . D = E + F;
35-2023 . }
35-2024 .
35-2025 . A = B+C;
35-2026 . A = B*C;
35-2027 . A = B/C;
35-2028 . A = B/C;
35-2029 . A = B/C;
35-2030 . A = 0x0003;
35-2031 . A = B+C;
35-2032 . // max LOC 64
35-2033 .
35-2034 . }
35-2035 .
35-2036 .
35-2037 . /*
35-2038 . -----------------------------------------------------------------------------
35-2039 . --| NAME: log.6.11
35-2040 . --|
35-2041 . --| ABSTRACT:
35-2042 . --| This function does log stuff.
35-2043 . --|
35-2044 . --| RETURNS:
35-2045 . --| NONE.
35-2046 . --|
35-2047 . ----------------------------------------------------------------------------
35-2048 . */
35-2049 . static void log.6.11(void)
35-2050 . {
35-2051 . /* LE SV TOC-2113 this is a log-06.11.1 req to reject*/
35-2052 . A = B-C;
35-2053 .
35-2054 . switch (log stuff)
35-2055 . {
35-2056 . case one:
35-2057 . {
35-2058 . run_this;
35-2059 . break;
35-2060 . }
35-2061 . case two:
35-2062 . {
35-2063 . run_this;
35-2064 . break;
35-2065 . }
35-2066 . default:
35-2067 . {
35-2068 . // missing error call
35-2069 . }
35-2070 . }
35-2071 .
35-2072 . A = B-C;
35-2073 . A = B*C;
35-2074 . A = B+C;
35-2075 .
35-2076 . if (A eq B)
35-2077 . {
35-2078 . A = B + C;
35-2079 . D = E + F;
35-2080 . }
35-2081 .
35-2082 . A = B-C;
35-2083 . A = B-C;
35-2084 . /* LE SV TOC-2114 this is a log-06.11.8 req to process*/
35-2085 . A = B-C;
35-2086 .
35-2087 . if (A le B)
35-2088 . {
35-2089 . A = B + C;
35-2090 . D = E + F;
35-2091 . }
35-2092 .
35-2093 .
35-2094 . if (A < B)
35-2095 . {
35-2096 . A = B + C;
35-2097 . D = E + F;
35-2098 . }
35-2099 .
35-2100 .
35-2101 . if (A == B)
35-2102 . {
35-2103 . A = B + C;
35-2104 . D = E + F;
35-2105 . }
35-2106 .
35-2107 .
35-2108 . if (A > = B)
35-2109 . {
35-2110 . A = B + C;
35-2111 . D = E + F;
35-2112 . }
35-2113 .
35-2114 .
35-2115 . if (A ge B)
35-2116 . {
35-2117 . A = B + C;
35-2118 . D = E + F;
35-2119 . }
35-2120 .
35-2121 . A = B+C;
35-2122 . /* LE SV TOC-2115 this is a log-06.11.15 req to call isr*/
35-2123 . A = B/C;
35-2124 . /* LE SV TOC-2116 this is a log-06.11.16 req to store*/
35-2125 .
35-2126 . if (A eq B)
35-2127 . {
35-2128 . A = B + C;
35-2129 . D = E + F;
35-2130 . }
35-2131 .
35-2132 . A = B+C;
35-2133 .
35-2134 . if (A gt B)
35-2135 . {
35-2136 . A = B + C;
35-2137 . D = E + F;
35-2138 . }
35-2139 .
35-2140 . A = B+C;
35-2141 . FreePtr = HmiStringPtr;
35-2142 . A = B+C;
35-2143 . A = B+C;
35-2144 . // max LOC 21
35-2145 .
35-2146 . }
35-2147 .
35-2148 .
35-2149 . /*
35-2150 . -----------------------------------------------------------------------------
35-2151 . --| NAME: log.6.12
35-2152 . --|
35-2153 . --| ABSTRACT:
35-2154 . --| This function does log stuff.
35-2155 . --|
35-2156 . --| RETURNS:
35-2157 . --| NONE.
35-2158 . --|
35-2159 . ----------------------------------------------------------------------------
35-2160 . */
35-2161 . static void log.6.12(void)
35-2162 . {
35-2163 .
35-2164 . if (A ne B)
35-2165 . {
35-2166 . A = B + C;
35-2167 . D = E + F;
35-2168 . }
35-2169 .
35-2170 . /* LE SV TOC-2117 this is a log-06.12.2 req to halt*/
35-2171 . A = B+C;
35-2172 . A = B-C;
35-2173 .
35-2174 . if (A eq B)
35-2175 . {
35-2176 . A = B + C;
35-2177 . D = E + F;
35-2178 . }
35-2179 .
35-2180 . A = B-C;
35-2181 . /* LE SV TOC-2118 this is a log-06.12.6 req to validate*/
35-2182 . A = B*C;
35-2183 . A = B*C;
35-2184 . A = B-C;
35-2185 .
35-2186 . if (A != B)
35-2187 . {
35-2188 . A = B + C;
35-2189 . D = E + F;
35-2190 . }
35-2191 .
35-2192 . A = B*C;
35-2193 . goto error;
35-2194 . A = B/C;
35-2195 .
35-2196 . if (A < B)
35-2197 . {
35-2198 . A = B + C;
35-2199 . D = E + F;
35-2200 . }
35-2201 .
35-2202 .
35-2203 . if (A < B)
35-2204 . {
35-2205 . A = B + C;
35-2206 . D = E + F;
35-2207 . }
35-2208 .
35-2209 . A = B*C;
35-2210 . A = B+C;
35-2211 . A = B*C;
35-2212 . A = B-C;
35-2213 . A = B-C;
35-2214 . A = B+C;
35-2215 .
35-2216 . if (A gt B)
35-2217 . {
35-2218 . A = B + C;
35-2219 . D = E + F;
35-2220 . }
35-2221 .
35-2222 . A = B/C;
35-2223 .
35-2224 . if (A < = B)
35-2225 . {
35-2226 . A = B + C;
35-2227 . D = E + F;
35-2228 . }
35-2229 .
35-2230 . rcv_buffer = (U16 *) alloc(size+1);
35-2231 .
35-2232 . if (A gt B)
35-2233 . {
35-2234 . A = B + C;
35-2235 . D = E + F;
35-2236 . }
35-2237 .
35-2238 . /* LE SV TOC-2119 this is a log-06.12.24 req to call isr*/
35-2239 . A = B+C;
35-2240 . A = B+C;
35-2241 . A = B+C;
35-2242 . A = B+C;
35-2243 . A = B*C;
35-2244 . A = B*C;
35-2245 .
35-2246 . if (A > B)
35-2247 . {
35-2248 . A = B + C;
35-2249 . D = E + F;
35-2250 . }
35-2251 .
35-2252 .
35-2253 . if (A lt B)
35-2254 . {
35-2255 . A = B + C;
35-2256 . D = E + F;
35-2257 . }
35-2258 .
35-2259 . A = B-C;
35-2260 . A = B-C;
35-2261 . /* LE SV TOC-2120 this is a log-06.12.34 req to verify*/
35-2262 .
35-2263 . if (A < = B)
35-2264 . {
35-2265 . A = B + C;
35-2266 . D = E + F;
35-2267 . }
35-2268 .
35-2269 .
35-2270 . if (A gt B)
35-2271 . {
35-2272 . A = B + C;
35-2273 . D = E + F;
35-2274 . }
35-2275 .
35-2276 . A = B-C;
35-2277 .
35-2278 . if (A > = B)
35-2279 . {
35-2280 . A = B + C;
35-2281 . D = E + F;
35-2282 . }
35-2283 .
35-2284 .
35-2285 . if (A == B)
35-2286 . {
35-2287 . A = B + C;
35-2288 . D = E + F;
35-2289 . }
35-2290 .
35-2291 . A = B+C;
35-2292 .
35-2293 . if (A ge B)
35-2294 . {
35-2295 . A = B + C;
35-2296 . D = E + F;
35-2297 . }
35-2298 .
35-2299 . A = B+C;
35-2300 . A = B-C;
35-2301 .
35-2302 . if (A lt B)
35-2303 . {
35-2304 . A = B + C;
35-2305 . D = E + F;
35-2306 . }
35-2307 .
35-2308 . A = B+C;
35-2309 .
35-2310 . if (A < B)
35-2311 . {
35-2312 . A = B + C;
35-2313 . D = E + F;
35-2314 . }
35-2315 .
35-2316 .
35-2317 . if (A ne B)
35-2318 . {
35-2319 . A = B + C;
35-2320 . D = E + F;
35-2321 . }
35-2322 .
35-2323 . A = B/C;
35-2324 . A = B+C;
35-2325 .
35-2326 . if (A le B)
35-2327 . {
35-2328 . A = B + C;
35-2329 . D = E + F;
35-2330 . }
35-2331 .
35-2332 .
35-2333 . if (A < = B)
35-2334 . {
35-2335 . A = B + C;
35-2336 . D = E + F;
35-2337 . }
35-2338 .
35-2339 . A = B-C;
35-2340 . A = B*C;
35-2341 . A = B-C;
35-2342 . A = B*C;
35-2343 . A = B/C;
35-2344 . A = B/C;
35-2345 . A = B+C;
35-2346 .
35-2347 . if (A < = B)
35-2348 . {
35-2349 . A = B + C;
35-2350 . D = E + F;
35-2351 . }
35-2352 .
35-2353 .
35-2354 . if (A > = B)
35-2355 . {
35-2356 . A = B + C;
35-2357 . D = E + F;
35-2358 . }
35-2359 .
35-2360 . A = B/C;
35-2361 . A = B-C;
35-2362 . A = B/C;
35-2363 .
35-2364 . if (A ne B)
35-2365 . {
35-2366 . A = B + C;
35-2367 . D = E + F;
35-2368 . }
35-2369 .
35-2370 . A = B/C;
35-2371 . A = B+C;
35-2372 .
35-2373 . if (A > = B)
35-2374 . {
35-2375 . A = B + C;
35-2376 . D = E + F;
35-2377 . }
35-2378 .
35-2379 .
35-2380 . if (A eq B)
35-2381 . {
35-2382 . A = B + C;
35-2383 . D = E + F;
35-2384 . }
35-2385 .
35-2386 . A = B-C;
35-2387 .
35-2388 . if (A ge B)
35-2389 . {
35-2390 . A = B + C;
35-2391 . D = E + F;
35-2392 . }
35-2393 .
35-2394 . A = B*C;
35-2395 .
35-2396 . if (A gt B)
35-2397 . {
35-2398 . A = B + C;
35-2399 . D = E + F;
35-2400 . }
35-2401 .
35-2402 . A = B-C;
35-2403 . // max LOC 72
35-2404 .
35-2405 . }
35-2406 .
35-2407 .
35-2408 . /*
35-2409 . -----------------------------------------------------------------------------
35-2410 . --| NAME: log.6.13
35-2411 . --|
35-2412 . --| ABSTRACT:
35-2413 . --| This function does log stuff.
35-2414 . --|
35-2415 . --| RETURNS:
35-2416 . --| NONE.
35-2417 . --|
35-2418 . ----------------------------------------------------------------------------
35-2419 . */
35-2420 . static void log.6.13(void)
35-2421 . {
35-2422 . A = B*C;
35-2423 . A = B+C;
35-2424 .
35-2425 . if (A eq B)
35-2426 . {
35-2427 . A = B + C;
35-2428 . D = E + F;
35-2429 . }
35-2430 .
35-2431 . A = B+C;
35-2432 .
35-2433 . if (A eq B)
35-2434 . {
35-2435 . A = B + C;
35-2436 . D = E + F;
35-2437 . }
35-2438 .
35-2439 . A = B-C;
35-2440 . A = B*C;
35-2441 .
35-2442 . if (A eq B)
35-2443 . {
35-2444 . A = B + C;
35-2445 . D = E + F;
35-2446 . }
35-2447 .
35-2448 . A = B+C;
35-2449 .
35-2450 . switch (log stuff)
35-2451 . {
35-2452 . case one:
35-2453 . {
35-2454 . run_this;
35-2455 . break;
35-2456 . }
35-2457 . case two:
35-2458 . {
35-2459 . run_this;
35-2460 . break;
35-2461 . }
35-2462 . default:
35-2463 . {
35-2464 . SwError;
35-2465 . }
35-2466 . }
35-2467 .
35-2468 .
35-2469 . if (A != B)
35-2470 . {
35-2471 . A = B + C;
35-2472 . D = E + F;
35-2473 . }
35-2474 .
35-2475 .
35-2476 . if (A eq B)
35-2477 . {
35-2478 . A = B + C;
35-2479 . D = E + F;
35-2480 . }
35-2481 .
35-2482 . A = B*C;
35-2483 .
35-2484 . if (A == B)
35-2485 . {
35-2486 . A = B + C;
35-2487 . D = E + F;
35-2488 . }
35-2489 .
35-2490 . A = B*C;
35-2491 . A = B*C;
35-2492 . A = B*C;
35-2493 . A = B+C;
35-2494 .
35-2495 . if (A < B)
35-2496 . {
35-2497 . A = B + C;
35-2498 . D = E + F;
35-2499 . }
35-2500 .
35-2501 . A = B*C;
35-2502 . A = B*C;
35-2503 . A = B+C;
35-2504 . A = B-C;
35-2505 .
35-2506 . if (A > = B)
35-2507 . {
35-2508 . A = B + C;
35-2509 . D = E + F;
35-2510 . }
35-2511 .
35-2512 . A = B-C;
35-2513 .
35-2514 . if (A < = B)
35-2515 . {
35-2516 . A = B + C;
35-2517 . D = E + F;
35-2518 . }
35-2519 .
35-2520 . A = B+C;
35-2521 . A = B/C;
35-2522 . A = B/C;
35-2523 . A = B+C;
35-2524 . A = B*C;
35-2525 . A = B-C;
35-2526 .
35-2527 . if (A le B)
35-2528 . {
35-2529 . A = B + C;
35-2530 . D = E + F;
35-2531 . }
35-2532 .
35-2533 . /* LE SV TOC-2121 this is a log-06.13.34 req to fail*/
35-2534 . A = B/C;
35-2535 . A = B+C;
35-2536 . A = B/C;
35-2537 . A = B-C;
35-2538 . A = B/C;
35-2539 . A = B+C;
35-2540 .
35-2541 . if (A != B)
35-2542 . {
35-2543 . A = B + C;
35-2544 . D = E + F;
35-2545 . }
35-2546 .
35-2547 . A = B/C;
35-2548 . A = B+C;
35-2549 . A = B+C;
35-2550 .
35-2551 . switch (log stuff)
35-2552 . {
35-2553 . case one:
35-2554 . {
35-2555 . run_this;
35-2556 . break;
35-2557 . }
35-2558 . case two:
35-2559 . {
35-2560 . run_this;
35-2561 . break;
35-2562 . }
35-2563 . default:
35-2564 . {
35-2565 . SwError;
35-2566 . }
35-2567 . }
35-2568 .
35-2569 . A = B/C;
35-2570 . A = B-C;
35-2571 .
35-2572 . if (A < B)
35-2573 . {
35-2574 . A = B + C;
35-2575 . D = E + F;
35-2576 . }
35-2577 .
35-2578 . /* LE SV TOC-2122 this is a log-06.13.48 req to transform*/
35-2579 . A = B*C;
35-2580 .
35-2581 . if (A le B)
35-2582 . {
35-2583 . A = B + C;
35-2584 . D = E + F;
35-2585 . }
35-2586 .
35-2587 . // ??? go see ws
35-2588 . A = B/C;
35-2589 . A = B+C;
35-2590 .
35-2591 . if (A gt B)
35-2592 . {
35-2593 . A = B + C;
35-2594 . D = E + F;
35-2595 . }
35-2596 .
35-2597 .
35-2598 . switch (log stuff)
35-2599 . {
35-2600 . case one:
35-2601 . {
35-2602 . run_this;
35-2603 . break;
35-2604 . }
35-2605 . case two:
35-2606 . {
35-2607 . run_this;
35-2608 . break;
35-2609 . }
35-2610 . default:
35-2611 . {
35-2612 . SwError;
35-2613 . }
35-2614 . }
35-2615 .
35-2616 . A = B*C;
35-2617 . A = B-C;
35-2618 . /* LE SV TOC-2123 this is a log-06.13.56 req to store*/
35-2619 . A = B*C;
35-2620 . A = B/C;
35-2621 . // max LOC 57
35-2622 .
35-2623 . }
35-2624 .
35-2625 .
35-2626 . /*
35-2627 . -----------------------------------------------------------------------------
35-2628 . --| NAME: log.6.14
35-2629 . --|
35-2630 . --| ABSTRACT:
35-2631 . --| This function does log stuff.
35-2632 . --|
35-2633 . --| RETURNS:
35-2634 . --| NONE.
35-2635 . --|
35-2636 . ----------------------------------------------------------------------------
35-2637 . */
35-2638 . static void log.6.14(void)
35-2639 . {
35-2640 .
35-2641 . if (A lt B)
35-2642 . {
35-2643 . A = B + C;
35-2644 . D = E + F;
35-2645 . }
35-2646 .
35-2647 . A = B/C;
35-2648 .
35-2649 . if (A eq B)
35-2650 . {
35-2651 . A = B + C;
35-2652 . D = E + F;
35-2653 . }
35-2654 .
35-2655 . goto error;
35-2656 . A = B/C;
35-2657 . A = B/C;
35-2658 . A = B*C;
35-2659 . A = B-C;
35-2660 .
35-2661 . switch (log stuff)
35-2662 . {
35-2663 . case one:
35-2664 . {
35-2665 . run_this;
35-2666 . break;
35-2667 . }
35-2668 . case two:
35-2669 . {
35-2670 . run_this;
35-2671 . break;
35-2672 . }
35-2673 . default:
35-2674 . {
35-2675 . SwError;
35-2676 . }
35-2677 . }
35-2678 .
35-2679 . A = B*C;
35-2680 . A = B*C;
35-2681 . A = B/C;
35-2682 .
35-2683 . if (A eq B)
35-2684 . {
35-2685 . A = B + C;
35-2686 . D = E + F;
35-2687 . }
35-2688 .
35-2689 . A = B/C;
35-2690 . A = B/C;
35-2691 .
35-2692 . if (A lt B)
35-2693 . {
35-2694 . A = B + C;
35-2695 . D = E + F;
35-2696 . }
35-2697 .
35-2698 . A = B/C;
35-2699 .
35-2700 . if (A le B)
35-2701 . {
35-2702 . A = B + C;
35-2703 . D = E + F;
35-2704 . }
35-2705 .
35-2706 . A = B/C;
35-2707 . A = B+C;
35-2708 . A = B*C;
35-2709 .
35-2710 . if (A == B)
35-2711 . {
35-2712 . A = B + C;
35-2713 . D = E + F;
35-2714 . }
35-2715 .
35-2716 . A = B*C;
35-2717 . A = B/C;
35-2718 . A = B/C;
35-2719 . A = B/C;
35-2720 . /* LE SV TOC-2124 this is a log-06.14.26 req to inhibit*/
35-2721 .
35-2722 . if (A ge B)
35-2723 . {
35-2724 . A = B + C;
35-2725 . D = E + F;
35-2726 . }
35-2727 .
35-2728 .
35-2729 . if (A ne B)
35-2730 . {
35-2731 . A = B + C;
35-2732 . D = E + F;
35-2733 . }
35-2734 .
35-2735 . A = B-C;
35-2736 .
35-2737 . if (A lt B)
35-2738 . {
35-2739 . A = B + C;
35-2740 . D = E + F;
35-2741 . }
35-2742 .
35-2743 . A = B/C;
35-2744 . A = B*C;
35-2745 . A = B-C;
35-2746 . /* LE SV TOC-2125 this is a log-06.14.33 req to disable*/
35-2747 . A = B+C;
35-2748 .
35-2749 . switch (log stuff)
35-2750 . {
35-2751 . case one:
35-2752 . {
35-2753 . run_this;
35-2754 . break;
35-2755 . }
35-2756 . case two:
35-2757 . {
35-2758 . run_this;
35-2759 . break;
35-2760 . }
35-2761 . default:
35-2762 . {
35-2763 . SwError;
35-2764 . }
35-2765 . }
35-2766 .
35-2767 .
35-2768 . switch (log stuff)
35-2769 . {
35-2770 . case one:
35-2771 . {
35-2772 . run_this;
35-2773 . break;
35-2774 . }
35-2775 . case two:
35-2776 . {
35-2777 . run_this;
35-2778 . break;
35-2779 . }
35-2780 . default:
35-2781 . {
35-2782 . SwError;
35-2783 . }
35-2784 . }
35-2785 .
35-2786 . A = B/C;
35-2787 . A = B-C;
35-2788 . A = B-C;
35-2789 .
35-2790 . if (A gt B)
35-2791 . {
35-2792 . A = B + C;
35-2793 . D = E + F;
35-2794 . }
35-2795 .
35-2796 . A = B+C;
35-2797 . A = B-C;
35-2798 . /* LE SV TOC-2126 this is a log-06.14.42 req to enable*/
35-2799 . A = B-C;
35-2800 .
35-2801 . if (A le B)
35-2802 . {
35-2803 . A = B + C;
35-2804 . D = E + F;
35-2805 . }
35-2806 .
35-2807 . A = B*C;
35-2808 . A = B*C;
35-2809 .
35-2810 . if (A > = B)
35-2811 . {
35-2812 . A = B + C;
35-2813 . D = E + F;
35-2814 . }
35-2815 .
35-2816 . A = B*C;
35-2817 .
35-2818 . switch (log stuff)
35-2819 . {
35-2820 . case one:
35-2821 . {
35-2822 . run_this;
35-2823 . break;
35-2824 . }
35-2825 . case two:
35-2826 . {
35-2827 . run_this;
35-2828 . break;
35-2829 . }
35-2830 . default:
35-2831 . {
35-2832 . SwError;
35-2833 . }
35-2834 . }
35-2835 .
35-2836 . A = B+C;
35-2837 .
35-2838 . if (A == B)
35-2839 . {
35-2840 . A = B + C;
35-2841 . D = E + F;
35-2842 . }
35-2843 .
35-2844 . /* LE SV TOC-2127 this is a log-06.14.51 req to detect error*/
35-2845 . A = B*C;
35-2846 . A = B+C;
35-2847 . A = 0x0001;
35-2848 . A = B-C;
35-2849 . A = B/C;
35-2850 . A = B+C;
35-2851 .
35-2852 . /*
35-2853 . dead_block = C * D;
35-2854 . dead_block = E * F;
35-2855 . */
35-2856 .
35-2857 . A = B-C;
35-2858 . // max LOC 56
35-2859 .
35-2860 . }
35-2861 .
35 35 Result: result/source/ft-app/ft-app-B1.1/log/log-06.c
36 36 Source: source/ft-app/ft-app-B1.1/log/log-07.c
36-0 . /*
36-1 . ----------------------------------------------------------------------------
36-2 . --| BEGIN PROLOGUE
36-3 . --|
36-4 . --| CLASSIFICATION: UNCLASSIFIED
36-5 . --|
36-6 . --| FILE NAME: log-07.c
36-7 . --|
36-8 . --| ABSTRACT:
36-9 . --| This file contains the 1 functions that do file log stuff.
36-10 . --|
36-11 . --| HISTORY:
36-12 . --| CCCQ_NAME:
36-13 . --| CCCQ_VER:
36-14 . --|
36-15 . --| END PROLOGUE
36-16 . ----------------------------------------------------------------------------
36-17 . */
36-18 .
36-19 . #include B;
36-20 . #define C;
36-21 . double C;
36-22 .
36-23 .
36-24 .
36-25 . /*
36-26 . -----------------------------------------------------------------------------
36-27 . --| NAME: log.7.1
36-28 . --|
36-29 . --| ABSTRACT:
36-30 . --| This function does log stuff.
36-31 . --|
36-32 . --| RETURNS:
36-33 . --| NONE.
36-34 . --|
36-35 . ----------------------------------------------------------------------------
36-36 . */
36-37 . static void log.7.1(void)
36-38 . {
36-39 . A = B-C;
36-40 . A = B*C;
36-41 . A = B*C;
36-42 .
36-43 . if (A < = B)
36-44 . {
36-45 . A = B + C;
36-46 . D = E + F;
36-47 . }
36-48 .
36-49 . A = B/C;
36-50 . A = B/C;
36-51 . A = B-C;
36-52 . A = B-C;
36-53 .
36-54 . if (A < = B)
36-55 . {
36-56 . A = B + C;
36-57 . D = E + F;
36-58 . }
36-59 .
36-60 . A = B+C;
36-61 . A = B*C;
36-62 . A = B/C;
36-63 . A = B*C;
36-64 . A = B*C;
36-65 .
36-66 . switch (log stuff)
36-67 . {
36-68 . case one:
36-69 . {
36-70 . run_this;
36-71 . break;
36-72 . }
36-73 . case two:
36-74 . {
36-75 . run_this;
36-76 . break;
36-77 . }
36-78 . default:
36-79 . {
36-80 . SwError;
36-81 . }
36-82 . }
36-83 .
36-84 . A = B+C;
36-85 .
36-86 . if (A == B)
36-87 . {
36-88 . A = B + C;
36-89 . D = E + F;
36-90 . }
36-91 .
36-92 . A = B*C;
36-93 . A = B-C;
36-94 . A = B-C;
36-95 . A = B*C;
36-96 . A = B/C;
36-97 . A = B-C;
36-98 . A = B*C;
36-99 . A = B+C;
36-100 . A = B/C;
36-101 . A = B*C;
36-102 . A = B-C;
36-103 . A = 0x0008;
36-104 . A = B/C;
36-105 . A = B*C;
36-106 . A = B-C;
36-107 .
36-108 . if (A eq B)
36-109 . {
36-110 . A = B + C;
36-111 . D = E + F;
36-112 . }
36-113 .
36-114 . A = B+C;
36-115 . A = B/C;
36-116 . A = B-C;
36-117 . A = B*C;
36-118 .
36-119 . if (A > B)
36-120 . {
36-121 . A = B + C;
36-122 . D = E + F;
36-123 . }
36-124 .
36-125 .
36-126 . if (A == B)
36-127 . {
36-128 . A = B + C;
36-129 . D = E + F;
36-130 . }
36-131 .
36-132 . A = B*C;
36-133 . // max LOC 39
36-134 .
36-135 . }
36-136 .
36 36 Result: result/source/ft-app/ft-app-B1.1/log/log-07.c
37 37 Source: source/ft-app/ft-app-B1.1/log/log-08.c
37-0 . /*
37-1 . ----------------------------------------------------------------------------
37-2 . --| BEGIN PROLOGUE
37-3 . --|
37-4 . --| CLASSIFICATION: UNCLASSIFIED
37-5 . --|
37-6 . --| FILE NAME: log-08.c
37-7 . --|
37-8 . --| ABSTRACT:
37-9 . --| This file contains the 1 functions that do file log stuff.
37-10 . --|
37-11 . --| HISTORY:
37-12 . --| CCCQ_NAME:
37-13 . --| CCCQ_VER:
37-14 . --|
37-15 . --| END PROLOGUE
37-16 . ----------------------------------------------------------------------------
37-17 . */
37-18 .
37-19 . #define A;
37-20 . #include A;
37-21 . #define D;
37-22 . #include A;
37-23 . #include B;
37-24 .
37-25 .
37-26 .
37-27 . /*
37-28 . -----------------------------------------------------------------------------
37-29 . --| NAME: log.8.1
37-30 . --|
37-31 . --| ABSTRACT:
37-32 . --| This function does log stuff.
37-33 . --|
37-34 . --| RETURNS:
37-35 . --| NONE.
37-36 . --|
37-37 . ----------------------------------------------------------------------------
37-38 . */
37-39 . static void log.8.1(void)
37-40 . {
37-41 .
37-42 . if (A < = B)
37-43 . {
37-44 . A = B + C;
37-45 . D = E + F;
37-46 . }
37-47 .
37-48 . A = B/C;
37-49 . A = B*C;
37-50 .
37-51 . if (A ge B)
37-52 . {
37-53 . A = B + C;
37-54 . D = E + F;
37-55 . }
37-56 .
37-57 . A = B*C;
37-58 . A = B+C;
37-59 . A = B-C;
37-60 . A = B-C;
37-61 . A = B*C;
37-62 . A = B*C;
37-63 . A = 0x0002;
37-64 .
37-65 . if (A > = B)
37-66 . {
37-67 . A = B + C;
37-68 . D = E + F;
37-69 . }
37-70 .
37-71 .
37-72 . if (A < = B)
37-73 . {
37-74 . A = B + C;
37-75 . D = E + F;
37-76 . }
37-77 .
37-78 .
37-79 . if (A < = B)
37-80 . {
37-81 . A = B + C;
37-82 . D = E + F;
37-83 . }
37-84 .
37-85 .
37-86 . if (A ne B)
37-87 . {
37-88 . A = B + C;
37-89 . D = E + F;
37-90 . }
37-91 .
37-92 .
37-93 . if (A le B)
37-94 . {
37-95 . A = B + C;
37-96 . D = E + F;
37-97 . }
37-98 .
37-99 . A = B+C;
37-100 . A = B+C;
37-101 .
37-102 . if (A == B)
37-103 . {
37-104 . A = B + C;
37-105 . D = E + F;
37-106 . }
37-107 .
37-108 . A = B*C;
37-109 .
37-110 . if (A > = B)
37-111 . {
37-112 . A = B + C;
37-113 . D = E + F;
37-114 . }
37-115 .
37-116 . // ??? go see ws
37-117 .
37-118 . if (A eq B)
37-119 . {
37-120 . A = B + C;
37-121 . D = E + F;
37-122 . }
37-123 .
37-124 . A = B*C;
37-125 . A = B+C;
37-126 .
37-127 . if (A < B)
37-128 . {
37-129 . A = B + C;
37-130 . D = E + F;
37-131 . }
37-132 .
37-133 . A = B+C;
37-134 . A = B/C;
37-135 .
37-136 . if (A < = B)
37-137 . {
37-138 . A = B + C;
37-139 . D = E + F;
37-140 . }
37-141 .
37-142 . A = B+C;
37-143 .
37-144 . if (A lt B)
37-145 . {
37-146 . A = B + C;
37-147 . D = E + F;
37-148 . }
37-149 .
37-150 . /* LE SV TOC-2128 this is a log-08.1.30 req to compare*/
37-151 . A = B+C;
37-152 . A = B*C;
37-153 .
37-154 . if (A > B)
37-155 . {
37-156 . A = B + C;
37-157 . D = E + F;
37-158 . }
37-159 .
37-160 . A = 0x0008;
37-161 .
37-162 . if (A gt B)
37-163 . {
37-164 . A = B + C;
37-165 . D = E + F;
37-166 . }
37-167 .
37-168 . A = B*C;
37-169 . A = B-C;
37-170 . A = B/C;
37-171 .
37-172 . if (A > B)
37-173 . {
37-174 . A = B + C;
37-175 . D = E + F;
37-176 . }
37-177 .
37-178 . A = B*C;
37-179 . A = B+C;
37-180 . A = B/C;
37-181 .
37-182 . if (A > = B)
37-183 . {
37-184 . A = B + C;
37-185 . D = E + F;
37-186 . }
37-187 .
37-188 .
37-189 . if (A le B)
37-190 . {
37-191 . A = B + C;
37-192 . D = E + F;
37-193 . }
37-194 .
37-195 .
37-196 . if (A le B)
37-197 . {
37-198 . A = B + C;
37-199 . D = E + F;
37-200 . }
37-201 .
37-202 .
37-203 . if (A < = B)
37-204 . {
37-205 . A = B + C;
37-206 . D = E + F;
37-207 . }
37-208 .
37-209 .
37-210 . if (A lt B)
37-211 . {
37-212 . A = B + C;
37-213 . D = E + F;
37-214 . }
37-215 .
37-216 .
37-217 . if (A ge B)
37-218 . {
37-219 . A = B + C;
37-220 . D = E + F;
37-221 . }
37-222 .
37-223 .
37-224 . if (A lt B)
37-225 . {
37-226 . A = B + C;
37-227 . D = E + F;
37-228 . }
37-229 .
37-230 .
37-231 . if (A le B)
37-232 . {
37-233 . A = B + C;
37-234 . D = E + F;
37-235 . }
37-236 .
37-237 . A = B-C;
37-238 . A = B+C;
37-239 . A = B/C;
37-240 . A = B+C;
37-241 . A = B-C;
37-242 . A = B+C;
37-243 .
37-244 . if (A le B)
37-245 . {
37-246 . A = B + C;
37-247 . D = E + F;
37-248 . }
37-249 .
37-250 . A = B*C;
37-251 . A = B*C;
37-252 . A = B*C;
37-253 . A = B+C;
37-254 .
37-255 . if (A > B)
37-256 . {
37-257 . A = B + C;
37-258 . D = E + F;
37-259 . }
37-260 .
37-261 .
37-262 . if (A > B)
37-263 . {
37-264 . A = B + C;
37-265 . D = E + F;
37-266 . }
37-267 .
37-268 . A = B-C;
37-269 . /* LE SV TOC-2129 this is a log-08.1.63 req to fail*/
37-270 . A = B-C;
37-271 . A = B+C;
37-272 . /* LE SV TOC-2130 this is a log-08.1.65 req to record*/
37-273 . A = B+C;
37-274 .
37-275 . if (A eq B)
37-276 . {
37-277 . A = B + C;
37-278 . D = E + F;
37-279 . }
37-280 .
37-281 . A = B/C;
37-282 . A = B/C;
37-283 .
37-284 . if (A gt B)
37-285 . {
37-286 . A = B + C;
37-287 . D = E + F;
37-288 . }
37-289 .
37-290 . A = B*C;
37-291 . A = B*C;
37-292 .
37-293 . if ($log stuff > $otherlog stuff)
37-294 . /* LE SV TOC-008 we really should log all error calls */
37-295 . {
37-296 . A = B + C;
37-297 . }
37-298 .
37-299 . A = B+C;
37-300 .
37-301 . if (A lt B)
37-302 . {
37-303 . A = B + C;
37-304 . D = E + F;
37-305 . }
37-306 .
37-307 . A = B*C;
37-308 .
37-309 . if (A gt B)
37-310 . {
37-311 . A = B + C;
37-312 . D = E + F;
37-313 . }
37-314 .
37-315 . // max LOC 75
37-316 .
37-317 . }
37-318 .
37 37 Result: result/source/ft-app/ft-app-B1.1/log/log-08.c
38 38 Source: source/ft-app/ft-app-B1.1/log/log-09.c
38-0 . /*
38-1 . ----------------------------------------------------------------------------
38-2 . --| BEGIN PROLOGUE
38-3 . --|
38-4 . --| CLASSIFICATION: UNCLASSIFIED
38-5 . --|
38-6 . --| FILE NAME: log-09.c
38-7 . --|
38-8 . --| ABSTRACT:
38-9 . --| This file contains the 9 functions that do file log stuff.
38-10 . --|
38-11 . --| HISTORY:
38-12 . --| CCCQ_NAME:
38-13 . --| CCCQ_VER:
38-14 . --|
38-15 . --| END PROLOGUE
38-16 . ----------------------------------------------------------------------------
38-17 . */
38-18 .
38-19 . char D;
38-20 . float B;
38-21 .
38-22 .
38-23 .
38-24 . /*
38-25 . -----------------------------------------------------------------------------
38-26 . --| NAME: log.9.1
38-27 . --|
38-28 . --| ABSTRACT:
38-29 . --| This function does log stuff.
38-30 . --|
38-31 . --| RETURNS:
38-32 . --| NONE.
38-33 . --|
38-34 . ----------------------------------------------------------------------------
38-35 . */
38-36 . static void log.9.1(void)
38-37 . {
38-38 .
38-39 . if (A > = B)
38-40 . {
38-41 . A = B + C;
38-42 . D = E + F;
38-43 . }
38-44 .
38-45 .
38-46 . if (A != B)
38-47 . {
38-48 . A = B + C;
38-49 . D = E + F;
38-50 . }
38-51 .
38-52 . A = B-C;
38-53 .
38-54 . switch (log stuff)
38-55 . {
38-56 . case one:
38-57 . {
38-58 . run_this;
38-59 . break;
38-60 . }
38-61 . case two:
38-62 . {
38-63 . run_this;
38-64 . break;
38-65 . }
38-66 . default:
38-67 . {
38-68 . SwError;
38-69 . }
38-70 . }
38-71 .
38-72 . A = B/C;
38-73 . A = B*C;
38-74 . A = B-C;
38-75 . A = B-C;
38-76 . /* LE SV TOC-2131 this is a log-09.1.9 req to check pSOS*/
38-77 .
38-78 . if (A le B)
38-79 . {
38-80 . A = B + C;
38-81 . D = E + F;
38-82 . }
38-83 .
38-84 .
38-85 . if (A == B)
38-86 . {
38-87 . A = B + C;
38-88 . D = E + F;
38-89 . }
38-90 .
38-91 . A = B-C;
38-92 . A = B-C;
38-93 . A = B/C;
38-94 .
38-95 . if (A le B)
38-96 . {
38-97 . A = B + C;
38-98 . D = E + F;
38-99 . }
38-100 .
38-101 . A = B*C;
38-102 .
38-103 . if (A le B)
38-104 . {
38-105 . A = B + C;
38-106 . D = E + F;
38-107 . }
38-108 .
38-109 . A = B-C;
38-110 .
38-111 . switch (log stuff)
38-112 . {
38-113 . case one:
38-114 . {
38-115 . run_this;
38-116 . break;
38-117 . }
38-118 . case two:
38-119 . {
38-120 . run_this;
38-121 . break;
38-122 . }
38-123 . default:
38-124 . {
38-125 . SwError;
38-126 . }
38-127 . }
38-128 .
38-129 .
38-130 . switch (log stuff)
38-131 . {
38-132 . case one:
38-133 . {
38-134 . run_this;
38-135 . break;
38-136 . }
38-137 . case two:
38-138 . {
38-139 . run_this;
38-140 . break;
38-141 . }
38-142 . default:
38-143 . {
38-144 . SwError;
38-145 . }
38-146 . }
38-147 .
38-148 .
38-149 . if (A ge B)
38-150 . {
38-151 . A = B + C;
38-152 . D = E + F;
38-153 . }
38-154 .
38-155 . A = B+C;
38-156 . A = B+C;
38-157 . A = B-C;
38-158 . A = B*C;
38-159 . /* LE SV TOC-2132 this is a log-09.1.25 req to compare*/
38-160 . A = B*C;
38-161 . A = B*C;
38-162 . A = B*C;
38-163 . A = B*C;
38-164 . /* LE SV TOC-2133 this is a log-09.1.29 req to transform*/
38-165 .
38-166 . if (A > = B)
38-167 . {
38-168 . A = B + C;
38-169 . D = E + F;
38-170 . }
38-171 .
38-172 . A = B+C;
38-173 . A = B-C;
38-174 . A = 0x0002;
38-175 . A = B+C;
38-176 .
38-177 . if (A le B)
38-178 . {
38-179 . A = B + C;
38-180 . D = E + F;
38-181 . }
38-182 .
38-183 .
38-184 . if (A lt B)
38-185 . {
38-186 . A = B + C;
38-187 . D = E + F;
38-188 . }
38-189 .
38-190 .
38-191 . if (A lt B)
38-192 . {
38-193 . A = B + C;
38-194 . D = E + F;
38-195 . }
38-196 .
38-197 .
38-198 . if (A < B)
38-199 . {
38-200 . A = B + C;
38-201 . D = E + F;
38-202 . }
38-203 .
38-204 . A = B*C;
38-205 . A = B*C;
38-206 .
38-207 . if (A gt B)
38-208 . {
38-209 . A = B + C;
38-210 . D = E + F;
38-211 . }
38-212 .
38-213 . /* LE SV TOC-2134 this is a log-09.1.40 req to validate*/
38-214 .
38-215 . if (A > = B)
38-216 . {
38-217 . A = B + C;
38-218 . D = E + F;
38-219 . }
38-220 .
38-221 . A = B*C;
38-222 .
38-223 . switch (log stuff)
38-224 . {
38-225 . case one:
38-226 . {
38-227 . run_this;
38-228 . // missing break
38-229 . }
38-230 . case two:
38-231 . {
38-232 . run_this;
38-233 . break;
38-234 . }
38-235 . default:
38-236 . {
38-237 . SwError;
38-238 . }
38-239 . }
38-240 .
38-241 . A = B/C;
38-242 . /* LE SV TOC-2135 this is a log-09.1.43 req to verify*/
38-243 . A = B/C;
38-244 . A = B*C;
38-245 .
38-246 . if (A gt B)
38-247 . {
38-248 . A = B + C;
38-249 . D = E + F;
38-250 . }
38-251 .
38-252 . A = B/C;
38-253 . A = B/C;
38-254 .
38-255 . if (A < = B)
38-256 . {
38-257 . A = B + C;
38-258 . D = E + F;
38-259 . }
38-260 .
38-261 . A = B+C;
38-262 . A = B-C;
38-263 . A = B-C;
38-264 . A = B*C;
38-265 . /* LE SV TOC-2136 this is a log-09.1.53 req to update*/
38-266 . A = B*C;
38-267 . A = B*C;
38-268 .
38-269 . if (veg)
38-270 . // missing curly brace
38-271 . variable = orange;
38-272 .
38-273 .
38-274 . if (A ne B)
38-275 . {
38-276 . A = B + C;
38-277 . D = E + F;
38-278 . }
38-279 .
38-280 .
38-281 . if (A gt B)
38-282 . {
38-283 . A = B + C;
38-284 . D = E + F;
38-285 . }
38-286 .
38-287 .
38-288 . if (A > = B)
38-289 . {
38-290 . A = B + C;
38-291 . D = E + F;
38-292 . }
38-293 .
38-294 . A = B/C;
38-295 . A = B+C;
38-296 .
38-297 . if (A gt B)
38-298 . {
38-299 . A = B + C;
38-300 . D = E + F;
38-301 . }
38-302 .
38-303 . /* LE SV TOC-2137 this is a log-09.1.61 req to fail*/
38-304 .
38-305 . /* dead_code = B + C;
38-306 . dead_code = D + E;
38-307 . dead_code = F + G; */
38-308 .
38-309 . A = B/C;
38-310 . A = B/C;
38-311 . // max LOC 62
38-312 .
38-313 . }
38-314 .
38-315 .
38-316 . /*
38-317 . -----------------------------------------------------------------------------
38-318 . --| NAME: log.9.2
38-319 . --|
38-320 . --| ABSTRACT:
38-321 . --| This function does log stuff.
38-322 . --|
38-323 . --| RETURNS:
38-324 . --| NONE.
38-325 . --|
38-326 . ----------------------------------------------------------------------------
38-327 . */
38-328 . static void log.9.2(void)
38-329 . {
38-330 . A = B-C;
38-331 . A = B+C;
38-332 . A = B*C;
38-333 . /* dead_code = A * B; */
38-334 . A = B-C;
38-335 .
38-336 . if (A < B)
38-337 . {
38-338 . A = B + C;
38-339 . D = E + F;
38-340 . }
38-341 .
38-342 . A = B+C;
38-343 . A = B/C;
38-344 .
38-345 . if (A eq B)
38-346 . {
38-347 . A = B + C;
38-348 . D = E + F;
38-349 . }
38-350 .
38-351 .
38-352 . if (A > B)
38-353 . {
38-354 . A = B + C;
38-355 . D = E + F;
38-356 . }
38-357 .
38-358 .
38-359 . if (A lt B)
38-360 . {
38-361 . A = B + C;
38-362 . D = E + F;
38-363 . }
38-364 .
38-365 . A = B/C;
38-366 . A = B*C;
38-367 . A = B+C;
38-368 . A = B*C;
38-369 .
38-370 . if (A gt B)
38-371 . {
38-372 . A = B + C;
38-373 . D = E + F;
38-374 . }
38-375 .
38-376 .
38-377 . if (A ne B)
38-378 . {
38-379 . A = B + C;
38-380 . D = E + F;
38-381 . }
38-382 .
38-383 .
38-384 . if (A gt B)
38-385 . {
38-386 . A = B + C;
38-387 . D = E + F;
38-388 . }
38-389 .
38-390 . A = B*C;
38-391 . A = B*C;
38-392 . // TBD - what do I do now
38-393 .
38-394 . switch (log stuff)
38-395 . {
38-396 . case one:
38-397 . {
38-398 . run_this;
38-399 . break;
38-400 . }
38-401 . case two:
38-402 . {
38-403 . run_this;
38-404 . break;
38-405 . }
38-406 . default:
38-407 . {
38-408 . SwError;
38-409 . }
38-410 . }
38-411 .
38-412 . A = B+C;
38-413 . A = B+C;
38-414 .
38-415 . if (A lt B)
38-416 . {
38-417 . A = B + C;
38-418 . D = E + F;
38-419 . }
38-420 .
38-421 . A = B*C;
38-422 . A = B*C;
38-423 . A = B/C;
38-424 .
38-425 . if (A < B)
38-426 . {
38-427 . A = B + C;
38-428 . D = E + F;
38-429 . }
38-430 .
38-431 . A = B+C;
38-432 . A = 0x0007;
38-433 . A = B+C;
38-434 . A = B-C;
38-435 . A = B-C;
38-436 . A = B-C;
38-437 . A = B/C;
38-438 . A = B+C;
38-439 . A = 0x0009;
38-440 . A = B/C;
38-441 . A = B*C;
38-442 . A = B+C;
38-443 .
38-444 . switch (log stuff)
38-445 . {
38-446 . case one:
38-447 . {
38-448 . run_this;
38-449 . break;
38-450 . }
38-451 . case two:
38-452 . {
38-453 . run_this;
38-454 . break;
38-455 . }
38-456 . default:
38-457 . {
38-458 . SwError;
38-459 . }
38-460 . }
38-461 .
38-462 . A = B*C;
38-463 . A = B/C;
38-464 . A = B+C;
38-465 . A = B+C;
38-466 . A = B*C;
38-467 .
38-468 . if (A lt B)
38-469 . {
38-470 . A = B + C;
38-471 . D = E + F;
38-472 . }
38-473 .
38-474 . /* LE SV TOC-2138 this is a log-09.2.45 req to halt*/
38-475 . A = B/C;
38-476 . A = B*C;
38-477 .
38-478 . switch (log stuff)
38-479 . {
38-480 . case one:
38-481 . {
38-482 . run_this;
38-483 . break;
38-484 . }
38-485 . case two:
38-486 . {
38-487 . run_this;
38-488 . break;
38-489 . }
38-490 . default:
38-491 . {
38-492 . SwError;
38-493 . }
38-494 . }
38-495 .
38-496 .
38-497 . if (A lt B)
38-498 . {
38-499 . A = B + C;
38-500 . D = E + F;
38-501 . }
38-502 .
38-503 . A = B-C;
38-504 . A = B/C;
38-505 . /* LE SV TOC-2139 this is a log-09.2.51 req to check unix*/
38-506 . free(FreePtr);
38-507 . A = B-C;
38-508 . A = B+C;
38-509 .
38-510 . if (A > B)
38-511 . {
38-512 . A = B + C;
38-513 . D = E + F;
38-514 . }
38-515 .
38-516 .
38-517 . if (A gt B)
38-518 . {
38-519 . A = B + C;
38-520 . D = E + F;
38-521 . }
38-522 .
38-523 . A = B-C;
38-524 . /* LE SV TOC-2140 this is a log-09.2.56 req to validate*/
38-525 . A = B-C;
38-526 .
38-527 . if (A > B)
38-528 . {
38-529 . A = B + C;
38-530 . D = E + F;
38-531 . }
38-532 .
38-533 . A = B*C;
38-534 . A = B/C;
38-535 .
38-536 . switch (log stuff)
38-537 . {
38-538 . case:
38-539 . case:
38-540 . // stacked case statements but only if there is a new line in between
38-541 .
38-542 . case:
38-543 . case:
38-544 . case:
38-545 . {
38-546 . run_this;
38-547 . break;
38-548 . }
38-549 . default:
38-550 . {
38-551 . halt;
38-552 . }
38-553 . }
38-554 .
38-555 . A = B*C;
38-556 . A = B-C;
38-557 .
38-558 . if (A le B)
38-559 . {
38-560 . A = B + C;
38-561 . D = E + F;
38-562 . }
38-563 .
38-564 . // max LOC 62
38-565 .
38-566 . }
38-567 .
38-568 .
38-569 . /*
38-570 . -----------------------------------------------------------------------------
38-571 . --| NAME: log.9.3
38-572 . --|
38-573 . --| ABSTRACT:
38-574 . --| This function does log stuff.
38-575 . --|
38-576 . --| RETURNS:
38-577 . --| NONE.
38-578 . --|
38-579 . ----------------------------------------------------------------------------
38-580 . */
38-581 . static void log.9.3(void)
38-582 . {
38-583 . A = B/C;
38-584 . A = B*C;
38-585 . /* LE SV TOC-2141 this is a log-09.3.3 req to compare*/
38-586 . A = B-C;
38-587 . A = B/C;
38-588 . A = B*C;
38-589 . A = B*C;
38-590 . A = B*C;
38-591 . A = B/C;
38-592 .
38-593 . if (A == B)
38-594 . {
38-595 . A = B + C;
38-596 . D = E + F;
38-597 . }
38-598 .
38-599 . /* LE SV TOC-2142 this is a log-09.3.10 req to store*/
38-600 . A = B/C;
38-601 . A = B/C;
38-602 . A = B+C;
38-603 . A = B*C;
38-604 . A = B+C;
38-605 . A = B-C;
38-606 . A = B/C;
38-607 . A = B/C;
38-608 . A = B/C;
38-609 . A = B+C;
38-610 . A = B-C;
38-611 .
38-612 . if (A != B)
38-613 . {
38-614 . A = B + C;
38-615 . D = E + F;
38-616 . }
38-617 .
38-618 . A = 0x0002;
38-619 . A = B-C;
38-620 . A = B*C;
38-621 . A = 0x0009;
38-622 . A = B/C;
38-623 . A = B+C;
38-624 . A = B-C;
38-625 . A = B/C;
38-626 . A = B*C;
38-627 .
38-628 . if (A == B)
38-629 . {
38-630 . A = B + C;
38-631 . D = E + F;
38-632 . }
38-633 .
38-634 . A = B-C;
38-635 . A = B+C;
38-636 . A = B-C;
38-637 . A = B-C;
38-638 . A = B-C;
38-639 .
38-640 . if (A eq B)
38-641 . {
38-642 . A = B + C;
38-643 . D = E + F;
38-644 . }
38-645 .
38-646 .
38-647 . if (A eq B)
38-648 . {
38-649 . A = B + C;
38-650 . D = E + F;
38-651 . }
38-652 .
38-653 .
38-654 . if (A ge B)
38-655 . {
38-656 . A = B + C;
38-657 . D = E + F;
38-658 . }
38-659 .
38-660 . A = B+C;
38-661 .
38-662 . if (A eq B)
38-663 . {
38-664 . A = B + C;
38-665 . D = E + F;
38-666 . }
38-667 .
38-668 .
38-669 . if (veg)
38-670 . // missing curly brace
38-671 . variable = orange;
38-672 .
38-673 .
38-674 . if (A ge B)
38-675 . {
38-676 . A = B + C;
38-677 . D = E + F;
38-678 . }
38-679 .
38-680 .
38-681 . if (A eq B)
38-682 . {
38-683 . A = B + C;
38-684 . D = E + F;
38-685 . }
38-686 .
38-687 . A = B-C;
38-688 .
38-689 . if (A > B)
38-690 . {
38-691 . A = B + C;
38-692 . D = E + F;
38-693 . }
38-694 .
38-695 . /* dead_code = A * B; */
38-696 . A = B-C;
38-697 . A = B/C;
38-698 . A = B+C;
38-699 . A = B*C;
38-700 . // max LOC 47
38-701 .
38-702 . }
38-703 .
38-704 .
38-705 . /*
38-706 . -----------------------------------------------------------------------------
38-707 . --| NAME: log.9.4
38-708 . --|
38-709 . --| ABSTRACT:
38-710 . --| This function does log stuff.
38-711 . --|
38-712 . --| RETURNS:
38-713 . --| NONE.
38-714 . --|
38-715 . ----------------------------------------------------------------------------
38-716 . */
38-717 . static void log.9.4(void)
38-718 . {
38-719 . A = B/C;
38-720 . A = B*C;
38-721 . A = B*C;
38-722 .
38-723 . if (A gt B)
38-724 . {
38-725 . A = B + C;
38-726 . D = E + F;
38-727 . }
38-728 .
38-729 .
38-730 . if (A eq B)
38-731 . {
38-732 . A = B + C;
38-733 . D = E + F;
38-734 . }
38-735 .
38-736 . A = B+C;
38-737 . A = B/C;
38-738 . A = B/C;
38-739 . A = B/C;
38-740 . A = B/C;
38-741 . A = B+C;
38-742 . A = B/C;
38-743 . /* LE SV TOC-2143 this is a log-09.4.13 req to enable*/
38-744 . A = B*C;
38-745 .
38-746 . if (A != B)
38-747 . {
38-748 . A = B + C;
38-749 . D = E + F;
38-750 . }
38-751 .
38-752 . A = B+C;
38-753 .
38-754 . switch (log stuff)
38-755 . {
38-756 . case one:
38-757 . {
38-758 . run_this;
38-759 . break;
38-760 . }
38-761 . case two:
38-762 . {
38-763 . run_this;
38-764 . break;
38-765 . }
38-766 . default:
38-767 . {
38-768 . SwError;
38-769 . }
38-770 . }
38-771 .
38-772 . A = B*C;
38-773 .
38-774 . if (A le B)
38-775 . {
38-776 . A = B + C;
38-777 . D = E + F;
38-778 . }
38-779 .
38-780 .
38-781 . if (A ne B)
38-782 . {
38-783 . A = B + C;
38-784 . D = E + F;
38-785 . }
38-786 .
38-787 . A = B-C;
38-788 . A = B/C;
38-789 .
38-790 . if (A eq B)
38-791 . {
38-792 . A = B + C;
38-793 . D = E + F;
38-794 . }
38-795 .
38-796 . A = B+C;
38-797 . A = B+C;
38-798 . A = 0x0004;
38-799 .
38-800 . if {
38-801 . X = Y + Z;
38-802 . }
38-803 . else {
38-804 . halt;
38-805 . }
38-806 .
38-807 . A = B*C;
38-808 . A = B/C;
38-809 . A = B+C;
38-810 . A = B+C;
38-811 . A = B/C;
38-812 .
38-813 . if (A != B)
38-814 . {
38-815 . A = B + C;
38-816 . D = E + F;
38-817 . }
38-818 .
38-819 .
38-820 . if (A le B)
38-821 . {
38-822 . A = B + C;
38-823 . D = E + F;
38-824 . }
38-825 .
38-826 . A = B/C;
38-827 .
38-828 . if (A lt B)
38-829 . {
38-830 . A = B + C;
38-831 . D = E + F;
38-832 . }
38-833 .
38-834 . A = B/C;
38-835 . A = B-C;
38-836 . A = B-C;
38-837 . A = B-C;
38-838 . A = B+C;
38-839 .
38-840 . if (A ne B)
38-841 . {
38-842 . A = B + C;
38-843 . D = E + F;
38-844 . }
38-845 .
38-846 .
38-847 . if (A > B)
38-848 . {
38-849 . A = B + C;
38-850 . D = E + F;
38-851 . }
38-852 .
38-853 .
38-854 . if (A eq B)
38-855 . {
38-856 . A = B + C;
38-857 . D = E + F;
38-858 . }
38-859 .
38-860 . A = B/C;
38-861 . A = B-C;
38-862 . A = B*C;
38-863 . A = B+C;
38-864 . A = B-C;
38-865 . A = B/C;
38-866 . /* LE SV TOC-2144 this is a log-09.4.48 req to store*/
38-867 . A = B-C;
38-868 . A = B-C;
38-869 . A = B/C;
38-870 . A = B-C;
38-871 . A = B+C;
38-872 . A = B+C;
38-873 . A = B*C;
38-874 . A = B-C;
38-875 . A = B-C;
38-876 .
38-877 . if (A < = B)
38-878 . {
38-879 . A = B + C;
38-880 . D = E + F;
38-881 . }
38-882 .
38-883 . A = B*C;
38-884 . A = B-C;
38-885 . A = B-C;
38-886 . A = B+C;
38-887 . A = B/C;
38-888 .
38-889 . switch (log stuff)
38-890 . {
38-891 . case one:
38-892 . {
38-893 . switch (nested)
38-894 . {
38-895 . case:
38-896 . X = Y + Z;
38-897 . case:
38-898 . X = Y + Z;
38-899 . default:
38-900 . SwError;
38-901 . }
38-902 . }
38-903 . case two:
38-904 . {
38-905 . run_this;
38-906 . break;
38-907 . }
38-908 . default:
38-909 . {
38-910 . SwError;
38-911 . }
38-912 . }
38-913 .
38-914 . A = B+C;
38-915 .
38-916 . if (A gt B)
38-917 . {
38-918 . A = B + C;
38-919 . D = E + F;
38-920 . }
38-921 .
38-922 . A = B+C;
38-923 . A = B/C;
38-924 . A = B-C;
38-925 . A = B-C;
38-926 .
38-927 . if (A > B)
38-928 . {
38-929 . A = B + C;
38-930 . D = E + F;
38-931 . }
38-932 .
38-933 . A = B-C;
38-934 . A = B/C;
38-935 . A = B*C;
38-936 . A = B+C;
38-937 . A = B*C;
38-938 . A = B-C;
38-939 . A = B-C;
38-940 . A = B+C;
38-941 . A = B+C;
38-942 . A = B-C;
38-943 . A = B*C;
38-944 . A = B*C;
38-945 . // TBS - I need to figure this out
38-946 . A = B*C;
38-947 .
38-948 . if (A > B)
38-949 . {
38-950 . A = B + C;
38-951 . D = E + F;
38-952 . }
38-953 .
38-954 . A = B-C;
38-955 . A = B/C;
38-956 . A = B-C;
38-957 . A = B+C;
38-958 . /* LE SV TOC-2145 this is a log-09.4.88 req to update*/
38-959 . A = B*C;
38-960 .
38-961 . if (A ne B)
38-962 . {
38-963 . A = B + C;
38-964 . D = E + F;
38-965 . }
38-966 .
38-967 .
38-968 . if (A gt B)
38-969 . {
38-970 . A = B + C;
38-971 . D = E + F;
38-972 . }
38-973 .
38-974 . // max LOC 90
38-975 .
38-976 . }
38-977 .
38-978 .
38-979 . /*
38-980 . -----------------------------------------------------------------------------
38-981 . --| NAME: log.9.5
38-982 . --|
38-983 . --| ABSTRACT:
38-984 . --| This function does log stuff.
38-985 . --|
38-986 . --| RETURNS:
38-987 . --| NONE.
38-988 . --|
38-989 . ----------------------------------------------------------------------------
38-990 . */
38-991 . static void log.9.5(void)
38-992 . {
38-993 . A = B*C;
38-994 . A = B*C;
38-995 . A = B-C;
38-996 . A = B*C;
38-997 .
38-998 . if (A eq B)
38-999 . {
38-1000 . A = B + C;
38-1001 . D = E + F;
38-1002 . }
38-1003 .
38-1004 . A = B*C;
38-1005 . A = B*C;
38-1006 . A = B-C;
38-1007 .
38-1008 . if (A le B)
38-1009 . {
38-1010 . A = B + C;
38-1011 . D = E + F;
38-1012 . }
38-1013 .
38-1014 . A = B-C;
38-1015 . A = B+C;
38-1016 . A = B+C;
38-1017 .
38-1018 . if (A le B)
38-1019 . {
38-1020 . A = B + C;
38-1021 . D = E + F;
38-1022 . }
38-1023 .
38-1024 . A = B+C;
38-1025 . A = B/C;
38-1026 . A = B/C;
38-1027 . A = B/C;
38-1028 . A = B/C;
38-1029 .
38-1030 . if (A lt B)
38-1031 . {
38-1032 . A = B + C;
38-1033 . D = E + F;
38-1034 . }
38-1035 .
38-1036 . A = B+C;
38-1037 .
38-1038 . if (A gt B)
38-1039 . {
38-1040 . A = B + C;
38-1041 . D = E + F;
38-1042 . }
38-1043 .
38-1044 . // max LOC 21
38-1045 .
38-1046 . }
38-1047 .
38-1048 .
38-1049 . /*
38-1050 . -----------------------------------------------------------------------------
38-1051 . --| NAME: log.9.6
38-1052 . --|
38-1053 . --| ABSTRACT:
38-1054 . --| This function does log stuff.
38-1055 . --|
38-1056 . --| RETURNS:
38-1057 . --| NONE.
38-1058 . --|
38-1059 . ----------------------------------------------------------------------------
38-1060 . */
38-1061 . static void log.9.6(void)
38-1062 . {
38-1063 . A = B+C;
38-1064 . A = B*C;
38-1065 . A = B*C;
38-1066 .
38-1067 . if (A > B)
38-1068 . {
38-1069 . A = B + C;
38-1070 . D = E + F;
38-1071 . }
38-1072 .
38-1073 . A = B*C;
38-1074 . A = B-C;
38-1075 . A = B+C;
38-1076 . A = B*C;
38-1077 . A = B*C;
38-1078 . A = B*C;
38-1079 . A = B-C;
38-1080 .
38-1081 . if (A lt B)
38-1082 . {
38-1083 . A = B + C;
38-1084 . D = E + F;
38-1085 . }
38-1086 .
38-1087 . A = B/C;
38-1088 . A = B/C;
38-1089 .
38-1090 . if (A < B)
38-1091 . {
38-1092 . A = B + C;
38-1093 . D = E + F;
38-1094 . }
38-1095 .
38-1096 . A = B-C;
38-1097 . A = B-C;
38-1098 .
38-1099 . if (A lt B)
38-1100 . {
38-1101 . A = B + C;
38-1102 . D = E + F;
38-1103 . }
38-1104 .
38-1105 .
38-1106 . if (A eq B)
38-1107 . {
38-1108 . A = B + C;
38-1109 . D = E + F;
38-1110 . }
38-1111 .
38-1112 .
38-1113 . if (A == B)
38-1114 . {
38-1115 . A = B + C;
38-1116 . D = E + F;
38-1117 . }
38-1118 .
38-1119 . A = B*C;
38-1120 . A = B/C;
38-1121 . A = B-C;
38-1122 .
38-1123 . if (A == B)
38-1124 . {
38-1125 . A = B + C;
38-1126 . D = E + F;
38-1127 . }
38-1128 .
38-1129 . A = B*C;
38-1130 . A = B-C;
38-1131 . A = B*C;
38-1132 .
38-1133 . if (A ne B)
38-1134 . {
38-1135 . A = B + C;
38-1136 . D = E + F;
38-1137 . }
38-1138 .
38-1139 . A = B/C;
38-1140 . A = B-C;
38-1141 .
38-1142 . switch (log stuff)
38-1143 . {
38-1144 . case one:
38-1145 . {
38-1146 . run_this;
38-1147 . break;
38-1148 . }
38-1149 . case two:
38-1150 . {
38-1151 . run_this;
38-1152 . break;
38-1153 . }
38-1154 . default:
38-1155 . {
38-1156 . SwError;
38-1157 . }
38-1158 . }
38-1159 .
38-1160 . // max LOC 31
38-1161 .
38-1162 . }
38-1163 .
38-1164 .
38-1165 . /*
38-1166 . -----------------------------------------------------------------------------
38-1167 . --| NAME: log.9.7
38-1168 . --|
38-1169 . --| ABSTRACT:
38-1170 . --| This function does log stuff.
38-1171 . --|
38-1172 . --| RETURNS:
38-1173 . --| NONE.
38-1174 . --|
38-1175 . ----------------------------------------------------------------------------
38-1176 . */
38-1177 . static void log.9.7(void)
38-1178 . {
38-1179 . A = B+C;
38-1180 . A = B-C;
38-1181 .
38-1182 . if (A > B)
38-1183 . {
38-1184 . A = B + C;
38-1185 . D = E + F;
38-1186 . }
38-1187 .
38-1188 . A = B-C;
38-1189 . A = B/C;
38-1190 .
38-1191 . switch (log stuff)
38-1192 . {
38-1193 . case one:
38-1194 . {
38-1195 . run_this;
38-1196 . break;
38-1197 . }
38-1198 . case two:
38-1199 . {
38-1200 . run_this;
38-1201 . break;
38-1202 . }
38-1203 . // missing default
38-1204 . }
38-1205 .
38-1206 . A = B-C;
38-1207 . A = B-C;
38-1208 . A = 0x0006;
38-1209 .
38-1210 . if (A le B)
38-1211 . {
38-1212 . A = B + C;
38-1213 . D = E + F;
38-1214 . }
38-1215 .
38-1216 . /* LE SV TOC-2146 this is a log-09.7.9 req to recover*/
38-1217 . A = B+C;
38-1218 . A = B/C;
38-1219 . /* LE SV TOC-2147 this is a log-09.7.11 req to increment*/
38-1220 . A = B*C;
38-1221 . A = B+C;
38-1222 .
38-1223 . if (A > = B)
38-1224 . {
38-1225 . A = B + C;
38-1226 . D = E + F;
38-1227 . }
38-1228 .
38-1229 . A = B/C;
38-1230 .
38-1231 . if (A > = B)
38-1232 . {
38-1233 . A = B + C;
38-1234 . D = E + F;
38-1235 . }
38-1236 .
38-1237 .
38-1238 . if (A lt B)
38-1239 . {
38-1240 . A = B + C;
38-1241 . D = E + F;
38-1242 . }
38-1243 .
38-1244 .
38-1245 . if (A == B)
38-1246 . {
38-1247 . A = B + C;
38-1248 . D = E + F;
38-1249 . }
38-1250 .
38-1251 . /* LE SV TOC-2148 this is a log-09.7.18 req to transform*/
38-1252 .
38-1253 . if (A gt B)
38-1254 . {
38-1255 . A = B + C;
38-1256 . D = E + F;
38-1257 . }
38-1258 .
38-1259 .
38-1260 . if (A > B)
38-1261 . {
38-1262 . A = B + C;
38-1263 . D = E + F;
38-1264 . }
38-1265 .
38-1266 . A = B/C;
38-1267 . A = B+C;
38-1268 . A = B*C;
38-1269 . A = B/C;
38-1270 .
38-1271 . if (A > = B)
38-1272 . {
38-1273 . A = B + C;
38-1274 . D = E + F;
38-1275 . }
38-1276 .
38-1277 .
38-1278 . if (A ne B)
38-1279 . {
38-1280 . A = B + C;
38-1281 . D = E + F;
38-1282 . }
38-1283 .
38-1284 . A = B/C;
38-1285 . A = B*C;
38-1286 . A = B/C;
38-1287 .
38-1288 . if (A ge B)
38-1289 . {
38-1290 . A = B + C;
38-1291 . D = E + F;
38-1292 . }
38-1293 .
38-1294 .
38-1295 . if (A > B)
38-1296 . {
38-1297 . A = B + C;
38-1298 . D = E + F;
38-1299 . }
38-1300 .
38-1301 .
38-1302 . if (A gt B)
38-1303 . {
38-1304 . A = B + C;
38-1305 . D = E + F;
38-1306 . }
38-1307 .
38-1308 . A = B*C;
38-1309 .
38-1310 . if (A ne B)
38-1311 . {
38-1312 . A = B + C;
38-1313 . D = E + F;
38-1314 . }
38-1315 .
38-1316 .
38-1317 . if (A > B)
38-1318 . {
38-1319 . A = B + C;
38-1320 . D = E + F;
38-1321 . }
38-1322 .
38-1323 . A = B-C;
38-1324 . A = B*C;
38-1325 . A = B-C;
38-1326 . A = B+C;
38-1327 . /* LE SV TOC-2149 this is a log-09.7.39 req to set Real Time Clock*/
38-1328 . A = B-C;
38-1329 . A = B-C;
38-1330 . A = B-C;
38-1331 . A = B+C;
38-1332 . // max LOC 42
38-1333 .
38-1334 . }
38-1335 .
38-1336 .
38-1337 . /*
38-1338 . -----------------------------------------------------------------------------
38-1339 . --| NAME: log.9.8
38-1340 . --|
38-1341 . --| ABSTRACT:
38-1342 . --| This function does log stuff.
38-1343 . --|
38-1344 . --| RETURNS:
38-1345 . --| NONE.
38-1346 . --|
38-1347 . ----------------------------------------------------------------------------
38-1348 . */
38-1349 . static void log.9.8(void)
38-1350 . {
38-1351 . A = B+C;
38-1352 .
38-1353 . if (A < = B)
38-1354 . {
38-1355 . A = B + C;
38-1356 . D = E + F;
38-1357 . }
38-1358 .
38-1359 . A = B+C;
38-1360 .
38-1361 . switch (log stuff)
38-1362 . {
38-1363 . case one:
38-1364 . {
38-1365 . run_this;
38-1366 . break;
38-1367 . }
38-1368 . case two:
38-1369 . {
38-1370 . run_this;
38-1371 . break;
38-1372 . }
38-1373 . default:
38-1374 . {
38-1375 . SwError;
38-1376 . }
38-1377 . }
38-1378 .
38-1379 .
38-1380 . if (A != B)
38-1381 . {
38-1382 . A = B + C;
38-1383 . D = E + F;
38-1384 . }
38-1385 .
38-1386 . A = B/C;
38-1387 . A = B*C;
38-1388 .
38-1389 . if (A le B)
38-1390 . {
38-1391 . A = B + C;
38-1392 . D = E + F;
38-1393 . }
38-1394 .
38-1395 . A = B*C;
38-1396 . A = B*C;
38-1397 . A = B*C;
38-1398 . A = B*C;
38-1399 .
38-1400 . if (A < = B)
38-1401 . {
38-1402 . A = B + C;
38-1403 . D = E + F;
38-1404 . }
38-1405 .
38-1406 . A = B-C;
38-1407 .
38-1408 . if (A != B)
38-1409 . {
38-1410 . A = B + C;
38-1411 . D = E + F;
38-1412 . }
38-1413 .
38-1414 . /* LE SV TOC-2150 this is a log-09.8.16 req to compare*/
38-1415 .
38-1416 . if (A gt B)
38-1417 . {
38-1418 . A = B + C;
38-1419 . D = E + F;
38-1420 . }
38-1421 .
38-1422 .
38-1423 . if (A lt B)
38-1424 . {
38-1425 . A = B + C;
38-1426 . D = E + F;
38-1427 . }
38-1428 .
38-1429 .
38-1430 . if (A < B)
38-1431 . {
38-1432 . A = B + C;
38-1433 . D = E + F;
38-1434 . }
38-1435 .
38-1436 . A = B/C;
38-1437 . // max LOC 19
38-1438 .
38-1439 . }
38-1440 .
38-1441 .
38-1442 . /*
38-1443 . -----------------------------------------------------------------------------
38-1444 . --| NAME: log.9.9
38-1445 . --|
38-1446 . --| ABSTRACT:
38-1447 . --| This function does log stuff.
38-1448 . --|
38-1449 . --| RETURNS:
38-1450 . --| NONE.
38-1451 . --|
38-1452 . ----------------------------------------------------------------------------
38-1453 . */
38-1454 . static void log.9.9(void)
38-1455 . {
38-1456 . A = B*C;
38-1457 . A = B-C;
38-1458 . A = B+C;
38-1459 . A = B/C;
38-1460 . A = B/C;
38-1461 .
38-1462 . if (A eq B)
38-1463 . {
38-1464 . A = B + C;
38-1465 . D = E + F;
38-1466 . }
38-1467 .
38-1468 .
38-1469 . if (A le B)
38-1470 . {
38-1471 . A = B + C;
38-1472 . D = E + F;
38-1473 . }
38-1474 .
38-1475 .
38-1476 . if (A > = B)
38-1477 . {
38-1478 . A = B + C;
38-1479 . D = E + F;
38-1480 . }
38-1481 .
38-1482 . A = B*C;
38-1483 . A = B-C;
38-1484 .
38-1485 . if (A gt B)
38-1486 . {
38-1487 . A = B + C;
38-1488 . D = E + F;
38-1489 . }
38-1490 .
38-1491 . A = B-C;
38-1492 . A = B+C;
38-1493 . A = 0x0003;
38-1494 . A = B-C;
38-1495 . // max LOC 14
38-1496 .
38-1497 . }
38-1498 .
38 38 Result: result/source/ft-app/ft-app-B1.1/log/log-09.c
39 39 Source: source/ft-app/ft-app-B1.1/msaw/msaw-01.c
39-0 . /*
39-1 . ----------------------------------------------------------------------------
39-2 . --| BEGIN PROLOGUE
39-3 . --|
39-4 . --| CLASSIFICATION: UNCLASSIFIED
39-5 . --|
39-6 . --| FILE NAME: msaw-01.c
39-7 . --|
39-8 . --| ABSTRACT:
39-9 . --| This file contains the 1 functions that do file msaw stuff.
39-10 . --|
39-11 . --| HISTORY:
39-12 . --| CCCQ_NAME:
39-13 . --| CCCQ_VER:
39-14 . --|
39-15 . --| END PROLOGUE
39-16 . ----------------------------------------------------------------------------
39-17 . */
39-18 .
39-19 . #include D;
39-20 . #define D;
39-21 . #define B;
39-22 . #define C;
39-23 . #include A;
39-24 . #define C;
39-25 .
39-26 .
39-27 .
39-28 . /*
39-29 . -----------------------------------------------------------------------------
39-30 . --| NAME: msaw.1.1
39-31 . --|
39-32 . --| ABSTRACT:
39-33 . --| This function does msaw stuff.
39-34 . --|
39-35 . --| RETURNS:
39-36 . --| NONE.
39-37 . --|
39-38 . ----------------------------------------------------------------------------
39-39 . */
39-40 . static void msaw.1.1(void)
39-41 . {
39-42 . A = B*C;
39-43 .
39-44 . switch (msaw stuff)
39-45 . {
39-46 . case one:
39-47 . {
39-48 . run_this;
39-49 . break;
39-50 . }
39-51 . case two:
39-52 . {
39-53 . run_this;
39-54 . break;
39-55 . }
39-56 . default:
39-57 . {
39-58 . SwError;
39-59 . }
39-60 . }
39-61 .
39-62 .
39-63 . if (A != B)
39-64 . {
39-65 . A = B + C;
39-66 . D = E + F;
39-67 . }
39-68 .
39-69 .
39-70 . if (A gt B)
39-71 . {
39-72 . A = B + C;
39-73 . D = E + F;
39-74 . }
39-75 .
39-76 . A = B*C;
39-77 .
39-78 . if (A gt B)
39-79 . {
39-80 . A = B + C;
39-81 . D = E + F;
39-82 . }
39-83 .
39-84 . A = B-C;
39-85 . A = B/C;
39-86 . A = B*C;
39-87 .
39-88 . if (A gt B)
39-89 . {
39-90 . A = B + C;
39-91 . D = E + F;
39-92 . }
39-93 .
39-94 . A = B-C;
39-95 .
39-96 . if (A le B)
39-97 . {
39-98 . A = B + C;
39-99 . D = E + F;
39-100 . }
39-101 .
39-102 . A = B*C;
39-103 .
39-104 . if (A < B)
39-105 . {
39-106 . A = B + C;
39-107 . D = E + F;
39-108 . }
39-109 .
39-110 .
39-111 . if (A != B)
39-112 . {
39-113 . A = B + C;
39-114 . D = E + F;
39-115 . }
39-116 .
39-117 . A = B+C;
39-118 . A = B/C;
39-119 .
39-120 . if (A le B)
39-121 . {
39-122 . A = B + C;
39-123 . D = E + F;
39-124 . }
39-125 .
39-126 . A = B+C;
39-127 .
39-128 . if (A > = B)
39-129 . {
39-130 . A = B + C;
39-131 . D = E + F;
39-132 . }
39-133 .
39-134 . A = B-C;
39-135 . A = B+C;
39-136 . A = B+C;
39-137 . A = B/C;
39-138 . A = B-C;
39-139 .
39-140 . switch (msaw stuff)
39-141 . {
39-142 . case one:
39-143 . {
39-144 . run_this;
39-145 . break;
39-146 . }
39-147 . case two:
39-148 . {
39-149 . run_this;
39-150 . break;
39-151 . }
39-152 . default:
39-153 . {
39-154 . SwError;
39-155 . }
39-156 . }
39-157 .
39-158 . A = B-C;
39-159 . A = B/C;
39-160 . /* LE SV TOC-2201 this is a msaw-01.1.29 req to increment*/
39-161 .
39-162 . switch (msaw stuff)
39-163 . {
39-164 . case one:
39-165 . {
39-166 . run_this;
39-167 . break;
39-168 . }
39-169 . case two:
39-170 . {
39-171 . run_this;
39-172 . break;
39-173 . }
39-174 . default:
39-175 . {
39-176 . SwError;
39-177 . }
39-178 . }
39-179 .
39-180 . A = B/C;
39-181 .
39-182 . if (A ge B)
39-183 . {
39-184 . A = B + C;
39-185 . D = E + F;
39-186 . }
39-187 .
39-188 . A = B+C;
39-189 . A = 0x0009;
39-190 . A = B+C;
39-191 . A = B*C;
39-192 . A = B*C;
39-193 .
39-194 . if (A ne B)
39-195 . {
39-196 . A = B + C;
39-197 . D = E + F;
39-198 . }
39-199 .
39-200 .
39-201 . if (A ge B)
39-202 . {
39-203 . A = B + C;
39-204 . D = E + F;
39-205 . }
39-206 .
39-207 . A = B/C;
39-208 .
39-209 . if (A ne B)
39-210 . {
39-211 . A = B + C;
39-212 . D = E + F;
39-213 . }
39-214 .
39-215 . A = B*C;
39-216 . A = (long)B + C;
39-217 . A = B+C;
39-218 . A = B-C;
39-219 . A = B/C;
39-220 . A = B+C;
39-221 . A = B-C;
39-222 . A = B/C;
39-223 . A = B/C;
39-224 . // max LOC 47
39-225 .
39-226 . }
39-227 .
39 39 Result: result/source/ft-app/ft-app-B1.1/msaw/msaw-01.c
40 40 Source: source/ft-app/ft-app-B1.1/msaw/msaw-02.c
40-0 .
40-1 .
40-2 . #define A;
40-3 . #include C;
40-4 . float B;
40-5 . #define A;
40-6 . #define B;
40-7 . double C;
40-8 .
40-9 .
40-10 .
40-11 . /*
40-12 . -----------------------------------------------------------------------------
40-13 . --| NAME: msaw.2.1
40-14 . --|
40-15 . --| ABSTRACT:
40-16 . --| This function does msaw stuff.
40-17 . --|
40-18 . --| RETURNS:
40-19 . --| NONE.
40-20 . --|
40-21 . ----------------------------------------------------------------------------
40-22 . */
40-23 . static void msaw.2.1(void)
40-24 . {
40-25 . A = B*C;
40-26 . A = B+C;
40-27 .
40-28 . switch (msaw stuff)
40-29 . {
40-30 . case one:
40-31 . {
40-32 . run_this;
40-33 . break;
40-34 . }
40-35 . case two:
40-36 . {
40-37 . run_this;
40-38 . break;
40-39 . }
40-40 . default:
40-41 . {
40-42 . SwError;
40-43 . }
40-44 . }
40-45 .
40-46 .
40-47 . if (A le B)
40-48 . {
40-49 . A = B + C;
40-50 . D = E + F;
40-51 . }
40-52 .
40-53 . /* LE SV TOC-2202 this is a msaw-02.1.5 req to recover*/
40-54 . A = B-C;
40-55 . A = B*C;
40-56 . A = B+C;
40-57 . A = B*C;
40-58 . /* LE SV TOC-2203 this is a msaw-02.1.9 req to process*/
40-59 .
40-60 . switch (msaw stuff)
40-61 . {
40-62 . case one:
40-63 . {
40-64 . run_this;
40-65 . break;
40-66 . }
40-67 . case two:
40-68 . {
40-69 . run_this;
40-70 . break;
40-71 . }
40-72 . default:
40-73 . {
40-74 . SwError;
40-75 . }
40-76 . }
40-77 .
40-78 . A = B/C;
40-79 . A = B*C;
40-80 . /* LE SV TOC-2204 this is a msaw-02.1.12 req to compare*/
40-81 . A = B+C;
40-82 . A = B+C;
40-83 . A = 0x0001;
40-84 .
40-85 . if (A gt B)
40-86 . {
40-87 . A = B + C;
40-88 . D = E + F;
40-89 . }
40-90 .
40-91 .
40-92 . switch (msaw stuff)
40-93 . {
40-94 . case one:
40-95 . {
40-96 . run_this;
40-97 . break;
40-98 . }
40-99 . case two:
40-100 . {
40-101 . run_this;
40-102 . break;
40-103 . }
40-104 . default:
40-105 . {
40-106 . SwError;
40-107 . }
40-108 . }
40-109 .
40-110 . A = B/C;
40-111 . /* LE SV TOC-2205 this is a msaw-02.1.17 req to transform*/
40-112 .
40-113 . if (A > B)
40-114 . {
40-115 . A = B + C;
40-116 . D = E + F;
40-117 . }
40-118 .
40-119 .
40-120 . if (A < B)
40-121 . {
40-122 . A = B + C;
40-123 . D = E + F;
40-124 . }
40-125 .
40-126 . A = B-C;
40-127 .
40-128 . if (A ne B)
40-129 . {
40-130 . A = B + C;
40-131 . D = E + F;
40-132 . }
40-133 .
40-134 .
40-135 . if (A ge B)
40-136 . {
40-137 . A = B + C;
40-138 . D = E + F;
40-139 . }
40-140 .
40-141 . /* LE SV TOC-2206 this is a msaw-02.1.22 req to recover*/
40-142 . A = B+C;
40-143 . A = B/C;
40-144 . A = B*C;
40-145 . A = B-C;
40-146 . A = B/C;
40-147 . A = B-C;
40-148 .
40-149 . if (A gt B)
40-150 . {
40-151 . A = B + C;
40-152 . D = E + F;
40-153 . }
40-154 .
40-155 . A = B*C;
40-156 . A = B/C;
40-157 . A = B+C;
40-158 .
40-159 . if (A > = B)
40-160 . {
40-161 . A = B + C;
40-162 . D = E + F;
40-163 . }
40-164 .
40-165 . FreePtr = HmiStringPtr;
40-166 .
40-167 . if (A != B)
40-168 . {
40-169 . A = B + C;
40-170 . D = E + F;
40-171 . }
40-172 .
40-173 . A = B/C;
40-174 . A = B+C;
40-175 .
40-176 . if (A == B)
40-177 . {
40-178 . A = B + C;
40-179 . D = E + F;
40-180 . }
40-181 .
40-182 . /* LE SV TOC-2207 this is a msaw-02.1.37 req to check unix*/
40-183 .
40-184 . if (A ge B)
40-185 . {
40-186 . A = B + C;
40-187 . D = E + F;
40-188 . }
40-189 .
40-190 . A = B-C;
40-191 .
40-192 . if (A == B)
40-193 . {
40-194 . A = B + C;
40-195 . D = E + F;
40-196 . }
40-197 .
40-198 . A = B-C;
40-199 . A = B+C;
40-200 . A = B*C;
40-201 . A = B-C;
40-202 . A = B/C;
40-203 . A = B+C;
40-204 . A = B/C;
40-205 . A = B-C;
40-206 . A = B/C;
40-207 . A = 0x0002;
40-208 .
40-209 . if (A le B)
40-210 . {
40-211 . A = B + C;
40-212 . D = E + F;
40-213 . }
40-214 .
40-215 . A = B+C;
40-216 .
40-217 . switch (msaw stuff)
40-218 . {
40-219 . case one:
40-220 . {
40-221 . run_this;
40-222 . break;
40-223 . }
40-224 . case two:
40-225 . {
40-226 . run_this;
40-227 . break;
40-228 . }
40-229 . // missing default
40-230 . }
40-231 .
40-232 . A = B/C;
40-233 . A = B*C;
40-234 . A = B/C;
40-235 .
40-236 . if (A eq B)
40-237 . {
40-238 . A = B + C;
40-239 . D = E + F;
40-240 . }
40-241 .
40-242 .
40-243 . if (A != B)
40-244 . {
40-245 . A = B + C;
40-246 . D = E + F;
40-247 . }
40-248 .
40-249 .
40-250 . if (A lt B)
40-251 . {
40-252 . A = B + C;
40-253 . D = E + F;
40-254 . }
40-255 .
40-256 .
40-257 . if (A ge B)
40-258 . {
40-259 . A = B + C;
40-260 . D = E + F;
40-261 . }
40-262 .
40-263 .
40-264 . if (A != B)
40-265 . {
40-266 . A = B + C;
40-267 . D = E + F;
40-268 . }
40-269 .
40-270 .
40-271 . if (A < = B)
40-272 . {
40-273 . A = B + C;
40-274 . D = E + F;
40-275 . }
40-276 .
40-277 .
40-278 . switch (msaw stuff)
40-279 . {
40-280 . case one:
40-281 . {
40-282 . run_this;
40-283 . break;
40-284 . }
40-285 . case two:
40-286 . {
40-287 . run_this;
40-288 . break;
40-289 . }
40-290 . default:
40-291 . {
40-292 . SwError;
40-293 . }
40-294 . }
40-295 .
40-296 . A = B/C;
40-297 .
40-298 . if (A le B)
40-299 . {
40-300 . A = B + C;
40-301 . D = E + F;
40-302 . }
40-303 .
40-304 . A = B*C;
40-305 . A = B+C;
40-306 . A = B-C;
40-307 . A = B*C;
40-308 . A = B-C;
40-309 . A = B*C;
40-310 .
40-311 . if (A gt B)
40-312 . {
40-313 . A = B + C;
40-314 . D = E + F;
40-315 . }
40-316 .
40-317 .
40-318 . if (A lt B)
40-319 . {
40-320 . A = B + C;
40-321 . D = E + F;
40-322 . }
40-323 .
40-324 . A = B/C;
40-325 . A = B-C;
40-326 .
40-327 . if (A < B)
40-328 . {
40-329 . A = B + C;
40-330 . D = E + F;
40-331 . }
40-332 .
40-333 . A = B-C;
40-334 .
40-335 . if (A ge B)
40-336 . {
40-337 . A = B + C;
40-338 . D = E + F;
40-339 . }
40-340 .
40-341 . A = B-C;
40-342 . /* LE SV TOC-2208 this is a msaw-02.1.77 req to translate*/
40-343 .
40-344 . if (A < = B)
40-345 . {
40-346 . A = B + C;
40-347 . D = E + F;
40-348 . }
40-349 .
40-350 . free(FreePtr);
40-351 . A = B-C;
40-352 . A = B/C;
40-353 .
40-354 . if (A > = B)
40-355 . {
40-356 . A = B + C;
40-357 . D = E + F;
40-358 . }
40-359 .
40-360 . A = B*C;
40-361 . A = B+C;
40-362 . A = B*C;
40-363 .
40-364 . if (A ge B)
40-365 . {
40-366 . A = B + C;
40-367 . D = E + F;
40-368 . }
40-369 .
40-370 . A = B+C;
40-371 .
40-372 . if (A != B)
40-373 . {
40-374 . A = B + C;
40-375 . D = E + F;
40-376 . }
40-377 .
40-378 . A = B*C;
40-379 . A = B/C;
40-380 . A = B/C;
40-381 . A = B/C;
40-382 . A = B/C;
40-383 . // max LOC 91
40-384 .
40-385 . }
40-386 .
40-387 .
40-388 . /*
40-389 . -----------------------------------------------------------------------------
40-390 . --| NAME: msaw.2.2
40-391 . --|
40-392 . --| ABSTRACT:
40-393 . --| This function does msaw stuff.
40-394 . --|
40-395 . --| RETURNS:
40-396 . --| NONE.
40-397 . --|
40-398 . ----------------------------------------------------------------------------
40-399 . */
40-400 . static void msaw.2.2(void)
40-401 . {
40-402 .
40-403 . if (A > B)
40-404 . {
40-405 . A = B + C;
40-406 . D = E + F;
40-407 . }
40-408 .
40-409 . A = B+C;
40-410 . A = B+C;
40-411 . A = B*C;
40-412 . send_buffer = (U16 *) malloc(size+1);
40-413 . A = B+C;
40-414 . A = B/C;
40-415 .
40-416 . if (A le B)
40-417 . {
40-418 . A = B + C;
40-419 . D = E + F;
40-420 . }
40-421 .
40-422 . A = B/C;
40-423 .
40-424 . if (A != B)
40-425 . {
40-426 . A = B + C;
40-427 . D = E + F;
40-428 . }
40-429 .
40-430 .
40-431 . if (A != B)
40-432 . {
40-433 . A = B + C;
40-434 . D = E + F;
40-435 . }
40-436 .
40-437 . A = B-C;
40-438 .
40-439 . if (A ge B)
40-440 . {
40-441 . A = B + C;
40-442 . D = E + F;
40-443 . }
40-444 .
40-445 . A = B-C;
40-446 . A = B/C;
40-447 . A = B-C;
40-448 . A = B*C;
40-449 . A = B+C;
40-450 . A = B*C;
40-451 .
40-452 . if (A < B)
40-453 . {
40-454 . A = B + C;
40-455 . D = E + F;
40-456 . }
40-457 .
40-458 .
40-459 . if (A gt B)
40-460 . {
40-461 . A = B + C;
40-462 . D = E + F;
40-463 . }
40-464 .
40-465 .
40-466 . if (A gt B)
40-467 . {
40-468 . A = B + C;
40-469 . D = E + F;
40-470 . }
40-471 .
40-472 .
40-473 . if (A le B)
40-474 . {
40-475 . A = B + C;
40-476 . D = E + F;
40-477 . }
40-478 .
40-479 .
40-480 . if (A gt B)
40-481 . {
40-482 . A = B + C;
40-483 . D = E + F;
40-484 . }
40-485 .
40-486 . /* LE SV TOC-2209 this is a msaw-02.2.24 req to convert*/
40-487 .
40-488 . switch (msaw stuff)
40-489 . {
40-490 . case one:
40-491 . {
40-492 . run_this;
40-493 . // missing break
40-494 . }
40-495 . case two:
40-496 . {
40-497 . run_this;
40-498 . break;
40-499 . }
40-500 . default:
40-501 . {
40-502 . SwError;
40-503 . }
40-504 . }
40-505 .
40-506 . A = B+C;
40-507 . A = B*C;
40-508 . A = B+C;
40-509 . A = B-C;
40-510 .
40-511 . if (A le B)
40-512 . {
40-513 . A = B + C;
40-514 . D = E + F;
40-515 . }
40-516 .
40-517 .
40-518 . if (A < = B)
40-519 . {
40-520 . A = B + C;
40-521 . D = E + F;
40-522 . }
40-523 .
40-524 . A = B/C;
40-525 .
40-526 . switch (msaw stuff)
40-527 . {
40-528 . case one:
40-529 . {
40-530 . run_this;
40-531 . break;
40-532 . }
40-533 . case two:
40-534 . {
40-535 . run_this;
40-536 . break;
40-537 . }
40-538 . default:
40-539 . {
40-540 . SwError;
40-541 . }
40-542 . }
40-543 .
40-544 . A = B-C;
40-545 .
40-546 . if (A le B)
40-547 . {
40-548 . A = B + C;
40-549 . D = E + F;
40-550 . }
40-551 .
40-552 . A = B*C;
40-553 . A = B+C;
40-554 . A = B*C;
40-555 . A = B-C;
40-556 . A = B*C;
40-557 .
40-558 . switch (msaw stuff)
40-559 . {
40-560 . case one:
40-561 . {
40-562 . run_this;
40-563 . // missing break
40-564 . }
40-565 . case two:
40-566 . {
40-567 . run_this;
40-568 . break;
40-569 . }
40-570 . default:
40-571 . {
40-572 . SwError;
40-573 . }
40-574 . }
40-575 .
40-576 . A = B*C;
40-577 . A = B*C;
40-578 .
40-579 . if (A gt B)
40-580 . {
40-581 . A = B + C;
40-582 . D = E + F;
40-583 . }
40-584 .
40-585 .
40-586 . if (A == B)
40-587 . {
40-588 . A = B + C;
40-589 . D = E + F;
40-590 . }
40-591 .
40-592 . A = B/C;
40-593 .
40-594 . switch (msaw stuff)
40-595 . {
40-596 . case one:
40-597 . {
40-598 . run_this;
40-599 . // missing break
40-600 . }
40-601 . case two:
40-602 . {
40-603 . run_this;
40-604 . break;
40-605 . }
40-606 . default:
40-607 . {
40-608 . SwError;
40-609 . }
40-610 . }
40-611 .
40-612 . A = B*C;
40-613 . A = B*C;
40-614 . A = B*C;
40-615 . A = B*C;
40-616 . // max LOC 47
40-617 .
40-618 . }
40-619 .
40 40 Result: result/source/ft-app/ft-app-B1.1/msaw/msaw-02.c
41 41 Source: source/ft-app/ft-app-B1.1/msaw/msaw-03.c
41-0 . /*
41-1 . ----------------------------------------------------------------------------
41-2 . --| BEGIN PROLOGUE
41-3 . --|
41-4 . --| CLASSIFICATION: UNCLASSIFIED
41-5 . --|
41-6 . --| FILE NAME: msaw-03.c
41-7 . --|
41-8 . --| ABSTRACT:
41-9 . --| This file contains the 12 functions that do file msaw stuff.
41-10 . --|
41-11 . --| HISTORY:
41-12 . --| CCCQ_NAME:
41-13 . --| CCCQ_VER:
41-14 . --|
41-15 . --| END PROLOGUE
41-16 . ----------------------------------------------------------------------------
41-17 . */
41-18 .
41-19 . double C;
41-20 . #define C;
41-21 . #define A;
41-22 .
41-23 .
41-24 .
41-25 . /*
41-26 . -----------------------------------------------------------------------------
41-27 . --| NAME: msaw.3.1
41-28 . --|
41-29 . --| ABSTRACT:
41-30 . --| This function does msaw stuff.
41-31 . --|
41-32 . --| RETURNS:
41-33 . --| NONE.
41-34 . --|
41-35 . ----------------------------------------------------------------------------
41-36 . */
41-37 . static void msaw.3.1(void)
41-38 . {
41-39 .
41-40 . if {
41-41 . X = Y + Z;
41-42 . }
41-43 . else {
41-44 . halt;
41-45 . }
41-46 .
41-47 . A = B+C;
41-48 . A = B*C;
41-49 . A = B/C;
41-50 .
41-51 . if (A > = B)
41-52 . {
41-53 . A = B + C;
41-54 . D = E + F;
41-55 . }
41-56 .
41-57 . A = B*C;
41-58 . A = B*C;
41-59 . A = B-C;
41-60 . A = B-C;
41-61 .
41-62 . if (A ge B)
41-63 . {
41-64 . A = B + C;
41-65 . D = E + F;
41-66 . }
41-67 .
41-68 . A = B-C;
41-69 . A = B+C;
41-70 .
41-71 . if (A > B)
41-72 . {
41-73 . A = B + C;
41-74 . D = E + F;
41-75 . }
41-76 .
41-77 . A = B*C;
41-78 .
41-79 . if (A != B)
41-80 . {
41-81 . A = B + C;
41-82 . D = E + F;
41-83 . }
41-84 .
41-85 . A = B+C;
41-86 .
41-87 . /* dead_code = B + C;
41-88 . dead_code = D + E;
41-89 . dead_code = F + G; */
41-90 .
41-91 .
41-92 . if (A == B)
41-93 . {
41-94 . A = B + C;
41-95 . D = E + F;
41-96 . }
41-97 .
41-98 . A = B*C;
41-99 .
41-100 . if (A < B)
41-101 . {
41-102 . A = B + C;
41-103 . D = E + F;
41-104 . }
41-105 .
41-106 . A = B*C;
41-107 . A = B+C;
41-108 . A = B/C;
41-109 .
41-110 . if (A > B)
41-111 . {
41-112 . A = B + C;
41-113 . D = E + F;
41-114 . }
41-115 .
41-116 . A = B/C;
41-117 . A = B/C;
41-118 .
41-119 . switch (msaw stuff)
41-120 . {
41-121 . case one:
41-122 . {
41-123 . run_this;
41-124 . break;
41-125 . }
41-126 . case two:
41-127 . {
41-128 . run_this;
41-129 . break;
41-130 . }
41-131 . default:
41-132 . {
41-133 . SwError;
41-134 . }
41-135 . }
41-136 .
41-137 .
41-138 . if (A == B)
41-139 . {
41-140 . A = B + C;
41-141 . D = E + F;
41-142 . }
41-143 .
41-144 . /* LE SV TOC-2210 this is a msaw-03.1.27 req to verify*/
41-145 . A = B+C;
41-146 . A = B+C;
41-147 .
41-148 . switch (msaw stuff)
41-149 . {
41-150 . case one:
41-151 . {
41-152 . run_this;
41-153 . break;
41-154 . }
41-155 . case two:
41-156 . {
41-157 . run_this;
41-158 . break;
41-159 . }
41-160 . default:
41-161 . {
41-162 . SwError;
41-163 . }
41-164 . }
41-165 .
41-166 . A = B*C;
41-167 . A = B+C;
41-168 .
41-169 . if (A eq B)
41-170 . {
41-171 . A = B + C;
41-172 . D = E + F;
41-173 . }
41-174 .
41-175 . A = B+C;
41-176 . A = B-C;
41-177 . A = B/C;
41-178 . A = 0x0003;
41-179 . /* dead_code = A * B; */
41-180 . A = B+C;
41-181 .
41-182 . if (A < = B)
41-183 . {
41-184 . A = B + C;
41-185 . D = E + F;
41-186 . }
41-187 .
41-188 . A = B/C;
41-189 .
41-190 . if (A le B)
41-191 . {
41-192 . A = B + C;
41-193 . D = E + F;
41-194 . }
41-195 .
41-196 . A = B/C;
41-197 . A = B-C;
41-198 . A = B/C;
41-199 . A = B/C;
41-200 . A = B+C;
41-201 . A = B*C;
41-202 . A = B+C;
41-203 . A = B*C;
41-204 .
41-205 . if (A != B)
41-206 . {
41-207 . A = B + C;
41-208 . D = E + F;
41-209 . }
41-210 .
41-211 .
41-212 . if (A lt B)
41-213 . {
41-214 . A = B + C;
41-215 . D = E + F;
41-216 . }
41-217 .
41-218 . A = B/C;
41-219 . A = B-C;
41-220 . A = B+C;
41-221 . A = B*C;
41-222 . A = B/C;
41-223 .
41-224 . if (A le B)
41-225 . {
41-226 . A = B + C;
41-227 . D = E + F;
41-228 . }
41-229 .
41-230 . A = B+C;
41-231 .
41-232 . if (A < B)
41-233 . {
41-234 . A = B + C;
41-235 . D = E + F;
41-236 . }
41-237 .
41-238 .
41-239 . if (A < B)
41-240 . {
41-241 . A = B + C;
41-242 . D = E + F;
41-243 . }
41-244 .
41-245 . A = B+C;
41-246 . /* LE SV TOC-2211 this is a msaw-03.1.60 req to compare*/
41-247 . A = B*C;
41-248 .
41-249 . switch (msaw stuff)
41-250 . {
41-251 . case one:
41-252 . {
41-253 . run_this;
41-254 . break;
41-255 . }
41-256 . case two:
41-257 . {
41-258 . run_this;
41-259 . break;
41-260 . }
41-261 . default:
41-262 . {
41-263 . SwError;
41-264 . }
41-265 . }
41-266 .
41-267 .
41-268 . if (A != B)
41-269 . {
41-270 . A = B + C;
41-271 . D = E + F;
41-272 . }
41-273 .
41-274 .
41-275 . if (A lt B)
41-276 . {
41-277 . A = B + C;
41-278 . D = E + F;
41-279 . }
41-280 .
41-281 . A = B*C;
41-282 .
41-283 . if (A == B)
41-284 . {
41-285 . A = B + C;
41-286 . D = E + F;
41-287 . }
41-288 .
41-289 . A = B-C;
41-290 .
41-291 . if (A < B)
41-292 . {
41-293 . A = B + C;
41-294 . D = E + F;
41-295 . }
41-296 .
41-297 .
41-298 . if (A ne B)
41-299 . {
41-300 . A = B + C;
41-301 . D = E + F;
41-302 . }
41-303 .
41-304 . A = B*C;
41-305 . A = B/C;
41-306 .
41-307 . if (A ne B)
41-308 . {
41-309 . A = B + C;
41-310 . D = E + F;
41-311 . }
41-312 .
41-313 .
41-314 . if (A != B)
41-315 . {
41-316 . A = B + C;
41-317 . D = E + F;
41-318 . }
41-319 .
41-320 . A = B-C;
41-321 . A = B*C;
41-322 .
41-323 . if (A ge B)
41-324 . {
41-325 . A = B + C;
41-326 . D = E + F;
41-327 . }
41-328 .
41-329 . /* LE SV TOC-2212 this is a msaw-03.1.76 req to call isr*/
41-330 . A = B+C;
41-331 . A = B/C;
41-332 .
41-333 . switch (msaw stuff)
41-334 . {
41-335 . case one:
41-336 . {
41-337 . run_this;
41-338 . // missing break
41-339 . }
41-340 . case two:
41-341 . {
41-342 . run_this;
41-343 . break;
41-344 . }
41-345 . default:
41-346 . {
41-347 . SwError;
41-348 . }
41-349 . }
41-350 .
41-351 .
41-352 . if (A == B)
41-353 . {
41-354 . A = B + C;
41-355 . D = E + F;
41-356 . }
41-357 .
41-358 .
41-359 . if (A < B)
41-360 . {
41-361 . A = B + C;
41-362 . D = E + F;
41-363 . }
41-364 .
41-365 . A = B*C;
41-366 .
41-367 . if (A != B)
41-368 . {
41-369 . A = B + C;
41-370 . D = E + F;
41-371 . }
41-372 .
41-373 . A = B*C;
41-374 . A = B-C;
41-375 . // max LOC 83
41-376 .
41-377 . }
41-378 .
41-379 .
41-380 . /*
41-381 . -----------------------------------------------------------------------------
41-382 . --| NAME: msaw.3.2
41-383 . --|
41-384 . --| ABSTRACT:
41-385 . --| This function does msaw stuff.
41-386 . --|
41-387 . --| RETURNS:
41-388 . --| NONE.
41-389 . --|
41-390 . ----------------------------------------------------------------------------
41-391 . */
41-392 . static void msaw.3.2(void)
41-393 . {
41-394 . A = B+C;
41-395 . A = B+C;
41-396 . A = B*C;
41-397 . A = B/C;
41-398 . A = B+C;
41-399 . A = B*C;
41-400 .
41-401 . if (A ge B)
41-402 . {
41-403 . A = B + C;
41-404 . D = E + F;
41-405 . }
41-406 .
41-407 . A = B-C;
41-408 . A = B*C;
41-409 . /* LE SV TOC-2213 this is a msaw-03.2.10 req to convert*/
41-410 .
41-411 . if (veg)
41-412 . // missing curly brace
41-413 . variable = orange;
41-414 .
41-415 . A = B*C;
41-416 .
41-417 . if (A ge B)
41-418 . {
41-419 . A = B + C;
41-420 . D = E + F;
41-421 . }
41-422 .
41-423 .
41-424 . if (A lt B)
41-425 . {
41-426 . A = B + C;
41-427 . D = E + F;
41-428 . }
41-429 .
41-430 .
41-431 . if (veg)
41-432 . // missing curly brace
41-433 . variable = orange;
41-434 .
41-435 . A = B*C;
41-436 .
41-437 . if (A ge B)
41-438 . {
41-439 . A = B + C;
41-440 . D = E + F;
41-441 . }
41-442 .
41-443 . A = B*C;
41-444 .
41-445 . if (A ge B)
41-446 . {
41-447 . A = B + C;
41-448 . D = E + F;
41-449 . }
41-450 .
41-451 . A = B-C;
41-452 .
41-453 . switch (msaw stuff)
41-454 . {
41-455 . case one:
41-456 . {
41-457 . run_this;
41-458 . break;
41-459 . }
41-460 . case two:
41-461 . {
41-462 . run_this;
41-463 . break;
41-464 . }
41-465 . default:
41-466 . {
41-467 . SwError;
41-468 . }
41-469 . }
41-470 .
41-471 . A = B+C;
41-472 . A = B+C;
41-473 . A = B*C;
41-474 .
41-475 . if (A < B)
41-476 . {
41-477 . A = B + C;
41-478 . D = E + F;
41-479 . }
41-480 .
41-481 . A = B*C;
41-482 . A = B+C;
41-483 . A = B+C;
41-484 . A = B-C;
41-485 . A = B/C;
41-486 .
41-487 . if (A gt B)
41-488 . {
41-489 . A = B + C;
41-490 . D = E + F;
41-491 . }
41-492 .
41-493 . A = B-C;
41-494 . A = B*C;
41-495 .
41-496 . if (A le B)
41-497 . {
41-498 . A = B + C;
41-499 . D = E + F;
41-500 . }
41-501 .
41-502 . A = B+C;
41-503 . A = B/C;
41-504 . A = B-C;
41-505 . A = B-C;
41-506 .
41-507 . if (A > = B)
41-508 . {
41-509 . A = B + C;
41-510 . D = E + F;
41-511 . }
41-512 .
41-513 .
41-514 . if (A == B)
41-515 . {
41-516 . A = B + C;
41-517 . D = E + F;
41-518 . }
41-519 .
41-520 . A = B/C;
41-521 . A = B+C;
41-522 .
41-523 . if (A ne B)
41-524 . {
41-525 . A = B + C;
41-526 . D = E + F;
41-527 . }
41-528 .
41-529 .
41-530 . if (A ne B)
41-531 . {
41-532 . A = B + C;
41-533 . D = E + F;
41-534 . }
41-535 .
41-536 . A = B+C;
41-537 . goto error;
41-538 . A = B-C;
41-539 . A = B-C;
41-540 . A = B-C;
41-541 . A = B+C;
41-542 . A = B/C;
41-543 . /* LE SV TOC-2214 this is a msaw-03.2.48 req to store*/
41-544 . A = B/C;
41-545 .
41-546 . if (A eq B)
41-547 . {
41-548 . A = B + C;
41-549 . D = E + F;
41-550 . }
41-551 .
41-552 . /* LE SV TOC-2215 this is a msaw-03.2.50 req to fail*/
41-553 . A = B*C;
41-554 .
41-555 . if (A > = B)
41-556 . {
41-557 . A = B + C;
41-558 . D = E + F;
41-559 . }
41-560 .
41-561 . A = B-C;
41-562 .
41-563 . if (A == B)
41-564 . {
41-565 . A = B + C;
41-566 . D = E + F;
41-567 . }
41-568 .
41-569 . A = B*C;
41-570 . A = B-C;
41-571 .
41-572 . if (A eq B)
41-573 . {
41-574 . A = B + C;
41-575 . D = E + F;
41-576 . }
41-577 .
41-578 .
41-579 . if (A < = B)
41-580 . {
41-581 . A = B + C;
41-582 . D = E + F;
41-583 . }
41-584 .
41-585 .
41-586 . if (A ne B)
41-587 . {
41-588 . A = B + C;
41-589 . D = E + F;
41-590 . }
41-591 .
41-592 . A = B-C;
41-593 . A = B*C;
41-594 .
41-595 . if (A != B)
41-596 . {
41-597 . A = B + C;
41-598 . D = E + F;
41-599 . }
41-600 .
41-601 . A = B*C;
41-602 . A = B/C;
41-603 . A = B/C;
41-604 . A = B-C;
41-605 . A = B+C;
41-606 . A = B-C;
41-607 .
41-608 . if (A gt B)
41-609 . {
41-610 . A = B + C;
41-611 . D = E + F;
41-612 . }
41-613 .
41-614 . A = B/C;
41-615 .
41-616 . /* dead_code = B + C;
41-617 . dead_code = D + E;
41-618 . dead_code = F + G; */
41-619 .
41-620 . A = B-C;
41-621 .
41-622 . /* dead_block = C * D;
41-623 . dead_block = E * F; */
41-624 .
41-625 . A = B*C;
41-626 .
41-627 . if (A le B)
41-628 . {
41-629 . A = B + C;
41-630 . D = E + F;
41-631 . }
41-632 .
41-633 .
41-634 . if (A > B)
41-635 . {
41-636 . A = B + C;
41-637 . D = E + F;
41-638 . }
41-639 .
41-640 . // max LOC 73
41-641 .
41-642 . }
41-643 .
41-644 .
41-645 . /*
41-646 . -----------------------------------------------------------------------------
41-647 . --| NAME: msaw.3.3
41-648 . --|
41-649 . --| ABSTRACT:
41-650 . --| This function does msaw stuff.
41-651 . --|
41-652 . --| RETURNS:
41-653 . --| NONE.
41-654 . --|
41-655 . ----------------------------------------------------------------------------
41-656 . */
41-657 . static void msaw.3.3(void)
41-658 . {
41-659 . A = B*C;
41-660 . A = B-C;
41-661 . A = B*C;
41-662 . A = B*C;
41-663 .
41-664 . if (A lt B)
41-665 . {
41-666 . A = B + C;
41-667 . D = E + F;
41-668 . }
41-669 .
41-670 . A = B/C;
41-671 . A = B+C;
41-672 .
41-673 . if (A gt B)
41-674 . {
41-675 . A = B + C;
41-676 . D = E + F;
41-677 . }
41-678 .
41-679 .
41-680 . if (A gt B)
41-681 . {
41-682 . A = B + C;
41-683 . D = E + F;
41-684 . }
41-685 .
41-686 .
41-687 . if (A < B)
41-688 . {
41-689 . A = B + C;
41-690 . D = E + F;
41-691 . }
41-692 .
41-693 . A = B-C;
41-694 .
41-695 . if (A ge B)
41-696 . {
41-697 . A = B + C;
41-698 . D = E + F;
41-699 . }
41-700 .
41-701 . A = B*C;
41-702 . A = B+C;
41-703 . A = B-C;
41-704 . A = B/C;
41-705 .
41-706 . switch (msaw stuff)
41-707 . {
41-708 . case one:
41-709 . {
41-710 . switch (nested)
41-711 . {
41-712 . case:
41-713 . X = Y + Z;
41-714 . case:
41-715 . X = Y + Z;
41-716 . default:
41-717 . SwError;
41-718 . }
41-719 . }
41-720 . case two:
41-721 . {
41-722 . run_this;
41-723 . break;
41-724 . }
41-725 . default:
41-726 . {
41-727 . SwError;
41-728 . }
41-729 . }
41-730 .
41-731 . A = B-C;
41-732 . A = B+C;
41-733 . A = B+C;
41-734 . A = B-C;
41-735 . A = B*C;
41-736 .
41-737 . if (A lt B)
41-738 . {
41-739 . A = B + C;
41-740 . D = E + F;
41-741 . }
41-742 .
41-743 . A = B/C;
41-744 . A = B*C;
41-745 . A = B/C;
41-746 . A = B/C;
41-747 . A = B+C;
41-748 . A = B/C;
41-749 . A = B+C;
41-750 . A = B+C;
41-751 . A = B+C;
41-752 .
41-753 . if (A == B)
41-754 . {
41-755 . A = B + C;
41-756 . D = E + F;
41-757 . }
41-758 .
41-759 . A = B+C;
41-760 .
41-761 . if (A < = B)
41-762 . {
41-763 . A = B + C;
41-764 . D = E + F;
41-765 . }
41-766 .
41-767 . A = B-C;
41-768 . A = B/C;
41-769 .
41-770 . if (A ge B)
41-771 . {
41-772 . A = B + C;
41-773 . D = E + F;
41-774 . }
41-775 .
41-776 . /* LE SV TOC-2216 this is a msaw-03.3.38 req to call admin*/
41-777 . A = B-C;
41-778 .
41-779 . if (A == B)
41-780 . {
41-781 . A = B + C;
41-782 . D = E + F;
41-783 . }
41-784 .
41-785 .
41-786 . if (A > B)
41-787 . {
41-788 . A = B + C;
41-789 . D = E + F;
41-790 . }
41-791 .
41-792 . A = B-C;
41-793 . A = B+C;
41-794 .
41-795 . if (A < = B)
41-796 . {
41-797 . A = B + C;
41-798 . D = E + F;
41-799 . }
41-800 .
41-801 . A = 0x0001;
41-802 .
41-803 . switch (msaw stuff)
41-804 . {
41-805 . case one:
41-806 . {
41-807 . run_this;
41-808 . break;
41-809 . }
41-810 . case two:
41-811 . {
41-812 . run_this;
41-813 . break;
41-814 . }
41-815 . default:
41-816 . {
41-817 . SwError;
41-818 . }
41-819 . }
41-820 .
41-821 . A = B/C;
41-822 .
41-823 . if (A == B)
41-824 . {
41-825 . A = B + C;
41-826 . D = E + F;
41-827 . }
41-828 .
41-829 . A = B/C;
41-830 .
41-831 . if (A lt B)
41-832 . {
41-833 . A = B + C;
41-834 . D = E + F;
41-835 . }
41-836 .
41-837 . A = B*C;
41-838 . A = B/C;
41-839 . A = B+C;
41-840 .
41-841 . switch (msaw stuff)
41-842 . {
41-843 . case one:
41-844 . {
41-845 . run_this;
41-846 . break;
41-847 . }
41-848 . case two:
41-849 . {
41-850 . run_this;
41-851 . break;
41-852 . }
41-853 . // missing default
41-854 . }
41-855 .
41-856 .
41-857 . if (A == B)
41-858 . {
41-859 . A = B + C;
41-860 . D = E + F;
41-861 . }
41-862 .
41-863 . A = B*C;
41-864 . A = B+C;
41-865 .
41-866 . if (A < B)
41-867 . {
41-868 . A = B + C;
41-869 . D = E + F;
41-870 . }
41-871 .
41-872 . A = B*C;
41-873 . A = B*C;
41-874 .
41-875 . if (A ne B)
41-876 . {
41-877 . A = B + C;
41-878 . D = E + F;
41-879 . }
41-880 .
41-881 .
41-882 . if (A gt B)
41-883 . {
41-884 . A = B + C;
41-885 . D = E + F;
41-886 . }
41-887 .
41-888 . A = B-C;
41-889 . A = B+C;
41-890 . A = B/C;
41-891 . // max LOC 62
41-892 .
41-893 . }
41-894 .
41-895 .
41-896 . /*
41-897 . -----------------------------------------------------------------------------
41-898 . --| NAME: msaw.3.4
41-899 . --|
41-900 . --| ABSTRACT:
41-901 . --| This function does msaw stuff.
41-902 . --|
41-903 . --| RETURNS:
41-904 . --| NONE.
41-905 . --|
41-906 . ----------------------------------------------------------------------------
41-907 . */
41-908 . static void msaw.3.4(void)
41-909 . {
41-910 . A = B/C;
41-911 .
41-912 . if (A lt B)
41-913 . {
41-914 . A = B + C;
41-915 . D = E + F;
41-916 . }
41-917 .
41-918 . A = B-C;
41-919 . A = B/C;
41-920 . /* LE SV TOC-2217 this is a msaw-03.4.5 req to update*/
41-921 . A = B*C;
41-922 . A = B*C;
41-923 . A = B/C;
41-924 . A = B/C;
41-925 .
41-926 . if (A != B)
41-927 . {
41-928 . A = B + C;
41-929 . D = E + F;
41-930 . }
41-931 .
41-932 . A = B/C;
41-933 . A = B+C;
41-934 . A = B/C;
41-935 . A = B+C;
41-936 . A = B-C;
41-937 . A = B-C;
41-938 .
41-939 . if (A > B)
41-940 . {
41-941 . A = B + C;
41-942 . D = E + F;
41-943 . }
41-944 .
41-945 . A = B-C;
41-946 . A = B/C;
41-947 . A = B+C;
41-948 . A = B*C;
41-949 . A = B+C;
41-950 . A = B+C;
41-951 . A = B/C;
41-952 . A = B/C;
41-953 .
41-954 . if (A lt B)
41-955 . {
41-956 . A = B + C;
41-957 . D = E + F;
41-958 . }
41-959 .
41-960 . A = B*C;
41-961 . A = B+C;
41-962 .
41-963 . if (A == B)
41-964 . {
41-965 . A = B + C;
41-966 . D = E + F;
41-967 . }
41-968 .
41-969 .
41-970 . if (A < = B)
41-971 . {
41-972 . A = B + C;
41-973 . D = E + F;
41-974 . }
41-975 .
41-976 . A = B-C;
41-977 . A = B+C;
41-978 . A = B-C;
41-979 . A = B*C;
41-980 . A = B-C;
41-981 . A = B/C;
41-982 . /* LE SV TOC-2218 this is a msaw-03.4.36 req to set RTC*/
41-983 . A = B-C;
41-984 . A = 0x0002;
41-985 .
41-986 . if (A eq B)
41-987 . {
41-988 . A = B + C;
41-989 . D = E + F;
41-990 . }
41-991 .
41-992 . A = B+C;
41-993 .
41-994 . if (A ge B)
41-995 . {
41-996 . A = B + C;
41-997 . D = E + F;
41-998 . }
41-999 .
41-1000 . A = B/C;
41-1001 . A = B/C;
41-1002 . A = B/C;
41-1003 .
41-1004 . if (A eq B)
41-1005 . {
41-1006 . A = B + C;
41-1007 . D = E + F;
41-1008 . }
41-1009 .
41-1010 .
41-1011 . if (A le B)
41-1012 . {
41-1013 . A = B + C;
41-1014 . D = E + F;
41-1015 . }
41-1016 .
41-1017 . // max LOC 44
41-1018 .
41-1019 . }
41-1020 .
41-1021 .
41-1022 . /*
41-1023 . -----------------------------------------------------------------------------
41-1024 . --| NAME: msaw.3.5
41-1025 . --|
41-1026 . --| ABSTRACT:
41-1027 . --| This function does msaw stuff.
41-1028 . --|
41-1029 . --| RETURNS:
41-1030 . --| NONE.
41-1031 . --|
41-1032 . ----------------------------------------------------------------------------
41-1033 . */
41-1034 . static void msaw.3.5(void)
41-1035 . {
41-1036 . A = B*C;
41-1037 . A = B-C;
41-1038 . A = B-C;
41-1039 . /* LE SV TOC-2219 this is a msaw-03.5.4 req to store*/
41-1040 . A = B/C;
41-1041 . A = B*C;
41-1042 .
41-1043 . if (A < = B)
41-1044 . {
41-1045 . A = B + C;
41-1046 . D = E + F;
41-1047 . }
41-1048 .
41-1049 . A = B+C;
41-1050 .
41-1051 . if (A eq B)
41-1052 . {
41-1053 . A = B + C;
41-1054 . D = E + F;
41-1055 . }
41-1056 .
41-1057 . A = B*C;
41-1058 . A = B/C;
41-1059 .
41-1060 . if (A > B)
41-1061 . {
41-1062 . A = B + C;
41-1063 . D = E + F;
41-1064 . }
41-1065 .
41-1066 .
41-1067 . if (A lt B)
41-1068 . {
41-1069 . A = B + C;
41-1070 . D = E + F;
41-1071 . }
41-1072 .
41-1073 . A = B+C;
41-1074 .
41-1075 . if (A > B)
41-1076 . {
41-1077 . A = B + C;
41-1078 . D = E + F;
41-1079 . }
41-1080 .
41-1081 . A = B-C;
41-1082 .
41-1083 . if (A < B)
41-1084 . {
41-1085 . A = B + C;
41-1086 . D = E + F;
41-1087 . }
41-1088 .
41-1089 . A = B+C;
41-1090 . A = B-C;
41-1091 . A = B-C;
41-1092 . A = B-C;
41-1093 . A = B-C;
41-1094 . A = B-C;
41-1095 . A = B*C;
41-1096 . A = B+C;
41-1097 . A = B+C;
41-1098 .
41-1099 . if (A gt B)
41-1100 . {
41-1101 . A = B + C;
41-1102 . D = E + F;
41-1103 . }
41-1104 .
41-1105 . A = B/C;
41-1106 . A = B*C;
41-1107 . A = B-C;
41-1108 . A = B/C;
41-1109 . // max LOC 30
41-1110 .
41-1111 . }
41-1112 .
41-1113 .
41-1114 . /*
41-1115 . -----------------------------------------------------------------------------
41-1116 . --| NAME: msaw.3.6
41-1117 . --|
41-1118 . --| ABSTRACT:
41-1119 . --| This function does msaw stuff.
41-1120 . --|
41-1121 . --| RETURNS:
41-1122 . --| NONE.
41-1123 . --|
41-1124 . ----------------------------------------------------------------------------
41-1125 . */
41-1126 . static void msaw.3.6(void)
41-1127 . {
41-1128 . A = B/C;
41-1129 . A = 0x0007;
41-1130 . A = B+C;
41-1131 .
41-1132 . if (A < B)
41-1133 . {
41-1134 . A = B + C;
41-1135 . D = E + F;
41-1136 . }
41-1137 .
41-1138 .
41-1139 . /*
41-1140 . dead_block = C * D;
41-1141 . dead_block = E * F;
41-1142 . */
41-1143 .
41-1144 .
41-1145 . if (A != B)
41-1146 . {
41-1147 . A = B + C;
41-1148 . D = E + F;
41-1149 . }
41-1150 .
41-1151 . A = B+C;
41-1152 . A = B*C;
41-1153 . A = 0x0006;
41-1154 . A = B-C;
41-1155 .
41-1156 . if (A le B)
41-1157 . {
41-1158 . A = B + C;
41-1159 . D = E + F;
41-1160 . }
41-1161 .
41-1162 .
41-1163 . if (veg)
41-1164 . // missing curly brace
41-1165 . variable = orange;
41-1166 .
41-1167 . A = B/C;
41-1168 .
41-1169 . switch (msaw stuff)
41-1170 . {
41-1171 . case:
41-1172 . case:
41-1173 . // stacked case statements but only if there is a new line in between
41-1174 .
41-1175 . case:
41-1176 . case:
41-1177 . case:
41-1178 . {
41-1179 . run_this;
41-1180 . break;
41-1181 . }
41-1182 . default:
41-1183 . {
41-1184 . halt;
41-1185 . }
41-1186 . }
41-1187 .
41-1188 . A = B/C;
41-1189 . A = 0x0002;
41-1190 .
41-1191 . if (A < B)
41-1192 . {
41-1193 . A = B + C;
41-1194 . D = E + F;
41-1195 . }
41-1196 .
41-1197 . A = B-C;
41-1198 . A = B/C;
41-1199 .
41-1200 . if (A ne B)
41-1201 . {
41-1202 . A = B + C;
41-1203 . D = E + F;
41-1204 . }
41-1205 .
41-1206 . A = B-C;
41-1207 . A = B/C;
41-1208 .
41-1209 . if (A != B)
41-1210 . {
41-1211 . A = B + C;
41-1212 . D = E + F;
41-1213 . }
41-1214 .
41-1215 . A = B-C;
41-1216 .
41-1217 . if (A != B)
41-1218 . {
41-1219 . A = B + C;
41-1220 . D = E + F;
41-1221 . }
41-1222 .
41-1223 . A = B/C;
41-1224 . A = B+C;
41-1225 .
41-1226 . if (A lt B)
41-1227 . {
41-1228 . A = B + C;
41-1229 . D = E + F;
41-1230 . }
41-1231 .
41-1232 . A = B-C;
41-1233 . A = B/C;
41-1234 . A = B/C;
41-1235 .
41-1236 . if (A eq B)
41-1237 . {
41-1238 . A = B + C;
41-1239 . D = E + F;
41-1240 . }
41-1241 .
41-1242 . A = B-C;
41-1243 . A = B+C;
41-1244 . A = B-C;
41-1245 . A = B*C;
41-1246 . A = B/C;
41-1247 .
41-1248 . if (A gt B)
41-1249 . {
41-1250 . A = B + C;
41-1251 . D = E + F;
41-1252 . }
41-1253 .
41-1254 .
41-1255 . if (A < = B)
41-1256 . {
41-1257 . A = B + C;
41-1258 . D = E + F;
41-1259 . }
41-1260 .
41-1261 . A = B*C;
41-1262 . A = B*C;
41-1263 . A = B+C;
41-1264 . A = B+C;
41-1265 . A = B*C;
41-1266 .
41-1267 . if (A == B)
41-1268 . {
41-1269 . A = B + C;
41-1270 . D = E + F;
41-1271 . }
41-1272 .
41-1273 .
41-1274 . if (A ne B)
41-1275 . {
41-1276 . A = B + C;
41-1277 . D = E + F;
41-1278 . }
41-1279 .
41-1280 . A = B*C;
41-1281 . A = B/C;
41-1282 . A = B+C;
41-1283 .
41-1284 . if ($msaw stuff > $othermsaw stuff)
41-1285 . /* LE SV TOC-008 we really should log all error calls */
41-1286 . {
41-1287 . A = B + C;
41-1288 . }
41-1289 .
41-1290 .
41-1291 . if (A > B)
41-1292 . {
41-1293 . A = B + C;
41-1294 . D = E + F;
41-1295 . }
41-1296 .
41-1297 . A = B-C;
41-1298 . A = B+C;
41-1299 . A = B/C;
41-1300 . /* LE SV TOC-2220 this is a msaw-03.6.48 req to assign*/
41-1301 . A = B+C;
41-1302 . A = B-C;
41-1303 .
41-1304 . switch (msaw stuff)
41-1305 . {
41-1306 . case one:
41-1307 . {
41-1308 . run_this;
41-1309 . break;
41-1310 . }
41-1311 . case two:
41-1312 . {
41-1313 . run_this;
41-1314 . break;
41-1315 . }
41-1316 . default:
41-1317 . {
41-1318 . SwError;
41-1319 . }
41-1320 . }
41-1321 .
41-1322 . /* LE SV TOC-2221 this is a msaw-03.6.51 req to detect error*/
41-1323 .
41-1324 . if (A > = B)
41-1325 . {
41-1326 . A = B + C;
41-1327 . D = E + F;
41-1328 . }
41-1329 .
41-1330 . /* LE SV TOC-2222 this is a msaw-03.6.52 req to call admin*/
41-1331 . A = B*C;
41-1332 . A = B-C;
41-1333 . A = B-C;
41-1334 . A = B+C;
41-1335 .
41-1336 . switch (msaw stuff)
41-1337 . {
41-1338 . case one:
41-1339 . {
41-1340 . run_this;
41-1341 . break;
41-1342 . }
41-1343 . case two:
41-1344 . {
41-1345 . run_this;
41-1346 . break;
41-1347 . }
41-1348 . default:
41-1349 . {
41-1350 . SwError;
41-1351 . }
41-1352 . }
41-1353 .
41-1354 . A = B*C;
41-1355 . // max LOC 57
41-1356 .
41-1357 . }
41-1358 .
41-1359 .
41-1360 . /*
41-1361 . -----------------------------------------------------------------------------
41-1362 . --| NAME: msaw.3.7
41-1363 . --|
41-1364 . --| ABSTRACT:
41-1365 . --| This function does msaw stuff.
41-1366 . --|
41-1367 . --| RETURNS:
41-1368 . --| NONE.
41-1369 . --|
41-1370 . ----------------------------------------------------------------------------
41-1371 . */
41-1372 . static void msaw.3.7(void)
41-1373 . {
41-1374 . A = B+C;
41-1375 . A = B-C;
41-1376 .
41-1377 . if (A ne B)
41-1378 . {
41-1379 . A = B + C;
41-1380 . D = E + F;
41-1381 . }
41-1382 .
41-1383 . A = B+C;
41-1384 . A = 0x0008;
41-1385 . A = B/C;
41-1386 . A = B-C;
41-1387 .
41-1388 . if (veg)
41-1389 . // missing curly brace
41-1390 . variable = orange;
41-1391 .
41-1392 .
41-1393 . if (A ge B)
41-1394 . {
41-1395 . A = B + C;
41-1396 . D = E + F;
41-1397 . }
41-1398 .
41-1399 . A = B/C;
41-1400 . /* LE SV TOC-2223 this is a msaw-03.7.9 req to audit*/
41-1401 . A = B-C;
41-1402 . A = B+C;
41-1403 . A = B*C;
41-1404 . A = B+C;
41-1405 . A = B+C;
41-1406 . A = B*C;
41-1407 . /* LE SV TOC-2224 this is a msaw-03.7.15 req to reject*/
41-1408 . A = B/C;
41-1409 . A = B*C;
41-1410 . A = B-C;
41-1411 .
41-1412 . if (A eq B)
41-1413 . {
41-1414 . A = B + C;
41-1415 . D = E + F;
41-1416 . }
41-1417 .
41-1418 . A = B*C;
41-1419 .
41-1420 . if (A ne B)
41-1421 . {
41-1422 . A = B + C;
41-1423 . D = E + F;
41-1424 . }
41-1425 .
41-1426 . A = B/C;
41-1427 .
41-1428 . switch (msaw stuff)
41-1429 . {
41-1430 . case one:
41-1431 . {
41-1432 . run_this;
41-1433 . break;
41-1434 . }
41-1435 . case two:
41-1436 . {
41-1437 . run_this;
41-1438 . break;
41-1439 . }
41-1440 . default:
41-1441 . {
41-1442 . SwError;
41-1443 . }
41-1444 . }
41-1445 .
41-1446 . A = B/C;
41-1447 . A = B+C;
41-1448 .
41-1449 . if (A gt B)
41-1450 . {
41-1451 . A = B + C;
41-1452 . D = E + F;
41-1453 . }
41-1454 .
41-1455 .
41-1456 . switch (msaw stuff)
41-1457 . {
41-1458 . case one:
41-1459 . {
41-1460 . run_this;
41-1461 . break;
41-1462 . }
41-1463 . case two:
41-1464 . {
41-1465 . run_this;
41-1466 . break;
41-1467 . }
41-1468 . default:
41-1469 . {
41-1470 . SwError;
41-1471 . }
41-1472 . }
41-1473 .
41-1474 . A = B+C;
41-1475 . A = B*C;
41-1476 .
41-1477 . if (A > = B)
41-1478 . {
41-1479 . A = B + C;
41-1480 . D = E + F;
41-1481 . }
41-1482 .
41-1483 . A = B+C;
41-1484 .
41-1485 . if (A eq B)
41-1486 . {
41-1487 . A = B + C;
41-1488 . D = E + F;
41-1489 . }
41-1490 .
41-1491 . A = B/C;
41-1492 . A = B/C;
41-1493 .
41-1494 . if (A ne B)
41-1495 . {
41-1496 . A = B + C;
41-1497 . D = E + F;
41-1498 . }
41-1499 .
41-1500 . A = B*C;
41-1501 . A = B-C;
41-1502 . A = B*C;
41-1503 . A = (int)B + C;
41-1504 .
41-1505 . switch (msaw stuff)
41-1506 . {
41-1507 . case one:
41-1508 . {
41-1509 . run_this;
41-1510 . break;
41-1511 . }
41-1512 . case two:
41-1513 . {
41-1514 . run_this;
41-1515 . break;
41-1516 . }
41-1517 . default:
41-1518 . {
41-1519 . SwError;
41-1520 . }
41-1521 . }
41-1522 .
41-1523 . A = B+C;
41-1524 . A = B/C;
41-1525 . A = B/C;
41-1526 . A = B-C;
41-1527 . /* LE SV TOC-2225 this is a msaw-03.7.43 req to record*/
41-1528 . A = B/C;
41-1529 . A = B-C;
41-1530 . A = B*C;
41-1531 . A = B-C;
41-1532 .
41-1533 . if (A == B)
41-1534 . {
41-1535 . A = B + C;
41-1536 . D = E + F;
41-1537 . }
41-1538 .
41-1539 .
41-1540 . if (A > = B)
41-1541 . {
41-1542 . A = B + C;
41-1543 . D = E + F;
41-1544 . }
41-1545 .
41-1546 . A = B/C;
41-1547 .
41-1548 . switch (msaw stuff)
41-1549 . {
41-1550 . case one:
41-1551 . {
41-1552 . run_this;
41-1553 . break;
41-1554 . }
41-1555 . case two:
41-1556 . {
41-1557 . run_this;
41-1558 . break;
41-1559 . }
41-1560 . // missing default
41-1561 . }
41-1562 .
41-1563 .
41-1564 . if (A ne B)
41-1565 . {
41-1566 . A = B + C;
41-1567 . D = E + F;
41-1568 . }
41-1569 .
41-1570 . A = B+C;
41-1571 . A = B/C;
41-1572 .
41-1573 . if (A le B)
41-1574 . {
41-1575 . A = B + C;
41-1576 . D = E + F;
41-1577 . }
41-1578 .
41-1579 .
41-1580 . if (A le B)
41-1581 . {
41-1582 . A = B + C;
41-1583 . D = E + F;
41-1584 . }
41-1585 .
41-1586 .
41-1587 . if (A ge B)
41-1588 . {
41-1589 . A = B + C;
41-1590 . D = E + F;
41-1591 . }
41-1592 .
41-1593 .
41-1594 . switch (msaw stuff)
41-1595 . {
41-1596 . case one:
41-1597 . {
41-1598 . run_this;
41-1599 . break;
41-1600 . }
41-1601 . case two:
41-1602 . {
41-1603 . run_this;
41-1604 . break;
41-1605 . }
41-1606 . default:
41-1607 . {
41-1608 . SwError;
41-1609 . }
41-1610 . }
41-1611 .
41-1612 . A = B-C;
41-1613 . A = B-C;
41-1614 . A = 0x0009;
41-1615 . A = B*C;
41-1616 .
41-1617 . if {
41-1618 . X = Y + Z;
41-1619 . }
41-1620 . else {
41-1621 . halt;
41-1622 . }
41-1623 .
41-1624 . A = B+C;
41-1625 .
41-1626 . if (A gt B)
41-1627 . {
41-1628 . A = B + C;
41-1629 . D = E + F;
41-1630 . }
41-1631 .
41-1632 . A = B*C;
41-1633 .
41-1634 . if (A ne B)
41-1635 . {
41-1636 . A = B + C;
41-1637 . D = E + F;
41-1638 . }
41-1639 .
41-1640 .
41-1641 . if (A ge B)
41-1642 . {
41-1643 . A = B + C;
41-1644 . D = E + F;
41-1645 . }
41-1646 .
41-1647 .
41-1648 . if (A > B)
41-1649 . {
41-1650 . A = B + C;
41-1651 . D = E + F;
41-1652 . }
41-1653 .
41-1654 . /* LE SV TOC-2226 this is a msaw-03.7.66 req to translate*/
41-1655 .
41-1656 . if (A le B)
41-1657 . {
41-1658 . A = B + C;
41-1659 . D = E + F;
41-1660 . }
41-1661 .
41-1662 . A = B*C;
41-1663 .
41-1664 . if (A eq B)
41-1665 . {
41-1666 . A = B + C;
41-1667 . D = E + F;
41-1668 . }
41-1669 .
41-1670 . A = B+C;
41-1671 .
41-1672 . if (A > = B)
41-1673 . {
41-1674 . A = B + C;
41-1675 . D = E + F;
41-1676 . }
41-1677 .
41-1678 . A = B+C;
41-1679 .
41-1680 . switch (msaw stuff)
41-1681 . {
41-1682 . case one:
41-1683 . {
41-1684 . run_this;
41-1685 . break;
41-1686 . }
41-1687 . case two:
41-1688 . {
41-1689 . run_this;
41-1690 . break;
41-1691 . }
41-1692 . default:
41-1693 . {
41-1694 . SwError;
41-1695 . }
41-1696 . }
41-1697 .
41-1698 . A = B-C;
41-1699 . // max LOC 73
41-1700 .
41-1701 . }
41-1702 .
41-1703 .
41-1704 . /*
41-1705 . -----------------------------------------------------------------------------
41-1706 . --| NAME: msaw.3.8
41-1707 . --|
41-1708 . --| ABSTRACT:
41-1709 . --| This function does msaw stuff.
41-1710 . --|
41-1711 . --| RETURNS:
41-1712 . --| NONE.
41-1713 . --|
41-1714 . ----------------------------------------------------------------------------
41-1715 . */
41-1716 . static void msaw.3.8(void)
41-1717 . {
41-1718 . A = B*C;
41-1719 . A = B*C;
41-1720 .
41-1721 . if (A > B)
41-1722 . {
41-1723 . A = B + C;
41-1724 . D = E + F;
41-1725 . }
41-1726 .
41-1727 .
41-1728 . if (A != B)
41-1729 . {
41-1730 . A = B + C;
41-1731 . D = E + F;
41-1732 . }
41-1733 .
41-1734 . /* LE SV TOC-2227 this is a msaw-03.8.5 req to reject*/
41-1735 . A = B+C;
41-1736 . A = B/C;
41-1737 . A = B*C;
41-1738 . A = B+C;
41-1739 .
41-1740 . if (A le B)
41-1741 . {
41-1742 . A = B + C;
41-1743 . D = E + F;
41-1744 . }
41-1745 .
41-1746 . A = B/C;
41-1747 . A = B-C;
41-1748 .
41-1749 . if (A gt B)
41-1750 . {
41-1751 . A = B + C;
41-1752 . D = E + F;
41-1753 . }
41-1754 .
41-1755 . A = B/C;
41-1756 . A = B/C;
41-1757 . A = B/C;
41-1758 . A = B/C;
41-1759 .
41-1760 . switch (msaw stuff)
41-1761 . {
41-1762 . case one:
41-1763 . {
41-1764 . run_this;
41-1765 . break;
41-1766 . }
41-1767 . case two:
41-1768 . {
41-1769 . run_this;
41-1770 . break;
41-1771 . }
41-1772 . default:
41-1773 . {
41-1774 . SwError;
41-1775 . }
41-1776 . }
41-1777 .
41-1778 . A = B-C;
41-1779 . A = 0x0004;
41-1780 .
41-1781 . switch (msaw stuff)
41-1782 . {
41-1783 . case one:
41-1784 . {
41-1785 . run_this;
41-1786 . break;
41-1787 . }
41-1788 . case two:
41-1789 . {
41-1790 . run_this;
41-1791 . break;
41-1792 . }
41-1793 . default:
41-1794 . {
41-1795 . SwError;
41-1796 . }
41-1797 . }
41-1798 .
41-1799 .
41-1800 . if (A ne B)
41-1801 . {
41-1802 . A = B + C;
41-1803 . D = E + F;
41-1804 . }
41-1805 .
41-1806 . A = B-C;
41-1807 . A = B-C;
41-1808 . A = B+C;
41-1809 . /* LE SV TOC-2228 this is a msaw-03.8.24 req to halt*/
41-1810 .
41-1811 . if (A > B)
41-1812 . {
41-1813 . A = B + C;
41-1814 . D = E + F;
41-1815 . }
41-1816 .
41-1817 .
41-1818 . if (A < = B)
41-1819 . {
41-1820 . A = B + C;
41-1821 . D = E + F;
41-1822 . }
41-1823 .
41-1824 .
41-1825 . if (A eq B)
41-1826 . {
41-1827 . A = B + C;
41-1828 . D = E + F;
41-1829 . }
41-1830 .
41-1831 .
41-1832 . if (A ge B)
41-1833 . {
41-1834 . A = B + C;
41-1835 . D = E + F;
41-1836 . }
41-1837 .
41-1838 . /* LE SV TOC-2229 this is a msaw-03.8.28 req to assign*/
41-1839 . A = B*C;
41-1840 . A = B*C;
41-1841 . A = B/C;
41-1842 . // max LOC 30
41-1843 .
41-1844 . }
41-1845 .
41-1846 .
41-1847 . /*
41-1848 . -----------------------------------------------------------------------------
41-1849 . --| NAME: msaw.3.9
41-1850 . --|
41-1851 . --| ABSTRACT:
41-1852 . --| This function does msaw stuff.
41-1853 . --|
41-1854 . --| RETURNS:
41-1855 . --| NONE.
41-1856 . --|
41-1857 . ----------------------------------------------------------------------------
41-1858 . */
41-1859 . static void msaw.3.9(void)
41-1860 . {
41-1861 . A = B/C;
41-1862 . A = B-C;
41-1863 . A = B+C;
41-1864 .
41-1865 . if (A le B)
41-1866 . {
41-1867 . A = B + C;
41-1868 . D = E + F;
41-1869 . }
41-1870 .
41-1871 . A = B+C;
41-1872 . A = B+C;
41-1873 . A = B-C;
41-1874 . A = B-C;
41-1875 . A = B-C;
41-1876 . A = B+C;
41-1877 .
41-1878 . if (A eq B)
41-1879 . {
41-1880 . A = B + C;
41-1881 . D = E + F;
41-1882 . }
41-1883 .
41-1884 . A = B-C;
41-1885 . A = B*C;
41-1886 .
41-1887 . switch (msaw stuff)
41-1888 . {
41-1889 . case one:
41-1890 . {
41-1891 . run_this;
41-1892 . break;
41-1893 . }
41-1894 . case two:
41-1895 . {
41-1896 . run_this;
41-1897 . break;
41-1898 . }
41-1899 . default:
41-1900 . {
41-1901 . SwError;
41-1902 . }
41-1903 . }
41-1904 .
41-1905 . A = B*C;
41-1906 . // max LOC 15
41-1907 .
41-1908 . }
41-1909 .
41-1910 .
41-1911 . /*
41-1912 . -----------------------------------------------------------------------------
41-1913 . --| NAME: msaw.3.10
41-1914 . --|
41-1915 . --| ABSTRACT:
41-1916 . --| This function does msaw stuff.
41-1917 . --|
41-1918 . --| RETURNS:
41-1919 . --| NONE.
41-1920 . --|
41-1921 . ----------------------------------------------------------------------------
41-1922 . */
41-1923 . static void msaw.3.10(void)
41-1924 . {
41-1925 . A = B+C;
41-1926 . A = B+C;
41-1927 . A = B-C;
41-1928 . A = B/C;
41-1929 .
41-1930 . if (A le B)
41-1931 . {
41-1932 . A = B + C;
41-1933 . D = E + F;
41-1934 . }
41-1935 .
41-1936 .
41-1937 . if (A ge B)
41-1938 . {
41-1939 . A = B + C;
41-1940 . D = E + F;
41-1941 . }
41-1942 .
41-1943 . A = B*C;
41-1944 . A = B*C;
41-1945 .
41-1946 . if (A == B)
41-1947 . {
41-1948 . A = B + C;
41-1949 . D = E + F;
41-1950 . }
41-1951 .
41-1952 . A = B/C;
41-1953 . /* LE SV TOC-2230 this is a msaw-03.10.11 req to validate*/
41-1954 . A = B*C;
41-1955 . A = B-C;
41-1956 .
41-1957 . if (A ge B)
41-1958 . {
41-1959 . A = B + C;
41-1960 . D = E + F;
41-1961 . }
41-1962 .
41-1963 . A = B-C;
41-1964 . A = B+C;
41-1965 . A = B-C;
41-1966 . A = B*C;
41-1967 .
41-1968 . if (A < = B)
41-1969 . {
41-1970 . A = B + C;
41-1971 . D = E + F;
41-1972 . }
41-1973 .
41-1974 . A = B/C;
41-1975 .
41-1976 . if (A ge B)
41-1977 . {
41-1978 . A = B + C;
41-1979 . D = E + F;
41-1980 . }
41-1981 .
41-1982 . A = B*C;
41-1983 . A = B/C;
41-1984 . A = B*C;
41-1985 . A = B/C;
41-1986 . A = B/C;
41-1987 .
41-1988 . if (A ge B)
41-1989 . {
41-1990 . A = B + C;
41-1991 . D = E + F;
41-1992 . }
41-1993 .
41-1994 . A = B/C;
41-1995 .
41-1996 . /*
41-1997 . dead_block = C * D;
41-1998 . dead_block = E * F;
41-1999 . */
41-2000 .
41-2001 . A = B*C;
41-2002 . A = B*C;
41-2003 .
41-2004 . if (A > = B)
41-2005 . {
41-2006 . A = B + C;
41-2007 . D = E + F;
41-2008 . }
41-2009 .
41-2010 .
41-2011 . if (veg)
41-2012 . // missing curly brace
41-2013 . variable = orange;
41-2014 .
41-2015 . A = B-C;
41-2016 . A = B+C;
41-2017 . A = B/C;
41-2018 .
41-2019 . if (A ne B)
41-2020 . {
41-2021 . A = B + C;
41-2022 . D = E + F;
41-2023 . }
41-2024 .
41-2025 . A = B*C;
41-2026 . // max LOC 35
41-2027 .
41-2028 . }
41-2029 .
41-2030 .
41-2031 . /*
41-2032 . -----------------------------------------------------------------------------
41-2033 . --| NAME: msaw.3.11
41-2034 . --|
41-2035 . --| ABSTRACT:
41-2036 . --| This function does msaw stuff.
41-2037 . --|
41-2038 . --| RETURNS:
41-2039 . --| NONE.
41-2040 . --|
41-2041 . ----------------------------------------------------------------------------
41-2042 . */
41-2043 . static void msaw.3.11(void)
41-2044 . {
41-2045 .
41-2046 . if (A le B)
41-2047 . {
41-2048 . A = B + C;
41-2049 . D = E + F;
41-2050 . }
41-2051 .
41-2052 .
41-2053 . switch (msaw stuff)
41-2054 . {
41-2055 . case one:
41-2056 . {
41-2057 . run_this;
41-2058 . break;
41-2059 . }
41-2060 . case two:
41-2061 . {
41-2062 . run_this;
41-2063 . break;
41-2064 . }
41-2065 . default:
41-2066 . {
41-2067 . SwError;
41-2068 . }
41-2069 . }
41-2070 .
41-2071 . A = B+C;
41-2072 .
41-2073 . if (A le B)
41-2074 . {
41-2075 . A = B + C;
41-2076 . D = E + F;
41-2077 . }
41-2078 .
41-2079 . A = B*C;
41-2080 . A = B+C;
41-2081 . A = B/C;
41-2082 .
41-2083 . if (A < B)
41-2084 . {
41-2085 . A = B + C;
41-2086 . D = E + F;
41-2087 . }
41-2088 .
41-2089 . A = B*C;
41-2090 . A = B-C;
41-2091 .
41-2092 . if (A ne B)
41-2093 . {
41-2094 . A = B + C;
41-2095 . D = E + F;
41-2096 . }
41-2097 .
41-2098 . A = B*C;
41-2099 .
41-2100 . if (A > = B)
41-2101 . {
41-2102 . A = B + C;
41-2103 . D = E + F;
41-2104 . }
41-2105 .
41-2106 .
41-2107 . if (A gt B)
41-2108 . {
41-2109 . A = B + C;
41-2110 . D = E + F;
41-2111 . }
41-2112 .
41-2113 . A = B/C;
41-2114 . A = B*C;
41-2115 .
41-2116 . if (A != B)
41-2117 . {
41-2118 . A = B + C;
41-2119 . D = E + F;
41-2120 . }
41-2121 .
41-2122 .
41-2123 . if (A == B)
41-2124 . {
41-2125 . A = B + C;
41-2126 . D = E + F;
41-2127 . }
41-2128 .
41-2129 . A = B-C;
41-2130 . A = B/C;
41-2131 . FreePtr = HmiStringPtr;
41-2132 . A = B*C;
41-2133 . A = B+C;
41-2134 .
41-2135 . if (A < B)
41-2136 . {
41-2137 . A = B + C;
41-2138 . D = E + F;
41-2139 . }
41-2140 .
41-2141 . A = B-C;
41-2142 . A = B/C;
41-2143 . A = B/C;
41-2144 . /* LE SV TOC-2231 this is a msaw-03.11.27 req to check unix*/
41-2145 .
41-2146 . if (A == B)
41-2147 . {
41-2148 . A = B + C;
41-2149 . D = E + F;
41-2150 . }
41-2151 .
41-2152 . /* LE SV TOC-2232 this is a msaw-03.11.28 req to increment*/
41-2153 .
41-2154 . if (A < = B)
41-2155 . {
41-2156 . A = B + C;
41-2157 . D = E + F;
41-2158 . }
41-2159 .
41-2160 . A = B-C;
41-2161 . A = B*C;
41-2162 . A = B-C;
41-2163 . A = B*C;
41-2164 . A = B*C;
41-2165 . A = B/C;
41-2166 . A = B*C;
41-2167 .
41-2168 . if (A le B)
41-2169 . {
41-2170 . A = B + C;
41-2171 . D = E + F;
41-2172 . }
41-2173 .
41-2174 . A = B-C;
41-2175 .
41-2176 . if (A lt B)
41-2177 . {
41-2178 . A = B + C;
41-2179 . D = E + F;
41-2180 . }
41-2181 .
41-2182 . /* LE SV TOC-2233 this is a msaw-03.11.39 req to call isr*/
41-2183 .
41-2184 . switch (msaw stuff)
41-2185 . {
41-2186 . case one:
41-2187 . {
41-2188 . switch (nested)
41-2189 . {
41-2190 . case:
41-2191 . X = Y + Z;
41-2192 . case:
41-2193 . X = Y + Z;
41-2194 . default:
41-2195 . SwError;
41-2196 . }
41-2197 . }
41-2198 . case two:
41-2199 . {
41-2200 . run_this;
41-2201 . break;
41-2202 . }
41-2203 . default:
41-2204 . {
41-2205 . SwError;
41-2206 . }
41-2207 . }
41-2208 .
41-2209 . A = B*C;
41-2210 .
41-2211 . if (A < B)
41-2212 . {
41-2213 . A = B + C;
41-2214 . D = E + F;
41-2215 . }
41-2216 .
41-2217 . // TBD - what do I do now
41-2218 . A = B-C;
41-2219 .
41-2220 . if (A > = B)
41-2221 . {
41-2222 . A = B + C;
41-2223 . D = E + F;
41-2224 . }
41-2225 .
41-2226 . /* LE SV TOC-2234 this is a msaw-03.11.43 req to set RTC*/
41-2227 . A = B*C;
41-2228 . A = B/C;
41-2229 .
41-2230 . if (A != B)
41-2231 . {
41-2232 . A = B + C;
41-2233 . D = E + F;
41-2234 . }
41-2235 .
41-2236 . A = B*C;
41-2237 . A = B*C;
41-2238 . A = B+C;
41-2239 . A = B+C;
41-2240 . // max LOC 49
41-2241 .
41-2242 . }
41-2243 .
41-2244 .
41-2245 . /*
41-2246 . -----------------------------------------------------------------------------
41-2247 . --| NAME: msaw.3.12
41-2248 . --|
41-2249 . --| ABSTRACT:
41-2250 . --| This function does msaw stuff.
41-2251 . --|
41-2252 . --| RETURNS:
41-2253 . --| NONE.
41-2254 . --|
41-2255 . ----------------------------------------------------------------------------
41-2256 . */
41-2257 . static void msaw.3.12(void)
41-2258 . {
41-2259 .
41-2260 . if (A != B)
41-2261 . {
41-2262 . A = B + C;
41-2263 . D = E + F;
41-2264 . }
41-2265 .
41-2266 .
41-2267 . if (A > = B)
41-2268 . {
41-2269 . A = B + C;
41-2270 . D = E + F;
41-2271 . }
41-2272 .
41-2273 . A = B*C;
41-2274 . A = B/C;
41-2275 . A = B-C;
41-2276 .
41-2277 . if (A < = B)
41-2278 . {
41-2279 . A = B + C;
41-2280 . D = E + F;
41-2281 . }
41-2282 .
41-2283 .
41-2284 . if (A eq B)
41-2285 . {
41-2286 . A = B + C;
41-2287 . D = E + F;
41-2288 . }
41-2289 .
41-2290 . /* dead_code = A * B; */
41-2291 . A = B*C;
41-2292 .
41-2293 . if (A le B)
41-2294 . {
41-2295 . A = B + C;
41-2296 . D = E + F;
41-2297 . }
41-2298 .
41-2299 .
41-2300 . if (A < = B)
41-2301 . {
41-2302 . A = B + C;
41-2303 . D = E + F;
41-2304 . }
41-2305 .
41-2306 . A = B*C;
41-2307 . /* LE SV TOC-2235 this is a msaw-03.12.12 req to halt*/
41-2308 .
41-2309 . if (A le B)
41-2310 . {
41-2311 . A = B + C;
41-2312 . D = E + F;
41-2313 . }
41-2314 .
41-2315 . A = B-C;
41-2316 . A = B/C;
41-2317 . A = B+C;
41-2318 .
41-2319 . if (A > B)
41-2320 . {
41-2321 . A = B + C;
41-2322 . D = E + F;
41-2323 . }
41-2324 .
41-2325 .
41-2326 . if (A le B)
41-2327 . {
41-2328 . A = B + C;
41-2329 . D = E + F;
41-2330 . }
41-2331 .
41-2332 . A = B-C;
41-2333 .
41-2334 . if (A == B)
41-2335 . {
41-2336 . A = B + C;
41-2337 . D = E + F;
41-2338 . }
41-2339 .
41-2340 .
41-2341 . if (A > = B)
41-2342 . {
41-2343 . A = B + C;
41-2344 . D = E + F;
41-2345 . }
41-2346 .
41-2347 .
41-2348 . /*
41-2349 . dead_code = B - C;
41-2350 . dead_code = D - E;
41-2351 . dead_code = F - G;
41-2352 . */
41-2353 .
41-2354 .
41-2355 . if (A > = B)
41-2356 . {
41-2357 . A = B + C;
41-2358 . D = E + F;
41-2359 . }
41-2360 .
41-2361 . A = B*C;
41-2362 .
41-2363 . if (A gt B)
41-2364 . {
41-2365 . A = B + C;
41-2366 . D = E + F;
41-2367 . }
41-2368 .
41-2369 . A = B-C;
41-2370 .
41-2371 . if (A < = B)
41-2372 . {
41-2373 . A = B + C;
41-2374 . D = E + F;
41-2375 . }
41-2376 .
41-2377 . A = B/C;
41-2378 .
41-2379 . if (A ne B)
41-2380 . {
41-2381 . A = B + C;
41-2382 . D = E + F;
41-2383 . }
41-2384 .
41-2385 . A = B+C;
41-2386 . A = B*C;
41-2387 . A = B+C;
41-2388 . A = B*C;
41-2389 .
41-2390 . if (A ne B)
41-2391 . {
41-2392 . A = B + C;
41-2393 . D = E + F;
41-2394 . }
41-2395 .
41-2396 . /* LE SV TOC-2236 this is a msaw-03.12.33 req to recover*/
41-2397 . A = B/C;
41-2398 . // max LOC 33
41-2399 .
41-2400 . }
41-2401 .
41 41 Result: result/source/ft-app/ft-app-B1.1/msaw/msaw-03.c
42 42 Source: source/ft-app/ft-app-B1.1/msaw/msaw-04.c
42-0 . /*
42-1 . ----------------------------------------------------------------------------
42-2 . --| BEGIN PROLOGUE
42-3 . --|
42-4 . --| CLASSIFICATION: UNCLASSIFIED
42-5 . --|
42-6 . --| FILE NAME: msaw-04.c
42-7 . --|
42-8 . --| ABSTRACT:
42-9 . --| This file contains the 14 functions that do file msaw stuff.
42-10 . --|
42-11 . --| HISTORY:
42-12 . --| CCCQ_NAME:
42-13 . --| CCCQ_VER:
42-14 . --|
42-15 . --| END PROLOGUE
42-16 . ----------------------------------------------------------------------------
42-17 . */
42-18 .
42-19 . #define B;
42-20 . #include A;
42-21 .
42-22 .
42-23 .
42-24 . /*
42-25 . -----------------------------------------------------------------------------
42-26 . --| NAME: msaw.4.1
42-27 . --|
42-28 . --| ABSTRACT:
42-29 . --| This function does msaw stuff.
42-30 . --|
42-31 . --| RETURNS:
42-32 . --| NONE.
42-33 . --|
42-34 . ----------------------------------------------------------------------------
42-35 . */
42-36 . static void msaw.4.1(void)
42-37 . {
42-38 . A = B+C;
42-39 . // max LOC 1
42-40 .
42-41 . }
42-42 .
42-43 .
42-44 . /*
42-45 . -----------------------------------------------------------------------------
42-46 . --| NAME: msaw.4.2
42-47 . --|
42-48 . --| ABSTRACT:
42-49 . --| This function does msaw stuff.
42-50 . --|
42-51 . --| RETURNS:
42-52 . --| NONE.
42-53 . --|
42-54 . ----------------------------------------------------------------------------
42-55 . */
42-56 . static void msaw.4.2(void)
42-57 . {
42-58 . /* LE SV TOC-2237 this is a msaw-04.2.1 req to call isr*/
42-59 . A = B-C;
42-60 . A = B*C;
42-61 . A = B*C;
42-62 . A = B*C;
42-63 . A = B+C;
42-64 . A = B*C;
42-65 .
42-66 . if (A lt B)
42-67 . {
42-68 . A = B + C;
42-69 . D = E + F;
42-70 . }
42-71 .
42-72 . A = B-C;
42-73 . // max LOC 8
42-74 .
42-75 . }
42-76 .
42-77 .
42-78 . /*
42-79 . -----------------------------------------------------------------------------
42-80 . --| NAME: msaw.4.3
42-81 . --|
42-82 . --| ABSTRACT:
42-83 . --| This function does msaw stuff.
42-84 . --|
42-85 . --| RETURNS:
42-86 . --| NONE.
42-87 . --|
42-88 . ----------------------------------------------------------------------------
42-89 . */
42-90 . static void msaw.4.3(void)
42-91 . {
42-92 . A = B-C;
42-93 .
42-94 . if (A == B)
42-95 . {
42-96 . A = B + C;
42-97 . D = E + F;
42-98 . }
42-99 .
42-100 . A = B/C;
42-101 . A = B-C;
42-102 . A = B*C;
42-103 . A = B-C;
42-104 .
42-105 . if (veg)
42-106 . // missing curly brace
42-107 . variable = orange;
42-108 .
42-109 . A = B/C;
42-110 . A = B-C;
42-111 . A = B-C;
42-112 . A = B/C;
42-113 .
42-114 . /* dead_block = C * D;
42-115 . dead_block = E * F; */
42-116 .
42-117 . A = B-C;
42-118 . A = B/C;
42-119 . A = B+C;
42-120 . A = B-C;
42-121 . A = B-C;
42-122 . A = B/C;
42-123 .
42-124 . if (A == B)
42-125 . {
42-126 . A = B + C;
42-127 . D = E + F;
42-128 . }
42-129 .
42-130 . A = B/C;
42-131 . A = B/C;
42-132 . A = B+C;
42-133 . A = B+C;
42-134 . A = (long)B + C;
42-135 . A = B+C;
42-136 . A = B+C;
42-137 . A = B-C;
42-138 . /* LE SV TOC-2238 this is a msaw-04.3.25 req to assign*/
42-139 .
42-140 . if (A eq B)
42-141 . {
42-142 . A = B + C;
42-143 . D = E + F;
42-144 . }
42-145 .
42-146 .
42-147 . switch (msaw stuff)
42-148 . {
42-149 . case one:
42-150 . {
42-151 . run_this;
42-152 . break;
42-153 . }
42-154 . case two:
42-155 . {
42-156 . run_this;
42-157 . break;
42-158 . }
42-159 . default:
42-160 . {
42-161 . SwError;
42-162 . }
42-163 . }
42-164 .
42-165 . A = B*C;
42-166 . A = B/C;
42-167 . A = B-C;
42-168 . A = 0x0006;
42-169 .
42-170 . if (A le B)
42-171 . {
42-172 . A = B + C;
42-173 . D = E + F;
42-174 . }
42-175 .
42-176 . A = B+C;
42-177 . A = B+C;
42-178 .
42-179 . if (A eq B)
42-180 . {
42-181 . A = B + C;
42-182 . D = E + F;
42-183 . }
42-184 .
42-185 . /* LE SV TOC-2239 this is a msaw-04.3.34 req to transform*/
42-186 . A = B+C;
42-187 . A = B/C;
42-188 .
42-189 . switch (msaw stuff)
42-190 . {
42-191 . case one:
42-192 . {
42-193 . run_this;
42-194 . break;
42-195 . }
42-196 . case two:
42-197 . {
42-198 . run_this;
42-199 . break;
42-200 . }
42-201 . default:
42-202 . {
42-203 . SwError;
42-204 . }
42-205 . }
42-206 .
42-207 . A = B+C;
42-208 . A = B-C;
42-209 . A = B-C;
42-210 . A = 0x0007;
42-211 . A = B+C;
42-212 . A = B-C;
42-213 .
42-214 . if (A < B)
42-215 . {
42-216 . A = B + C;
42-217 . D = E + F;
42-218 . }
42-219 .
42-220 . /* LE SV TOC-2240 this is a msaw-04.3.43 req to halt*/
42-221 . A = B*C;
42-222 . A = B-C;
42-223 . A = B*C;
42-224 . A = B*C;
42-225 .
42-226 . switch (msaw stuff)
42-227 . {
42-228 . case:
42-229 . case:
42-230 . // stacked case statements but only if there is a new line in between
42-231 .
42-232 . case:
42-233 . case:
42-234 . case:
42-235 . {
42-236 . run_this;
42-237 . break;
42-238 . }
42-239 . default:
42-240 . {
42-241 . halt;
42-242 . }
42-243 . }
42-244 .
42-245 .
42-246 . if (A ne B)
42-247 . {
42-248 . A = B + C;
42-249 . D = E + F;
42-250 . }
42-251 .
42-252 .
42-253 . if (A < = B)
42-254 . {
42-255 . A = B + C;
42-256 . D = E + F;
42-257 . }
42-258 .
42-259 . A = B/C;
42-260 . A = B/C;
42-261 .
42-262 . if (A gt B)
42-263 . {
42-264 . A = B + C;
42-265 . D = E + F;
42-266 . }
42-267 .
42-268 . A = B+C;
42-269 . A = B/C;
42-270 . A = B-C;
42-271 . A = B-C;
42-272 . A = B-C;
42-273 . // max LOC 56
42-274 .
42-275 . }
42-276 .
42-277 .
42-278 . /*
42-279 . -----------------------------------------------------------------------------
42-280 . --| NAME: msaw.4.4
42-281 . --|
42-282 . --| ABSTRACT:
42-283 . --| This function does msaw stuff.
42-284 . --|
42-285 . --| RETURNS:
42-286 . --| NONE.
42-287 . --|
42-288 . ----------------------------------------------------------------------------
42-289 . */
42-290 . static void msaw.4.4(void)
42-291 . {
42-292 . A = B+C;
42-293 . A = B*C;
42-294 . A = B+C;
42-295 .
42-296 . if (A < = B)
42-297 . {
42-298 . A = B + C;
42-299 . D = E + F;
42-300 . }
42-301 .
42-302 .
42-303 . if (A < B)
42-304 . {
42-305 . A = B + C;
42-306 . D = E + F;
42-307 . }
42-308 .
42-309 . A = B/C;
42-310 . // ??? go see ws
42-311 . A = B/C;
42-312 .
42-313 . if (A lt B)
42-314 . {
42-315 . A = B + C;
42-316 . D = E + F;
42-317 . }
42-318 .
42-319 . A = B*C;
42-320 . // TBS - I need to figure this out
42-321 . A = B+C;
42-322 .
42-323 . if (A eq B)
42-324 . {
42-325 . A = B + C;
42-326 . D = E + F;
42-327 . }
42-328 .
42-329 . A = B*C;
42-330 .
42-331 . if (A ge B)
42-332 . {
42-333 . A = B + C;
42-334 . D = E + F;
42-335 . }
42-336 .
42-337 . A = B-C;
42-338 . A = B-C;
42-339 . A = B*C;
42-340 . A = B-C;
42-341 . A = B*C;
42-342 .
42-343 . if (A != B)
42-344 . {
42-345 . A = B + C;
42-346 . D = E + F;
42-347 . }
42-348 .
42-349 . A = B*C;
42-350 . A = B-C;
42-351 . A = B+C;
42-352 .
42-353 . if (A != B)
42-354 . {
42-355 . A = B + C;
42-356 . D = E + F;
42-357 . }
42-358 .
42-359 .
42-360 . if (A lt B)
42-361 . {
42-362 . A = B + C;
42-363 . D = E + F;
42-364 . }
42-365 .
42-366 .
42-367 . if (A != B)
42-368 . {
42-369 . A = B + C;
42-370 . D = E + F;
42-371 . }
42-372 .
42-373 . A = B-C;
42-374 . A = B-C;
42-375 .
42-376 . if (A gt B)
42-377 . {
42-378 . A = B + C;
42-379 . D = E + F;
42-380 . }
42-381 .
42-382 .
42-383 . if (A lt B)
42-384 . {
42-385 . A = B + C;
42-386 . D = E + F;
42-387 . }
42-388 .
42-389 . /* LE SV TOC-2241 this is a msaw-04.4.30 req to validate*/
42-390 . A = B*C;
42-391 .
42-392 . if (A lt B)
42-393 . {
42-394 . A = B + C;
42-395 . D = E + F;
42-396 . }
42-397 .
42-398 .
42-399 . if (A eq B)
42-400 . {
42-401 . A = B + C;
42-402 . D = E + F;
42-403 . }
42-404 .
42-405 . A = B*C;
42-406 .
42-407 . if (A < B)
42-408 . {
42-409 . A = B + C;
42-410 . D = E + F;
42-411 . }
42-412 .
42-413 .
42-414 . if (A > B)
42-415 . {
42-416 . A = B + C;
42-417 . D = E + F;
42-418 . }
42-419 .
42-420 .
42-421 . switch (msaw stuff)
42-422 . {
42-423 . case one:
42-424 . {
42-425 . run_this;
42-426 . break;
42-427 . }
42-428 . case two:
42-429 . {
42-430 . run_this;
42-431 . break;
42-432 . }
42-433 . default:
42-434 . {
42-435 . SwError;
42-436 . }
42-437 . }
42-438 .
42-439 . A = B+C;
42-440 . A = B*C;
42-441 .
42-442 . if (A lt B)
42-443 . {
42-444 . A = B + C;
42-445 . D = E + F;
42-446 . }
42-447 .
42-448 . A = B+C;
42-449 .
42-450 . switch (msaw stuff)
42-451 . {
42-452 . case one:
42-453 . {
42-454 . run_this;
42-455 . break;
42-456 . }
42-457 . case two:
42-458 . {
42-459 . run_this;
42-460 . break;
42-461 . }
42-462 . default:
42-463 . {
42-464 . SwError;
42-465 . }
42-466 . }
42-467 .
42-468 . A = 0x0006;
42-469 .
42-470 . if (A < = B)
42-471 . {
42-472 . A = B + C;
42-473 . D = E + F;
42-474 . }
42-475 .
42-476 .
42-477 . if (A != B)
42-478 . {
42-479 . A = B + C;
42-480 . D = E + F;
42-481 . }
42-482 .
42-483 . A = B*C;
42-484 . A = B+C;
42-485 . A = B*C;
42-486 . A = B/C;
42-487 . A = B*C;
42-488 .
42-489 . /* dead_block = C * D;
42-490 . dead_block = E * F; */
42-491 .
42-492 . A = B*C;
42-493 . A = B*C;
42-494 . A = B+C;
42-495 .
42-496 . switch (msaw stuff)
42-497 . {
42-498 . case one:
42-499 . {
42-500 . run_this;
42-501 . // missing break
42-502 . }
42-503 . case two:
42-504 . {
42-505 . run_this;
42-506 . break;
42-507 . }
42-508 . default:
42-509 . {
42-510 . SwError;
42-511 . }
42-512 . }
42-513 .
42-514 . A = B*C;
42-515 .
42-516 . if (A ge B)
42-517 . {
42-518 . A = B + C;
42-519 . D = E + F;
42-520 . }
42-521 .
42-522 . A = B+C;
42-523 . A = B*C;
42-524 . A = B*C;
42-525 . A = B/C;
42-526 . A = B*C;
42-527 . A = B+C;
42-528 . A = B-C;
42-529 . A = B-C;
42-530 . A = B-C;
42-531 . A = B*C;
42-532 . A = B-C;
42-533 . A = B/C;
42-534 . A = B-C;
42-535 . A = B+C;
42-536 . /* LE SV TOC-2242 this is a msaw-04.4.68 req to transform*/
42-537 . A = B+C;
42-538 .
42-539 . if (A lt B)
42-540 . {
42-541 . A = B + C;
42-542 . D = E + F;
42-543 . }
42-544 .
42-545 . A = B-C;
42-546 .
42-547 . if (A eq B)
42-548 . {
42-549 . A = B + C;
42-550 . D = E + F;
42-551 . }
42-552 .
42-553 . // max LOC 71
42-554 .
42-555 . }
42-556 .
42-557 .
42-558 . /*
42-559 . -----------------------------------------------------------------------------
42-560 . --| NAME: msaw.4.5
42-561 . --|
42-562 . --| ABSTRACT:
42-563 . --| This function does msaw stuff.
42-564 . --|
42-565 . --| RETURNS:
42-566 . --| NONE.
42-567 . --|
42-568 . ----------------------------------------------------------------------------
42-569 . */
42-570 . static void msaw.4.5(void)
42-571 . {
42-572 . A = B+C;
42-573 . A = B*C;
42-574 .
42-575 . if (A < B)
42-576 . {
42-577 . A = B + C;
42-578 . D = E + F;
42-579 . }
42-580 .
42-581 . A = B*C;
42-582 . A = B*C;
42-583 . A = B-C;
42-584 . A = B/C;
42-585 . A = B/C;
42-586 . A = B-C;
42-587 . A = B+C;
42-588 . A = B-C;
42-589 . A = 0x0003;
42-590 .
42-591 . if (A ne B)
42-592 . {
42-593 . A = B + C;
42-594 . D = E + F;
42-595 . }
42-596 .
42-597 .
42-598 . if (A ge B)
42-599 . {
42-600 . A = B + C;
42-601 . D = E + F;
42-602 . }
42-603 .
42-604 . A = B+C;
42-605 .
42-606 . if (A < = B)
42-607 . {
42-608 . A = B + C;
42-609 . D = E + F;
42-610 . }
42-611 .
42-612 . A = B*C;
42-613 . A = B-C;
42-614 . A = B-C;
42-615 . A = B-C;
42-616 .
42-617 . if (A != B)
42-618 . {
42-619 . A = B + C;
42-620 . D = E + F;
42-621 . }
42-622 .
42-623 . A = B-C;
42-624 .
42-625 . if (A == B)
42-626 . {
42-627 . A = B + C;
42-628 . D = E + F;
42-629 . }
42-630 .
42-631 .
42-632 . if (A > B)
42-633 . {
42-634 . A = B + C;
42-635 . D = E + F;
42-636 . }
42-637 .
42-638 . A = B-C;
42-639 .
42-640 . if (A > = B)
42-641 . {
42-642 . A = B + C;
42-643 . D = E + F;
42-644 . }
42-645 .
42-646 . A = B*C;
42-647 . A = B+C;
42-648 . A = B/C;
42-649 .
42-650 . if (A ge B)
42-651 . {
42-652 . A = B + C;
42-653 . D = E + F;
42-654 . }
42-655 .
42-656 . A = B+C;
42-657 . A = B*C;
42-658 .
42-659 . if (A > B)
42-660 . {
42-661 . A = B + C;
42-662 . D = E + F;
42-663 . }
42-664 .
42-665 .
42-666 . if (A < = B)
42-667 . {
42-668 . A = B + C;
42-669 . D = E + F;
42-670 . }
42-671 .
42-672 . A = B-C;
42-673 .
42-674 . switch (msaw stuff)
42-675 . {
42-676 . case one:
42-677 . {
42-678 . switch (nested)
42-679 . {
42-680 . case:
42-681 . X = Y + Z;
42-682 . case:
42-683 . X = Y + Z;
42-684 . default:
42-685 . SwError;
42-686 . }
42-687 . }
42-688 . case two:
42-689 . {
42-690 . run_this;
42-691 . break;
42-692 . }
42-693 . default:
42-694 . {
42-695 . SwError;
42-696 . }
42-697 . }
42-698 .
42-699 .
42-700 . if (A != B)
42-701 . {
42-702 . A = B + C;
42-703 . D = E + F;
42-704 . }
42-705 .
42-706 . // max LOC 35
42-707 .
42-708 . }
42-709 .
42-710 .
42-711 . /*
42-712 . -----------------------------------------------------------------------------
42-713 . --| NAME: msaw.4.6
42-714 . --|
42-715 . --| ABSTRACT:
42-716 . --| This function does msaw stuff.
42-717 . --|
42-718 . --| RETURNS:
42-719 . --| NONE.
42-720 . --|
42-721 . ----------------------------------------------------------------------------
42-722 . */
42-723 . static void msaw.4.6(void)
42-724 . {
42-725 . A = B*C;
42-726 . A = B*C;
42-727 . A = B*C;
42-728 .
42-729 . if (A < B)
42-730 . {
42-731 . A = B + C;
42-732 . D = E + F;
42-733 . }
42-734 .
42-735 . A = B*C;
42-736 .
42-737 . if (A < = B)
42-738 . {
42-739 . A = B + C;
42-740 . D = E + F;
42-741 . }
42-742 .
42-743 . A = B/C;
42-744 . A = B+C;
42-745 .
42-746 . if (A gt B)
42-747 . {
42-748 . A = B + C;
42-749 . D = E + F;
42-750 . }
42-751 .
42-752 . A = B-C;
42-753 . A = B+C;
42-754 . // max LOC 11
42-755 .
42-756 . }
42-757 .
42-758 .
42-759 . /*
42-760 . -----------------------------------------------------------------------------
42-761 . --| NAME: msaw.4.7
42-762 . --|
42-763 . --| ABSTRACT:
42-764 . --| This function does msaw stuff.
42-765 . --|
42-766 . --| RETURNS:
42-767 . --| NONE.
42-768 . --|
42-769 . ----------------------------------------------------------------------------
42-770 . */
42-771 . static void msaw.4.7(void)
42-772 . {
42-773 .
42-774 . if (A le B)
42-775 . {
42-776 . A = B + C;
42-777 . D = E + F;
42-778 . }
42-779 .
42-780 .
42-781 . if (A > B)
42-782 . {
42-783 . A = B + C;
42-784 . D = E + F;
42-785 . }
42-786 .
42-787 . A = B-C;
42-788 . A = B-C;
42-789 .
42-790 . if (A eq B)
42-791 . {
42-792 . A = B + C;
42-793 . D = E + F;
42-794 . }
42-795 .
42-796 . A = B/C;
42-797 .
42-798 . if (A > = B)
42-799 . {
42-800 . A = B + C;
42-801 . D = E + F;
42-802 . }
42-803 .
42-804 . /* LE SV TOC-2243 this is a msaw-04.7.8 req to check unix*/
42-805 . A = B*C;
42-806 .
42-807 . if (A eq B)
42-808 . {
42-809 . A = B + C;
42-810 . D = E + F;
42-811 . }
42-812 .
42-813 . // (P) this is really improtant
42-814 . A = B/C;
42-815 . A = B-C;
42-816 .
42-817 . if (A ge B)
42-818 . {
42-819 . A = B + C;
42-820 . D = E + F;
42-821 . }
42-822 .
42-823 . A = B+C;
42-824 . A = B+C;
42-825 . A = B+C;
42-826 . A = B*C;
42-827 . // max LOC 16
42-828 .
42-829 . }
42-830 .
42-831 .
42-832 . /*
42-833 . -----------------------------------------------------------------------------
42-834 . --| NAME: msaw.4.8
42-835 . --|
42-836 . --| ABSTRACT:
42-837 . --| This function does msaw stuff.
42-838 . --|
42-839 . --| RETURNS:
42-840 . --| NONE.
42-841 . --|
42-842 . ----------------------------------------------------------------------------
42-843 . */
42-844 . static void msaw.4.8(void)
42-845 . {
42-846 .
42-847 . if (A lt B)
42-848 . {
42-849 . A = B + C;
42-850 . D = E + F;
42-851 . }
42-852 .
42-853 . A = B*C;
42-854 . /* LE SV TOC-2244 this is a msaw-04.8.3 req to set RTC*/
42-855 . A = B/C;
42-856 .
42-857 . if (A ge B)
42-858 . {
42-859 . A = B + C;
42-860 . D = E + F;
42-861 . }
42-862 .
42-863 . A = B-C;
42-864 .
42-865 . if (A ne B)
42-866 . {
42-867 . A = B + C;
42-868 . D = E + F;
42-869 . }
42-870 .
42-871 . A = B-C;
42-872 .
42-873 . if (A < B)
42-874 . {
42-875 . A = B + C;
42-876 . D = E + F;
42-877 . }
42-878 .
42-879 .
42-880 . switch (msaw stuff)
42-881 . {
42-882 . case one:
42-883 . {
42-884 . run_this;
42-885 . break;
42-886 . }
42-887 . case two:
42-888 . {
42-889 . run_this;
42-890 . break;
42-891 . }
42-892 . default:
42-893 . {
42-894 . SwError;
42-895 . }
42-896 . }
42-897 .
42-898 . A = B+C;
42-899 . free(FreePtr);
42-900 . A = B+C;
42-901 . A = B*C;
42-902 .
42-903 . if (A gt B)
42-904 . {
42-905 . A = B + C;
42-906 . D = E + F;
42-907 . }
42-908 .
42-909 . A = B/C;
42-910 . A = B-C;
42-911 . /* LE SV TOC-2245 this is a msaw-04.8.16 req to verify*/
42-912 . A = B*C;
42-913 . A = B*C;
42-914 . A = B*C;
42-915 . A = B/C;
42-916 . A = B-C;
42-917 . A = B+C;
42-918 .
42-919 . if (A < = B)
42-920 . {
42-921 . A = B + C;
42-922 . D = E + F;
42-923 . }
42-924 .
42-925 . // max LOC 22
42-926 .
42-927 . }
42-928 .
42-929 .
42-930 . /*
42-931 . -----------------------------------------------------------------------------
42-932 . --| NAME: msaw.4.9
42-933 . --|
42-934 . --| ABSTRACT:
42-935 . --| This function does msaw stuff.
42-936 . --|
42-937 . --| RETURNS:
42-938 . --| NONE.
42-939 . --|
42-940 . ----------------------------------------------------------------------------
42-941 . */
42-942 . static void msaw.4.9(void)
42-943 . {
42-944 .
42-945 . if (A gt B)
42-946 . {
42-947 . A = B + C;
42-948 . D = E + F;
42-949 . }
42-950 .
42-951 . A = B*C;
42-952 . /* LE SV TOC-2246 this is a msaw-04.9.3 req to enable*/
42-953 .
42-954 . if (A le B)
42-955 . {
42-956 . A = B + C;
42-957 . D = E + F;
42-958 . }
42-959 .
42-960 .
42-961 . if (A ne B)
42-962 . {
42-963 . A = B + C;
42-964 . D = E + F;
42-965 . }
42-966 .
42-967 .
42-968 . if (A gt B)
42-969 . {
42-970 . A = B + C;
42-971 . D = E + F;
42-972 . }
42-973 .
42-974 . A = B+C;
42-975 .
42-976 . if (A lt B)
42-977 . {
42-978 . A = B + C;
42-979 . D = E + F;
42-980 . }
42-981 .
42-982 . A = B*C;
42-983 . A = B*C;
42-984 . A = B-C;
42-985 .
42-986 . if (A lt B)
42-987 . {
42-988 . A = B + C;
42-989 . D = E + F;
42-990 . }
42-991 .
42-992 . /* LE SV TOC-2247 this is a msaw-04.9.12 req to verify*/
42-993 . A = B/C;
42-994 . A = B/C;
42-995 . A = B-C;
42-996 . // max LOC 14
42-997 .
42-998 . }
42-999 .
42-1000 .
42-1001 . /*
42-1002 . -----------------------------------------------------------------------------
42-1003 . --| NAME: msaw.4.10
42-1004 . --|
42-1005 . --| ABSTRACT:
42-1006 . --| This function does msaw stuff.
42-1007 . --|
42-1008 . --| RETURNS:
42-1009 . --| NONE.
42-1010 . --|
42-1011 . ----------------------------------------------------------------------------
42-1012 . */
42-1013 . static void msaw.4.10(void)
42-1014 . {
42-1015 . A = B*C;
42-1016 . A = B*C;
42-1017 .
42-1018 . if (veg)
42-1019 . // missing curly brace
42-1020 . variable = orange;
42-1021 .
42-1022 .
42-1023 . if (A > = B)
42-1024 . {
42-1025 . A = B + C;
42-1026 . D = E + F;
42-1027 . }
42-1028 .
42-1029 . A = B/C;
42-1030 . /* LE SV TOC-2248 this is a msaw-04.10.5 req to transform*/
42-1031 .
42-1032 . if (A != B)
42-1033 . {
42-1034 . A = B + C;
42-1035 . D = E + F;
42-1036 . }
42-1037 .
42-1038 .
42-1039 . if (A > = B)
42-1040 . {
42-1041 . A = B + C;
42-1042 . D = E + F;
42-1043 . }
42-1044 .
42-1045 .
42-1046 . if (A < = B)
42-1047 . {
42-1048 . A = B + C;
42-1049 . D = E + F;
42-1050 . }
42-1051 .
42-1052 . A = B/C;
42-1053 . A = B/C;
42-1054 .
42-1055 . if (A eq B)
42-1056 . {
42-1057 . A = B + C;
42-1058 . D = E + F;
42-1059 . }
42-1060 .
42-1061 . A = B*C;
42-1062 .
42-1063 . /*
42-1064 . dead_code = B - C;
42-1065 . dead_code = D - E;
42-1066 . dead_code = F - G;
42-1067 . */
42-1068 .
42-1069 . A = B+C;
42-1070 . A = B/C;
42-1071 .
42-1072 . if (A ne B)
42-1073 . {
42-1074 . A = B + C;
42-1075 . D = E + F;
42-1076 . }
42-1077 .
42-1078 . A = B/C;
42-1079 . A = B/C;
42-1080 . A = B/C;
42-1081 .
42-1082 . if (veg)
42-1083 . // missing curly brace
42-1084 . variable = orange;
42-1085 .
42-1086 . A = B*C;
42-1087 . A = B+C;
42-1088 . A = B-C;
42-1089 . A = B*C;
42-1090 . A = B/C;
42-1091 . /* LE SV TOC-2249 this is a msaw-04.10.23 req to recover*/
42-1092 . A = (long)B + C;
42-1093 .
42-1094 . if (A > = B)
42-1095 . {
42-1096 . A = B + C;
42-1097 . D = E + F;
42-1098 . }
42-1099 .
42-1100 . A = B-C;
42-1101 .
42-1102 . if (A > B)
42-1103 . {
42-1104 . A = B + C;
42-1105 . D = E + F;
42-1106 . }
42-1107 .
42-1108 . A = B*C;
42-1109 . /* LE SV TOC-2250 this is a msaw-04.10.27 req to audit*/
42-1110 .
42-1111 . if (A gt B)
42-1112 . {
42-1113 . A = B + C;
42-1114 . D = E + F;
42-1115 . }
42-1116 .
42-1117 . A = 0x0009;
42-1118 .
42-1119 . if (A > = B)
42-1120 . {
42-1121 . A = B + C;
42-1122 . D = E + F;
42-1123 . }
42-1124 .
42-1125 .
42-1126 . if (A > = B)
42-1127 . {
42-1128 . A = B + C;
42-1129 . D = E + F;
42-1130 . }
42-1131 .
42-1132 .
42-1133 . if (A ge B)
42-1134 . {
42-1135 . A = B + C;
42-1136 . D = E + F;
42-1137 . }
42-1138 .
42-1139 . A = B+C;
42-1140 .
42-1141 . if (A lt B)
42-1142 . {
42-1143 . A = B + C;
42-1144 . D = E + F;
42-1145 . }
42-1146 .
42-1147 .
42-1148 . if (A > B)
42-1149 . {
42-1150 . A = B + C;
42-1151 . D = E + F;
42-1152 . }
42-1153 .
42-1154 . A = B/C;
42-1155 .
42-1156 . if ($msaw stuff > $othermsaw stuff)
42-1157 . /* LE SV TOC-008 we really should log all error calls */
42-1158 . {
42-1159 . A = B + C;
42-1160 . }
42-1161 .
42-1162 . A = B*C;
42-1163 . A = B/C;
42-1164 . // TBD - what do I do now
42-1165 . A = B+C;
42-1166 .
42-1167 . if (A < B)
42-1168 . {
42-1169 . A = B + C;
42-1170 . D = E + F;
42-1171 . }
42-1172 .
42-1173 .
42-1174 . if (A lt B)
42-1175 . {
42-1176 . A = B + C;
42-1177 . D = E + F;
42-1178 . }
42-1179 .
42-1180 . A = B-C;
42-1181 .
42-1182 . if (A le B)
42-1183 . {
42-1184 . A = B + C;
42-1185 . D = E + F;
42-1186 . }
42-1187 .
42-1188 .
42-1189 . if (A gt B)
42-1190 . {
42-1191 . A = B + C;
42-1192 . D = E + F;
42-1193 . }
42-1194 .
42-1195 . A = B*C;
42-1196 .
42-1197 . if (A > B)
42-1198 . {
42-1199 . A = B + C;
42-1200 . D = E + F;
42-1201 . }
42-1202 .
42-1203 . FreePtr = HmiStringPtr;
42-1204 .
42-1205 . if (A ne B)
42-1206 . {
42-1207 . A = B + C;
42-1208 . D = E + F;
42-1209 . }
42-1210 .
42-1211 . A = B/C;
42-1212 . A = B*C;
42-1213 . A = B*C;
42-1214 . A = B/C;
42-1215 . A = B*C;
42-1216 . A = B-C;
42-1217 . A = B*C;
42-1218 . A = B*C;
42-1219 .
42-1220 . if (A > = B)
42-1221 . {
42-1222 . A = B + C;
42-1223 . D = E + F;
42-1224 . }
42-1225 .
42-1226 . A = B*C;
42-1227 . A = B*C;
42-1228 . // max LOC 56
42-1229 .
42-1230 . }
42-1231 .
42-1232 .
42-1233 . /*
42-1234 . -----------------------------------------------------------------------------
42-1235 . --| NAME: msaw.4.11
42-1236 . --|
42-1237 . --| ABSTRACT:
42-1238 . --| This function does msaw stuff.
42-1239 . --|
42-1240 . --| RETURNS:
42-1241 . --| NONE.
42-1242 . --|
42-1243 . ----------------------------------------------------------------------------
42-1244 . */
42-1245 . static void msaw.4.11(void)
42-1246 . {
42-1247 . A = B*C;
42-1248 . A = 0x0009;
42-1249 . A = B/C;
42-1250 .
42-1251 . if (A le B)
42-1252 . {
42-1253 . A = B + C;
42-1254 . D = E + F;
42-1255 . }
42-1256 .
42-1257 . A = B+C;
42-1258 . A = B+C;
42-1259 . A = B+C;
42-1260 .
42-1261 . if (A == B)
42-1262 . {
42-1263 . A = B + C;
42-1264 . D = E + F;
42-1265 . }
42-1266 .
42-1267 . A = B-C;
42-1268 . A = B+C;
42-1269 . A = B-C;
42-1270 . A = B*C;
42-1271 . // TBD - what do I do now
42-1272 . A = B*C;
42-1273 . A = B+C;
42-1274 .
42-1275 . if (A eq B)
42-1276 . {
42-1277 . A = B + C;
42-1278 . D = E + F;
42-1279 . }
42-1280 .
42-1281 . /* LE SV TOC-2251 this is a msaw-04.11.15 req to halt*/
42-1282 . A = B/C;
42-1283 . A = B+C;
42-1284 .
42-1285 . if (A lt B)
42-1286 . {
42-1287 . A = B + C;
42-1288 . D = E + F;
42-1289 . }
42-1290 .
42-1291 . A = B-C;
42-1292 . A = B-C;
42-1293 .
42-1294 . if (A < = B)
42-1295 . {
42-1296 . A = B + C;
42-1297 . D = E + F;
42-1298 . }
42-1299 .
42-1300 .
42-1301 . if (A > = B)
42-1302 . {
42-1303 . A = B + C;
42-1304 . D = E + F;
42-1305 . }
42-1306 .
42-1307 .
42-1308 . if (A gt B)
42-1309 . {
42-1310 . A = B + C;
42-1311 . D = E + F;
42-1312 . }
42-1313 .
42-1314 . A = B-C;
42-1315 . A = B+C;
42-1316 .
42-1317 . if (A ge B)
42-1318 . {
42-1319 . A = B + C;
42-1320 . D = E + F;
42-1321 . }
42-1322 .
42-1323 . A = B/C;
42-1324 .
42-1325 . if (A != B)
42-1326 . {
42-1327 . A = B + C;
42-1328 . D = E + F;
42-1329 . }
42-1330 .
42-1331 . A = B-C;
42-1332 .
42-1333 . switch (msaw stuff)
42-1334 . {
42-1335 . case one:
42-1336 . {
42-1337 . switch (nested)
42-1338 . {
42-1339 . case:
42-1340 . X = Y + Z;
42-1341 . case:
42-1342 . X = Y + Z;
42-1343 . default:
42-1344 . SwError;
42-1345 . }
42-1346 . }
42-1347 . case two:
42-1348 . {
42-1349 . run_this;
42-1350 . break;
42-1351 . }
42-1352 . default:
42-1353 . {
42-1354 . SwError;
42-1355 . }
42-1356 . }
42-1357 .
42-1358 . A = B+C;
42-1359 . A = B-C;
42-1360 . A = B+C;
42-1361 . A = B+C;
42-1362 . A = (float)B + C;
42-1363 . A = B*C;
42-1364 . A = 0x0002;
42-1365 . A = B*C;
42-1366 . A = B-C;
42-1367 .
42-1368 . if (A < B)
42-1369 . {
42-1370 . A = B + C;
42-1371 . D = E + F;
42-1372 . }
42-1373 .
42-1374 . /* LE SV TOC-2252 this is a msaw-04.11.37 req to store*/
42-1375 . A = B-C;
42-1376 .
42-1377 . if (A < B)
42-1378 . {
42-1379 . A = B + C;
42-1380 . D = E + F;
42-1381 . }
42-1382 .
42-1383 . A = B/C;
42-1384 . A = B*C;
42-1385 .
42-1386 . if (A ge B)
42-1387 . {
42-1388 . A = B + C;
42-1389 . D = E + F;
42-1390 . }
42-1391 .
42-1392 . A = B/C;
42-1393 . /* LE SV TOC-2253 this is a msaw-04.11.43 req to transform*/
42-1394 .
42-1395 . if (A gt B)
42-1396 . {
42-1397 . A = B + C;
42-1398 . D = E + F;
42-1399 . }
42-1400 .
42-1401 . A = B-C;
42-1402 . A = B+C;
42-1403 . A = B-C;
42-1404 .
42-1405 . if (A ge B)
42-1406 . {
42-1407 . A = B + C;
42-1408 . D = E + F;
42-1409 . }
42-1410 .
42-1411 .
42-1412 . switch (msaw stuff)
42-1413 . {
42-1414 . case one:
42-1415 . {
42-1416 . run_this;
42-1417 . break;
42-1418 . }
42-1419 . case two:
42-1420 . {
42-1421 . run_this;
42-1422 . break;
42-1423 . }
42-1424 . default:
42-1425 . {
42-1426 . SwError;
42-1427 . }
42-1428 . }
42-1429 .
42-1430 . A = B/C;
42-1431 .
42-1432 . if (A < B)
42-1433 . {
42-1434 . A = B + C;
42-1435 . D = E + F;
42-1436 . }
42-1437 .
42-1438 . // max LOC 50
42-1439 .
42-1440 . }
42-1441 .
42-1442 .
42-1443 . /*
42-1444 . -----------------------------------------------------------------------------
42-1445 . --| NAME: msaw.4.12
42-1446 . --|
42-1447 . --| ABSTRACT:
42-1448 . --| This function does msaw stuff.
42-1449 . --|
42-1450 . --| RETURNS:
42-1451 . --| NONE.
42-1452 . --|
42-1453 . ----------------------------------------------------------------------------
42-1454 . */
42-1455 . static void msaw.4.12(void)
42-1456 . {
42-1457 .
42-1458 . if (A le B)
42-1459 . {
42-1460 . A = B + C;
42-1461 . D = E + F;
42-1462 . }
42-1463 .
42-1464 . A = B*C;
42-1465 . A = B/C;
42-1466 . A = B-C;
42-1467 . A = B+C;
42-1468 . A = B/C;
42-1469 . A = B+C;
42-1470 . A = B/C;
42-1471 .
42-1472 . if (A != B)
42-1473 . {
42-1474 . A = B + C;
42-1475 . D = E + F;
42-1476 . }
42-1477 .
42-1478 . A = B*C;
42-1479 . A = B+C;
42-1480 .
42-1481 . if (A ge B)
42-1482 . {
42-1483 . A = B + C;
42-1484 . D = E + F;
42-1485 . }
42-1486 .
42-1487 .
42-1488 . if (A > = B)
42-1489 . {
42-1490 . A = B + C;
42-1491 . D = E + F;
42-1492 . }
42-1493 .
42-1494 . // max LOC 13
42-1495 .
42-1496 . }
42-1497 .
42-1498 .
42-1499 . /*
42-1500 . -----------------------------------------------------------------------------
42-1501 . --| NAME: msaw.4.13
42-1502 . --|
42-1503 . --| ABSTRACT:
42-1504 . --| This function does msaw stuff.
42-1505 . --|
42-1506 . --| RETURNS:
42-1507 . --| NONE.
42-1508 . --|
42-1509 . ----------------------------------------------------------------------------
42-1510 . */
42-1511 . static void msaw.4.13(void)
42-1512 . {
42-1513 .
42-1514 . if (A lt B)
42-1515 . {
42-1516 . A = B + C;
42-1517 . D = E + F;
42-1518 . }
42-1519 .
42-1520 .
42-1521 . if (veg)
42-1522 . // missing curly brace
42-1523 . variable = orange;
42-1524 .
42-1525 . A = B+C;
42-1526 . A = B+C;
42-1527 .
42-1528 . if (A > B)
42-1529 . {
42-1530 . A = B + C;
42-1531 . D = E + F;
42-1532 . }
42-1533 .
42-1534 . A = B-C;
42-1535 . A = B-C;
42-1536 .
42-1537 . if (A eq B)
42-1538 . {
42-1539 . A = B + C;
42-1540 . D = E + F;
42-1541 . }
42-1542 .
42-1543 .
42-1544 . if (A lt B)
42-1545 . {
42-1546 . A = B + C;
42-1547 . D = E + F;
42-1548 . }
42-1549 .
42-1550 .
42-1551 . if (A == B)
42-1552 . {
42-1553 . A = B + C;
42-1554 . D = E + F;
42-1555 . }
42-1556 .
42-1557 .
42-1558 . if (A > B)
42-1559 . {
42-1560 . A = B + C;
42-1561 . D = E + F;
42-1562 . }
42-1563 .
42-1564 . A = B-C;
42-1565 . A = B/C;
42-1566 .
42-1567 . if (A < B)
42-1568 . {
42-1569 . A = B + C;
42-1570 . D = E + F;
42-1571 . }
42-1572 .
42-1573 . A = B*C;
42-1574 .
42-1575 . if (A != B)
42-1576 . {
42-1577 . A = B + C;
42-1578 . D = E + F;
42-1579 . }
42-1580 .
42-1581 . A = (long)B + C;
42-1582 . A = B*C;
42-1583 . A = B+C;
42-1584 .
42-1585 . if (A > = B)
42-1586 . {
42-1587 . A = B + C;
42-1588 . D = E + F;
42-1589 . }
42-1590 .
42-1591 . A = 0x0003;
42-1592 . A = B*C;
42-1593 . A = B-C;
42-1594 . A = B-C;
42-1595 .
42-1596 . if (A lt B)
42-1597 . {
42-1598 . A = B + C;
42-1599 . D = E + F;
42-1600 . }
42-1601 .
42-1602 . A = B/C;
42-1603 . A = B+C;
42-1604 .
42-1605 . if (A gt B)
42-1606 . {
42-1607 . A = B + C;
42-1608 . D = E + F;
42-1609 . }
42-1610 .
42-1611 . A = B+C;
42-1612 . A = 0x0006;
42-1613 .
42-1614 . if (A < B)
42-1615 . {
42-1616 . A = B + C;
42-1617 . D = E + F;
42-1618 . }
42-1619 .
42-1620 .
42-1621 . if (A le B)
42-1622 . {
42-1623 . A = B + C;
42-1624 . D = E + F;
42-1625 . }
42-1626 .
42-1627 .
42-1628 . if (A < = B)
42-1629 . {
42-1630 . A = B + C;
42-1631 . D = E + F;
42-1632 . }
42-1633 .
42-1634 . A = B+C;
42-1635 . /* LE SV TOC-2254 this is a msaw-04.13.31 req to check pSOS*/
42-1636 . A = B-C;
42-1637 . A = B+C;
42-1638 . A = B/C;
42-1639 .
42-1640 . if (A != B)
42-1641 . {
42-1642 . A = B + C;
42-1643 . D = E + F;
42-1644 . }
42-1645 .
42-1646 .
42-1647 . if (A ge B)
42-1648 . {
42-1649 . A = B + C;
42-1650 . D = E + F;
42-1651 . }
42-1652 .
42-1653 . A = B*C;
42-1654 . A = B+C;
42-1655 . // ??? go see ws
42-1656 . A = B-C;
42-1657 .
42-1658 . if (A ne B)
42-1659 . {
42-1660 . A = B + C;
42-1661 . D = E + F;
42-1662 . }
42-1663 .
42-1664 . A = B*C;
42-1665 .
42-1666 . if (A ne B)
42-1667 . {
42-1668 . A = B + C;
42-1669 . D = E + F;
42-1670 . }
42-1671 .
42-1672 . A = B/C;
42-1673 .
42-1674 . if (A == B)
42-1675 . {
42-1676 . A = B + C;
42-1677 . D = E + F;
42-1678 . }
42-1679 .
42-1680 . A = B*C;
42-1681 . // max LOC 44
42-1682 .
42-1683 . }
42-1684 .
42-1685 .
42-1686 . /*
42-1687 . -----------------------------------------------------------------------------
42-1688 . --| NAME: msaw.4.14
42-1689 . --|
42-1690 . --| ABSTRACT:
42-1691 . --| This function does msaw stuff.
42-1692 . --|
42-1693 . --| RETURNS:
42-1694 . --| NONE.
42-1695 . --|
42-1696 . ----------------------------------------------------------------------------
42-1697 . */
42-1698 . static void msaw.4.14(void)
42-1699 . {
42-1700 . A = B/C;
42-1701 . A = B-C;
42-1702 . A = B+C;
42-1703 . send_buffer = (U16 *) malloc(size+1);
42-1704 . A = B*C;
42-1705 . A = B+C;
42-1706 . A = B-C;
42-1707 . A = B-C;
42-1708 . A = B-C;
42-1709 . A = B*C;
42-1710 .
42-1711 . if {
42-1712 . X = Y + Z;
42-1713 . }
42-1714 . else {
42-1715 . halt;
42-1716 . }
42-1717 .
42-1718 . A = B-C;
42-1719 . /* LE SV TOC-2255 this is a msaw-04.14.11 req to inhibit*/
42-1720 . goto error;
42-1721 .
42-1722 . if (A ne B)
42-1723 . {
42-1724 . A = B + C;
42-1725 . D = E + F;
42-1726 . }
42-1727 .
42-1728 . A = B+C;
42-1729 . A = B*C;
42-1730 . A = B-C;
42-1731 . /* LE SV TOC-2256 this is a msaw-04.14.15 req to disable*/
42-1732 . A = B+C;
42-1733 . A = B/C;
42-1734 . A = B+C;
42-1735 . A = B/C;
42-1736 .
42-1737 . if (A == B)
42-1738 . {
42-1739 . A = B + C;
42-1740 . D = E + F;
42-1741 . }
42-1742 .
42-1743 . A = B*C;
42-1744 . // TBD - what do I do now
42-1745 . A = B-C;
42-1746 . A = B/C;
42-1747 . A = B-C;
42-1748 . A = B+C;
42-1749 . A = B+C;
42-1750 . A = B-C;
42-1751 .
42-1752 . if (A le B)
42-1753 . {
42-1754 . A = B + C;
42-1755 . D = E + F;
42-1756 . }
42-1757 .
42-1758 . // max LOC 27
42-1759 .
42-1760 . }
42-1761 .
42 42 Result: result/source/ft-app/ft-app-B1.1/msaw/msaw-04.c
43 43 Source: source/ft-app/ft-app-B1.1/pwr/pwr-01.c
43-0 . /*
43-1 . ----------------------------------------------------------------------------
43-2 . --| BEGIN PROLOGUE
43-3 . --|
43-4 . --| CLASSIFICATION: UNCLASSIFIED
43-5 . --|
43-6 . --| FILE NAME: pwr-01.c
43-7 . --|
43-8 . --| ABSTRACT:
43-9 . --| This file contains the 13 functions that do file pwr stuff.
43-10 . --|
43-11 . --| HISTORY:
43-12 . --| CCCQ_NAME:
43-13 . --| CCCQ_VER:
43-14 . --|
43-15 . --| END PROLOGUE
43-16 . ----------------------------------------------------------------------------
43-17 . */
43-18 .
43-19 . char D;
43-20 . #include C;
43-21 . char D;
43-22 . #define C;
43-23 . #define A;
43-24 .
43-25 .
43-26 .
43-27 . /*
43-28 . -----------------------------------------------------------------------------
43-29 . --| NAME: pwr.1.1
43-30 . --|
43-31 . --| ABSTRACT:
43-32 . --| This function does pwr stuff.
43-33 . --|
43-34 . --| RETURNS:
43-35 . --| NONE.
43-36 . --|
43-37 . ----------------------------------------------------------------------------
43-38 . */
43-39 . static void pwr.1.1(void)
43-40 . {
43-41 . A = B*C;
43-42 . A = B/C;
43-43 .
43-44 . if (A < B)
43-45 . {
43-46 . A = B + C;
43-47 . D = E + F;
43-48 . }
43-49 .
43-50 . A = 0x0009;
43-51 .
43-52 . if (A > B)
43-53 . {
43-54 . A = B + C;
43-55 . D = E + F;
43-56 . }
43-57 .
43-58 .
43-59 . if (A < B)
43-60 . {
43-61 . A = B + C;
43-62 . D = E + F;
43-63 . }
43-64 .
43-65 . A = B-C;
43-66 . A = B-C;
43-67 . // max LOC 7
43-68 .
43-69 . }
43-70 .
43-71 .
43-72 . /*
43-73 . -----------------------------------------------------------------------------
43-74 . --| NAME: pwr.1.2
43-75 . --|
43-76 . --| ABSTRACT:
43-77 . --| This function does pwr stuff.
43-78 . --|
43-79 . --| RETURNS:
43-80 . --| NONE.
43-81 . --|
43-82 . ----------------------------------------------------------------------------
43-83 . */
43-84 . static void pwr.1.2(void)
43-85 . {
43-86 .
43-87 . if (A != B)
43-88 . {
43-89 . A = B + C;
43-90 . D = E + F;
43-91 . }
43-92 .
43-93 . A = B/C;
43-94 .
43-95 . if (A gt B)
43-96 . {
43-97 . A = B + C;
43-98 . D = E + F;
43-99 . }
43-100 .
43-101 .
43-102 . if (A == B)
43-103 . {
43-104 . A = B + C;
43-105 . D = E + F;
43-106 . }
43-107 .
43-108 . A = B/C;
43-109 . A = B/C;
43-110 . A = B+C;
43-111 .
43-112 . if (A < B)
43-113 . {
43-114 . A = B + C;
43-115 . D = E + F;
43-116 . }
43-117 .
43-118 . A = B-C;
43-119 .
43-120 . if (A eq B)
43-121 . {
43-122 . A = B + C;
43-123 . D = E + F;
43-124 . }
43-125 .
43-126 . A = B*C;
43-127 . A = B-C;
43-128 . // (P) this is really improtant
43-129 . A = B+C;
43-130 .
43-131 . if (A < = B)
43-132 . {
43-133 . A = B + C;
43-134 . D = E + F;
43-135 . }
43-136 .
43-137 . A = B+C;
43-138 .
43-139 . if (A gt B)
43-140 . {
43-141 . A = B + C;
43-142 . D = E + F;
43-143 . }
43-144 .
43-145 .
43-146 . if (A le B)
43-147 . {
43-148 . A = B + C;
43-149 . D = E + F;
43-150 . }
43-151 .
43-152 . A = B/C;
43-153 . /* LE SV TOC-2401 this is a pwr-01.2.19 req to disable*/
43-154 . A = B/C;
43-155 . A = B+C;
43-156 . A = B/C;
43-157 . A = B*C;
43-158 . A = B*C;
43-159 . A = B/C;
43-160 . /* LE SV TOC-2402 this is a pwr-01.2.25 req to update*/
43-161 . A = B-C;
43-162 .
43-163 . if (A lt B)
43-164 . {
43-165 . A = B + C;
43-166 . D = E + F;
43-167 . }
43-168 .
43-169 . A = B*C;
43-170 .
43-171 . if (A ge B)
43-172 . {
43-173 . A = B + C;
43-174 . D = E + F;
43-175 . }
43-176 .
43-177 .
43-178 . switch (pwr stuff)
43-179 . {
43-180 . case one:
43-181 . {
43-182 . run_this;
43-183 . break;
43-184 . }
43-185 . case two:
43-186 . {
43-187 . run_this;
43-188 . break;
43-189 . }
43-190 . default:
43-191 . {
43-192 . SwError;
43-193 . }
43-194 . }
43-195 .
43-196 . A = B*C;
43-197 . A = B*C;
43-198 .
43-199 . if (A gt B)
43-200 . {
43-201 . A = B + C;
43-202 . D = E + F;
43-203 . }
43-204 .
43-205 . A = B+C;
43-206 . A = B*C;
43-207 . A = B/C;
43-208 . A = B*C;
43-209 .
43-210 . if (A < B)
43-211 . {
43-212 . A = B + C;
43-213 . D = E + F;
43-214 . }
43-215 .
43-216 .
43-217 . if (A lt B)
43-218 . {
43-219 . A = B + C;
43-220 . D = E + F;
43-221 . }
43-222 .
43-223 . /* LE SV TOC-2403 this is a pwr-01.2.39 req to call admin*/
43-224 .
43-225 . if (A > B)
43-226 . {
43-227 . A = B + C;
43-228 . D = E + F;
43-229 . }
43-230 .
43-231 .
43-232 . if (A < B)
43-233 . {
43-234 . A = B + C;
43-235 . D = E + F;
43-236 . }
43-237 .
43-238 . A = B*C;
43-239 . A = B+C;
43-240 . A = B/C;
43-241 . A = B-C;
43-242 . A = B/C;
43-243 .
43-244 . #ifdef LAZY
43-245 . // this is not nice
43-246 . A = B + C;
43-247 . A = B + C;
43-248 . #endif
43-249 .
43-250 .
43-251 . if (A < = B)
43-252 . {
43-253 . A = B + C;
43-254 . D = E + F;
43-255 . }
43-256 .
43-257 . /* LE SV TOC-2404 this is a pwr-01.2.47 req to validate*/
43-258 .
43-259 . if (A le B)
43-260 . {
43-261 . A = B + C;
43-262 . D = E + F;
43-263 . }
43-264 .
43-265 . A = B-C;
43-266 . A = B/C;
43-267 . A = B+C;
43-268 .
43-269 . if (A > = B)
43-270 . {
43-271 . A = B + C;
43-272 . D = E + F;
43-273 . }
43-274 .
43-275 .
43-276 . if (A ne B)
43-277 . {
43-278 . A = B + C;
43-279 . D = E + F;
43-280 . }
43-281 .
43-282 . A = B*C;
43-283 .
43-284 . if (A > = B)
43-285 . {
43-286 . A = B + C;
43-287 . D = E + F;
43-288 . }
43-289 .
43-290 .
43-291 . if (A != B)
43-292 . {
43-293 . A = B + C;
43-294 . D = E + F;
43-295 . }
43-296 .
43-297 . A = B-C;
43-298 . A = B+C;
43-299 .
43-300 . if (A eq B)
43-301 . {
43-302 . A = B + C;
43-303 . D = E + F;
43-304 . }
43-305 .
43-306 . A = B+C;
43-307 .
43-308 . switch (pwr stuff)
43-309 . {
43-310 . case one:
43-311 . {
43-312 . run_this;
43-313 . break;
43-314 . }
43-315 . case two:
43-316 . {
43-317 . run_this;
43-318 . break;
43-319 . }
43-320 . default:
43-321 . {
43-322 . SwError;
43-323 . }
43-324 . }
43-325 .
43-326 . FreePtr = HmiStringPtr;
43-327 . A = B*C;
43-328 . A = B-C;
43-329 . // max LOC 62
43-330 .
43-331 . }
43-332 .
43-333 .
43-334 . /*
43-335 . -----------------------------------------------------------------------------
43-336 . --| NAME: pwr.1.3
43-337 . --|
43-338 . --| ABSTRACT:
43-339 . --| This function does pwr stuff.
43-340 . --|
43-341 . --| RETURNS:
43-342 . --| NONE.
43-343 . --|
43-344 . ----------------------------------------------------------------------------
43-345 . */
43-346 . static void pwr.1.3(void)
43-347 . {
43-348 .
43-349 . if (A le B)
43-350 . {
43-351 . A = B + C;
43-352 . D = E + F;
43-353 . }
43-354 .
43-355 . A = B+C;
43-356 . A = B/C;
43-357 . rcv_buffer = (U16 *) alloc(size+1);
43-358 . A = B*C;
43-359 . A = B*C;
43-360 .
43-361 . if (A < = B)
43-362 . {
43-363 . A = B + C;
43-364 . D = E + F;
43-365 . }
43-366 .
43-367 . A = B-C;
43-368 . A = B/C;
43-369 . A = B+C;
43-370 . /* LE SV TOC-2405 this is a pwr-01.3.10 req to transform*/
43-371 . A = B*C;
43-372 .
43-373 . if (A lt B)
43-374 . {
43-375 . A = B + C;
43-376 . D = E + F;
43-377 . }
43-378 .
43-379 .
43-380 . if (A == B)
43-381 . {
43-382 . A = B + C;
43-383 . D = E + F;
43-384 . }
43-385 .
43-386 .
43-387 . if (A ne B)
43-388 . {
43-389 . A = B + C;
43-390 . D = E + F;
43-391 . }
43-392 .
43-393 . A = B/C;
43-394 . A = B/C;
43-395 .
43-396 . switch (pwr stuff)
43-397 . {
43-398 . case one:
43-399 . {
43-400 . run_this;
43-401 . break;
43-402 . }
43-403 . case two:
43-404 . {
43-405 . run_this;
43-406 . break;
43-407 . }
43-408 . default:
43-409 . {
43-410 . SwError;
43-411 . }
43-412 . }
43-413 .
43-414 . A = B*C;
43-415 . A = B-C;
43-416 . A = B/C;
43-417 . // max LOC 19
43-418 .
43-419 . }
43-420 .
43-421 .
43-422 . /*
43-423 . -----------------------------------------------------------------------------
43-424 . --| NAME: pwr.1.4
43-425 . --|
43-426 . --| ABSTRACT:
43-427 . --| This function does pwr stuff.
43-428 . --|
43-429 . --| RETURNS:
43-430 . --| NONE.
43-431 . --|
43-432 . ----------------------------------------------------------------------------
43-433 . */
43-434 . static void pwr.1.4(void)
43-435 . {
43-436 . A = B+C;
43-437 . A = B-C;
43-438 .
43-439 . if (A < = B)
43-440 . {
43-441 . A = B + C;
43-442 . D = E + F;
43-443 . }
43-444 .
43-445 . A = B-C;
43-446 . A = B*C;
43-447 . A = B/C;
43-448 .
43-449 . if (A > = B)
43-450 . {
43-451 . A = B + C;
43-452 . D = E + F;
43-453 . }
43-454 .
43-455 . A = B+C;
43-456 .
43-457 . if (A != B)
43-458 . {
43-459 . A = B + C;
43-460 . D = E + F;
43-461 . }
43-462 .
43-463 .
43-464 . if (A == B)
43-465 . {
43-466 . A = B + C;
43-467 . D = E + F;
43-468 . }
43-469 .
43-470 . A = B/C;
43-471 . // max LOC 11
43-472 .
43-473 . }
43-474 .
43-475 .
43-476 . /*
43-477 . -----------------------------------------------------------------------------
43-478 . --| NAME: pwr.1.5
43-479 . --|
43-480 . --| ABSTRACT:
43-481 . --| This function does pwr stuff.
43-482 . --|
43-483 . --| RETURNS:
43-484 . --| NONE.
43-485 . --|
43-486 . ----------------------------------------------------------------------------
43-487 . */
43-488 . static void pwr.1.5(void)
43-489 . {
43-490 . A = B*C;
43-491 . A = B/C;
43-492 . /* LE SV TOC-2406 this is a pwr-01.5.3 req to set Real Time Clock*/
43-493 . A = B+C;
43-494 . A = B*C;
43-495 . A = B-C;
43-496 . A = B+C;
43-497 .
43-498 . if {
43-499 . X = Y + Z;
43-500 . }
43-501 . else {
43-502 . halt;
43-503 . }
43-504 .
43-505 . A = B-C;
43-506 . A = B/C;
43-507 . A = B/C;
43-508 .
43-509 . if (A lt B)
43-510 . {
43-511 . A = B + C;
43-512 . D = E + F;
43-513 . }
43-514 .
43-515 . /* LE SV TOC-2407 this is a pwr-01.5.11 req to compare*/
43-516 . A = B+C;
43-517 . A = B+C;
43-518 . A = B-C;
43-519 .
43-520 . if (A == B)
43-521 . {
43-522 . A = B + C;
43-523 . D = E + F;
43-524 . }
43-525 .
43-526 . A = B*C;
43-527 .
43-528 . switch (pwr stuff)
43-529 . {
43-530 . case one:
43-531 . {
43-532 . run_this;
43-533 . break;
43-534 . }
43-535 . case two:
43-536 . {
43-537 . run_this;
43-538 . break;
43-539 . }
43-540 . default:
43-541 . {
43-542 . // missing error call
43-543 . }
43-544 . }
43-545 .
43-546 .
43-547 . if (A > B)
43-548 . {
43-549 . A = B + C;
43-550 . D = E + F;
43-551 . }
43-552 .
43-553 .
43-554 . if (A > B)
43-555 . {
43-556 . A = B + C;
43-557 . D = E + F;
43-558 . }
43-559 .
43-560 .
43-561 . switch (pwr stuff)
43-562 . {
43-563 . case one:
43-564 . {
43-565 . run_this;
43-566 . break;
43-567 . }
43-568 . case two:
43-569 . {
43-570 . run_this;
43-571 . break;
43-572 . }
43-573 . default:
43-574 . {
43-575 . SwError;
43-576 . }
43-577 . }
43-578 .
43-579 . A = B*C;
43-580 . A = B-C;
43-581 . A = B+C;
43-582 . A = B/C;
43-583 . A = B-C;
43-584 . A = B*C;
43-585 . A = B/C;
43-586 . A = B*C;
43-587 .
43-588 . if (A ne B)
43-589 . {
43-590 . A = B + C;
43-591 . D = E + F;
43-592 . }
43-593 .
43-594 .
43-595 . if (A eq B)
43-596 . {
43-597 . A = B + C;
43-598 . D = E + F;
43-599 . }
43-600 .
43-601 . A = B-C;
43-602 .
43-603 . if (A > = B)
43-604 . {
43-605 . A = B + C;
43-606 . D = E + F;
43-607 . }
43-608 .
43-609 . A = B/C;
43-610 .
43-611 . if (A ge B)
43-612 . {
43-613 . A = B + C;
43-614 . D = E + F;
43-615 . }
43-616 .
43-617 . A = B/C;
43-618 .
43-619 . if (A ge B)
43-620 . {
43-621 . A = B + C;
43-622 . D = E + F;
43-623 . }
43-624 .
43-625 .
43-626 . if (A < B)
43-627 . {
43-628 . A = B + C;
43-629 . D = E + F;
43-630 . }
43-631 .
43-632 .
43-633 . if (A ge B)
43-634 . {
43-635 . A = B + C;
43-636 . D = E + F;
43-637 . }
43-638 .
43-639 . // max LOC 36
43-640 .
43-641 . }
43-642 .
43-643 .
43-644 . /*
43-645 . -----------------------------------------------------------------------------
43-646 . --| NAME: pwr.1.6
43-647 . --|
43-648 . --| ABSTRACT:
43-649 . --| This function does pwr stuff.
43-650 . --|
43-651 . --| RETURNS:
43-652 . --| NONE.
43-653 . --|
43-654 . ----------------------------------------------------------------------------
43-655 . */
43-656 . static void pwr.1.6(void)
43-657 . {
43-658 . A = B+C;
43-659 . A = B+C;
43-660 .
43-661 . if (A != B)
43-662 . {
43-663 . A = B + C;
43-664 . D = E + F;
43-665 . }
43-666 .
43-667 . /* LE SV TOC-2408 this is a pwr-01.6.4 req to enable*/
43-668 . A = B*C;
43-669 .
43-670 . if (A < = B)
43-671 . {
43-672 . A = B + C;
43-673 . D = E + F;
43-674 . }
43-675 .
43-676 . A = B*C;
43-677 . A = B-C;
43-678 . A = B+C;
43-679 .
43-680 . if (A eq B)
43-681 . {
43-682 . A = B + C;
43-683 . D = E + F;
43-684 . }
43-685 .
43-686 . A = B-C;
43-687 . A = B*C;
43-688 . A = B-C;
43-689 . A = B/C;
43-690 . A = B*C;
43-691 .
43-692 . if (A < B)
43-693 . {
43-694 . A = B + C;
43-695 . D = E + F;
43-696 . }
43-697 .
43-698 .
43-699 . if (A lt B)
43-700 . {
43-701 . A = B + C;
43-702 . D = E + F;
43-703 . }
43-704 .
43-705 . A = B+C;
43-706 . A = B-C;
43-707 . A = B*C;
43-708 .
43-709 . if (A < = B)
43-710 . {
43-711 . A = B + C;
43-712 . D = E + F;
43-713 . }
43-714 .
43-715 . A = B-C;
43-716 .
43-717 . if (A != B)
43-718 . {
43-719 . A = B + C;
43-720 . D = E + F;
43-721 . }
43-722 .
43-723 . A = B/C;
43-724 .
43-725 . switch (pwr stuff)
43-726 . {
43-727 . case one:
43-728 . {
43-729 . run_this;
43-730 . break;
43-731 . }
43-732 . case two:
43-733 . {
43-734 . run_this;
43-735 . break;
43-736 . }
43-737 . // missing default
43-738 . }
43-739 .
43-740 . A = B+C;
43-741 . A = B+C;
43-742 .
43-743 . switch (pwr stuff)
43-744 . {
43-745 . case one:
43-746 . {
43-747 . run_this;
43-748 . break;
43-749 . }
43-750 . case two:
43-751 . {
43-752 . run_this;
43-753 . break;
43-754 . }
43-755 . default:
43-756 . {
43-757 . // missing error call
43-758 . }
43-759 . }
43-760 .
43-761 . A = B-C;
43-762 .
43-763 . if (A < B)
43-764 . {
43-765 . A = B + C;
43-766 . D = E + F;
43-767 . }
43-768 .
43-769 . A = B/C;
43-770 . A = B-C;
43-771 . A = B+C;
43-772 . A = B/C;
43-773 . A = B-C;
43-774 . A = B+C;
43-775 . A = B-C;
43-776 . A = B-C;
43-777 . A = B/C;
43-778 . A = B/C;
43-779 . A = B*C;
43-780 . A = B+C;
43-781 . A = B*C;
43-782 . A = B*C;
43-783 . A = B+C;
43-784 . /* LE SV TOC-2409 this is a pwr-01.6.43 req to convert*/
43-785 .
43-786 . if (A < = B)
43-787 . {
43-788 . A = B + C;
43-789 . D = E + F;
43-790 . }
43-791 .
43-792 . /* LE SV TOC-2410 this is a pwr-01.6.44 req to verify*/
43-793 . A = B*C;
43-794 . A = B*C;
43-795 . /* LE SV TOC-2411 this is a pwr-01.6.46 req to convert*/
43-796 . A = B*C;
43-797 . A = B-C;
43-798 . A = B/C;
43-799 . // max LOC 48
43-800 .
43-801 . }
43-802 .
43-803 .
43-804 . /*
43-805 . -----------------------------------------------------------------------------
43-806 . --| NAME: pwr.1.7
43-807 . --|
43-808 . --| ABSTRACT:
43-809 . --| This function does pwr stuff.
43-810 . --|
43-811 . --| RETURNS:
43-812 . --| NONE.
43-813 . --|
43-814 . ----------------------------------------------------------------------------
43-815 . */
43-816 . static void pwr.1.7(void)
43-817 . {
43-818 . /* LE SV TOC-2412 this is a pwr-01.7.1 req to transform*/
43-819 . A = B/C;
43-820 . A = B/C;
43-821 . /* LE SV TOC-2413 this is a pwr-01.7.3 req to increment*/
43-822 .
43-823 . if (A > = B)
43-824 . {
43-825 . A = B + C;
43-826 . D = E + F;
43-827 . }
43-828 .
43-829 . A = B*C;
43-830 . A = B*C;
43-831 . A = B*C;
43-832 .
43-833 . if (A < = B)
43-834 . {
43-835 . A = B + C;
43-836 . D = E + F;
43-837 . }
43-838 .
43-839 . A = B*C;
43-840 .
43-841 . if (A ge B)
43-842 . {
43-843 . A = B + C;
43-844 . D = E + F;
43-845 . }
43-846 .
43-847 .
43-848 . switch (pwr stuff)
43-849 . {
43-850 . case one:
43-851 . {
43-852 . run_this;
43-853 . break;
43-854 . }
43-855 . case two:
43-856 . {
43-857 . run_this;
43-858 . break;
43-859 . }
43-860 . default:
43-861 . {
43-862 . SwError;
43-863 . }
43-864 . }
43-865 .
43-866 . A = B-C;
43-867 . A = B-C;
43-868 . A = B-C;
43-869 . A = B/C;
43-870 . A = B/C;
43-871 . /* LE SV TOC-2414 this is a pwr-01.7.16 req to halt*/
43-872 . A = 0x0002;
43-873 . A = B-C;
43-874 .
43-875 . if (A == B)
43-876 . {
43-877 . A = B + C;
43-878 . D = E + F;
43-879 . }
43-880 .
43-881 . A = B+C;
43-882 .
43-883 . if (A le B)
43-884 . {
43-885 . A = B + C;
43-886 . D = E + F;
43-887 . }
43-888 .
43-889 . // max LOC 19
43-890 .
43-891 . }
43-892 .
43-893 .
43-894 . /*
43-895 . -----------------------------------------------------------------------------
43-896 . --| NAME: pwr.1.8
43-897 . --|
43-898 . --| ABSTRACT:
43-899 . --| This function does pwr stuff.
43-900 . --|
43-901 . --| RETURNS:
43-902 . --| NONE.
43-903 . --|
43-904 . ----------------------------------------------------------------------------
43-905 . */
43-906 . static void pwr.1.8(void)
43-907 . {
43-908 .
43-909 . if (A eq B)
43-910 . {
43-911 . A = B + C;
43-912 . D = E + F;
43-913 . }
43-914 .
43-915 . A = B-C;
43-916 .
43-917 . if (A == B)
43-918 . {
43-919 . A = B + C;
43-920 . D = E + F;
43-921 . }
43-922 .
43-923 .
43-924 . if (A eq B)
43-925 . {
43-926 . A = B + C;
43-927 . D = E + F;
43-928 . }
43-929 .
43-930 . /* LE SV TOC-2415 this is a pwr-01.8.5 req to increment*/
43-931 .
43-932 . if (A ne B)
43-933 . {
43-934 . A = B + C;
43-935 . D = E + F;
43-936 . }
43-937 .
43-938 . A = B+C;
43-939 . A = B/C;
43-940 . /* LE SV TOC-2416 this is a pwr-01.8.8 req to check unix*/
43-941 .
43-942 . if (A > B)
43-943 . {
43-944 . A = B + C;
43-945 . D = E + F;
43-946 . }
43-947 .
43-948 .
43-949 . if (A gt B)
43-950 . {
43-951 . A = B + C;
43-952 . D = E + F;
43-953 . }
43-954 .
43-955 . A = B+C;
43-956 . A = B*C;
43-957 .
43-958 . if (A > B)
43-959 . {
43-960 . A = B + C;
43-961 . D = E + F;
43-962 . }
43-963 .
43-964 . A = B+C;
43-965 . A = B*C;
43-966 .
43-967 . if (A ne B)
43-968 . {
43-969 . A = B + C;
43-970 . D = E + F;
43-971 . }
43-972 .
43-973 .
43-974 . if (A eq B)
43-975 . {
43-976 . A = B + C;
43-977 . D = E + F;
43-978 . }
43-979 .
43-980 . A = B*C;
43-981 . A = B*C;
43-982 .
43-983 . if (A ge B)
43-984 . {
43-985 . A = B + C;
43-986 . D = E + F;
43-987 . }
43-988 .
43-989 . A = B+C;
43-990 . A = B+C;
43-991 . A = B*C;
43-992 .
43-993 . if (A > B)
43-994 . {
43-995 . A = B + C;
43-996 . D = E + F;
43-997 . }
43-998 .
43-999 . A = B*C;
43-1000 . A = B/C;
43-1001 . // max LOC 25
43-1002 .
43-1003 . }
43-1004 .
43-1005 .
43-1006 . /*
43-1007 . -----------------------------------------------------------------------------
43-1008 . --| NAME: pwr.1.9
43-1009 . --|
43-1010 . --| ABSTRACT:
43-1011 . --| This function does pwr stuff.
43-1012 . --|
43-1013 . --| RETURNS:
43-1014 . --| NONE.
43-1015 . --|
43-1016 . ----------------------------------------------------------------------------
43-1017 . */
43-1018 . static void pwr.1.9(void)
43-1019 . {
43-1020 .
43-1021 . switch (pwr stuff)
43-1022 . {
43-1023 . case one:
43-1024 . {
43-1025 . run_this;
43-1026 . break;
43-1027 . }
43-1028 . case two:
43-1029 . {
43-1030 . run_this;
43-1031 . break;
43-1032 . }
43-1033 . default:
43-1034 . {
43-1035 . SwError;
43-1036 . }
43-1037 . }
43-1038 .
43-1039 . A = B-C;
43-1040 . A = B-C;
43-1041 . A = B*C;
43-1042 . A = B+C;
43-1043 . /* LE SV TOC-2417 this is a pwr-01.9.6 req to reject*/
43-1044 . A = B-C;
43-1045 . A = B+C;
43-1046 .
43-1047 . if (A > B)
43-1048 . {
43-1049 . A = B + C;
43-1050 . D = E + F;
43-1051 . }
43-1052 .
43-1053 . A = B/C;
43-1054 .
43-1055 . if (A eq B)
43-1056 . {
43-1057 . A = B + C;
43-1058 . D = E + F;
43-1059 . }
43-1060 .
43-1061 . A = B-C;
43-1062 . A = B/C;
43-1063 . /* LE SV TOC-2418 this is a pwr-01.9.13 req to process*/
43-1064 . A = B*C;
43-1065 . A = B-C;
43-1066 .
43-1067 . if (A eq B)
43-1068 . {
43-1069 . A = B + C;
43-1070 . D = E + F;
43-1071 . }
43-1072 .
43-1073 . A = B+C;
43-1074 . A = B/C;
43-1075 . A = B/C;
43-1076 .
43-1077 . switch (pwr stuff)
43-1078 . {
43-1079 . case one:
43-1080 . {
43-1081 . run_this;
43-1082 . break;
43-1083 . }
43-1084 . case two:
43-1085 . {
43-1086 . run_this;
43-1087 . break;
43-1088 . }
43-1089 . default:
43-1090 . {
43-1091 . SwError;
43-1092 . }
43-1093 . }
43-1094 .
43-1095 . /* LE SV TOC-2419 this is a pwr-01.9.20 req to audit*/
43-1096 .
43-1097 . if (A le B)
43-1098 . {
43-1099 . A = B + C;
43-1100 . D = E + F;
43-1101 . }
43-1102 .
43-1103 . A = B-C;
43-1104 . A = B/C;
43-1105 . A = B+C;
43-1106 . A = B*C;
43-1107 . do forever;
43-1108 .
43-1109 . switch (pwr stuff)
43-1110 . {
43-1111 . case one:
43-1112 . {
43-1113 . run_this;
43-1114 . break;
43-1115 . }
43-1116 . case two:
43-1117 . {
43-1118 . run_this;
43-1119 . break;
43-1120 . }
43-1121 . default:
43-1122 . {
43-1123 . SwError;
43-1124 . }
43-1125 . }
43-1126 .
43-1127 .
43-1128 . if (A > = B)
43-1129 . {
43-1130 . A = B + C;
43-1131 . D = E + F;
43-1132 . }
43-1133 .
43-1134 . /* LE SV TOC-2420 this is a pwr-01.9.27 req to detect error*/
43-1135 . A = B+C;
43-1136 .
43-1137 . switch (pwr stuff)
43-1138 . {
43-1139 . case one:
43-1140 . {
43-1141 . run_this;
43-1142 . break;
43-1143 . }
43-1144 . case two:
43-1145 . {
43-1146 . run_this;
43-1147 . break;
43-1148 . }
43-1149 . // missing default
43-1150 . }
43-1151 .
43-1152 . A = B+C;
43-1153 . A = B-C;
43-1154 . A = B+C;
43-1155 . A = B/C;
43-1156 .
43-1157 . if (A ne B)
43-1158 . {
43-1159 . A = B + C;
43-1160 . D = E + F;
43-1161 . }
43-1162 .
43-1163 .
43-1164 . if (A > B)
43-1165 . {
43-1166 . A = B + C;
43-1167 . D = E + F;
43-1168 . }
43-1169 .
43-1170 .
43-1171 . if (A ne B)
43-1172 . {
43-1173 . A = B + C;
43-1174 . D = E + F;
43-1175 . }
43-1176 .
43-1177 . A = B+C;
43-1178 . A = B-C;
43-1179 . A = B*C;
43-1180 . A = B*C;
43-1181 . A = B/C;
43-1182 .
43-1183 . if (A ge B)
43-1184 . {
43-1185 . A = B + C;
43-1186 . D = E + F;
43-1187 . }
43-1188 .
43-1189 . A = B-C;
43-1190 .
43-1191 . if (A le B)
43-1192 . {
43-1193 . A = B + C;
43-1194 . D = E + F;
43-1195 . }
43-1196 .
43-1197 . A = B+C;
43-1198 .
43-1199 . switch (pwr stuff)
43-1200 . {
43-1201 . case one:
43-1202 . {
43-1203 . run_this;
43-1204 . break;
43-1205 . }
43-1206 . case two:
43-1207 . {
43-1208 . run_this;
43-1209 . break;
43-1210 . }
43-1211 . default:
43-1212 . {
43-1213 . SwError;
43-1214 . }
43-1215 . }
43-1216 .
43-1217 . A = B*C;
43-1218 . A = B/C;
43-1219 .
43-1220 . if (A lt B)
43-1221 . {
43-1222 . A = B + C;
43-1223 . D = E + F;
43-1224 . }
43-1225 .
43-1226 . A = B/C;
43-1227 . A = B*C;
43-1228 .
43-1229 . if (A ge B)
43-1230 . {
43-1231 . A = B + C;
43-1232 . D = E + F;
43-1233 . }
43-1234 .
43-1235 . // max LOC 50
43-1236 .
43-1237 . }
43-1238 .
43-1239 .
43-1240 . /*
43-1241 . -----------------------------------------------------------------------------
43-1242 . --| NAME: pwr.1.10
43-1243 . --|
43-1244 . --| ABSTRACT:
43-1245 . --| This function does pwr stuff.
43-1246 . --|
43-1247 . --| RETURNS:
43-1248 . --| NONE.
43-1249 . --|
43-1250 . ----------------------------------------------------------------------------
43-1251 . */
43-1252 . static void pwr.1.10(void)
43-1253 . {
43-1254 . A = B*C;
43-1255 . A = B*C;
43-1256 . A = B*C;
43-1257 . A = B/C;
43-1258 . A = B/C;
43-1259 . A = B*C;
43-1260 . A = B/C;
43-1261 .
43-1262 . if (A le B)
43-1263 . {
43-1264 . A = B + C;
43-1265 . D = E + F;
43-1266 . }
43-1267 .
43-1268 . A = B/C;
43-1269 . A = B/C;
43-1270 . A = B/C;
43-1271 . A = B/C;
43-1272 . A = B-C;
43-1273 .
43-1274 . if (A lt B)
43-1275 . {
43-1276 . A = B + C;
43-1277 . D = E + F;
43-1278 . }
43-1279 .
43-1280 . A = B*C;
43-1281 . A = B+C;
43-1282 . A = B*C;
43-1283 . A = B-C;
43-1284 .
43-1285 . if (A < B)
43-1286 . {
43-1287 . A = B + C;
43-1288 . D = E + F;
43-1289 . }
43-1290 .
43-1291 . A = B+C;
43-1292 . A = B/C;
43-1293 . A = B/C;
43-1294 . A = B+C;
43-1295 . A = B+C;
43-1296 . A = B/C;
43-1297 . rcv_buffer = (U16 *) alloc(size+1);
43-1298 . A = B-C;
43-1299 . send_buffer = (U16 *) malloc(size+1);
43-1300 . A = B+C;
43-1301 .
43-1302 . if (A gt B)
43-1303 . {
43-1304 . A = B + C;
43-1305 . D = E + F;
43-1306 . }
43-1307 .
43-1308 . // (P) this is really improtant
43-1309 . A = B*C;
43-1310 . A = B*C;
43-1311 . A = B/C;
43-1312 . A = B*C;
43-1313 . A = B*C;
43-1314 . A = B-C;
43-1315 .
43-1316 . if (A != B)
43-1317 . {
43-1318 . A = B + C;
43-1319 . D = E + F;
43-1320 . }
43-1321 .
43-1322 . A = B/C;
43-1323 . A = B*C;
43-1324 . A = B/C;
43-1325 . A = B-C;
43-1326 .
43-1327 . if (A == B)
43-1328 . {
43-1329 . A = B + C;
43-1330 . D = E + F;
43-1331 . }
43-1332 .
43-1333 . A = B-C;
43-1334 .
43-1335 . if (A != B)
43-1336 . {
43-1337 . A = B + C;
43-1338 . D = E + F;
43-1339 . }
43-1340 .
43-1341 . A = B/C;
43-1342 . A = B+C;
43-1343 . // max LOC 44
43-1344 .
43-1345 . }
43-1346 .
43-1347 .
43-1348 . /*
43-1349 . -----------------------------------------------------------------------------
43-1350 . --| NAME: pwr.1.11
43-1351 . --|
43-1352 . --| ABSTRACT:
43-1353 . --| This function does pwr stuff.
43-1354 . --|
43-1355 . --| RETURNS:
43-1356 . --| NONE.
43-1357 . --|
43-1358 . ----------------------------------------------------------------------------
43-1359 . */
43-1360 . static void pwr.1.11(void)
43-1361 . {
43-1362 . A = B/C;
43-1363 . A = B/C;
43-1364 . A = B/C;
43-1365 . /* LE SV TOC-2421 this is a pwr-01.11.4 req to store*/
43-1366 . A = B+C;
43-1367 . /* LE SV TOC-2422 this is a pwr-01.11.5 req to update*/
43-1368 .
43-1369 . if (A > = B)
43-1370 . {
43-1371 . A = B + C;
43-1372 . D = E + F;
43-1373 . }
43-1374 .
43-1375 . A = B-C;
43-1376 . A = B/C;
43-1377 . A = B/C;
43-1378 . /* LE SV TOC-2423 this is a pwr-01.11.9 req to fail*/
43-1379 . A = B-C;
43-1380 .
43-1381 . if (A > B)
43-1382 . {
43-1383 . A = B + C;
43-1384 . D = E + F;
43-1385 . }
43-1386 .
43-1387 .
43-1388 . if (A > = B)
43-1389 . {
43-1390 . A = B + C;
43-1391 . D = E + F;
43-1392 . }
43-1393 .
43-1394 . A = B-C;
43-1395 .
43-1396 . /*
43-1397 . dead_block = C * D;
43-1398 . dead_block = E * F;
43-1399 . */
43-1400 .
43-1401 .
43-1402 . if (A ge B)
43-1403 . {
43-1404 . A = B + C;
43-1405 . D = E + F;
43-1406 . }
43-1407 .
43-1408 . /* LE SV TOC-2424 this is a pwr-01.11.14 req to compare*/
43-1409 .
43-1410 . if (A le B)
43-1411 . {
43-1412 . A = B + C;
43-1413 . D = E + F;
43-1414 . }
43-1415 .
43-1416 .
43-1417 . if (A gt B)
43-1418 . {
43-1419 . A = B + C;
43-1420 . D = E + F;
43-1421 . }
43-1422 .
43-1423 .
43-1424 . if (A ne B)
43-1425 . {
43-1426 . A = B + C;
43-1427 . D = E + F;
43-1428 . }
43-1429 .
43-1430 . A = B-C;
43-1431 .
43-1432 . if (A > = B)
43-1433 . {
43-1434 . A = B + C;
43-1435 . D = E + F;
43-1436 . }
43-1437 .
43-1438 .
43-1439 . if (A > = B)
43-1440 . {
43-1441 . A = B + C;
43-1442 . D = E + F;
43-1443 . }
43-1444 .
43-1445 . free(FreePtr);
43-1446 . A = B-C;
43-1447 .
43-1448 . if (A > = B)
43-1449 . {
43-1450 . A = B + C;
43-1451 . D = E + F;
43-1452 . }
43-1453 .
43-1454 . /* dead_code = A * B; */
43-1455 .
43-1456 . if (A != B)
43-1457 . {
43-1458 . A = B + C;
43-1459 . D = E + F;
43-1460 . }
43-1461 .
43-1462 .
43-1463 . if (A == B)
43-1464 . {
43-1465 . A = B + C;
43-1466 . D = E + F;
43-1467 . }
43-1468 .
43-1469 . A = B/C;
43-1470 . A = B*C;
43-1471 . A = B-C;
43-1472 .
43-1473 . if (A lt B)
43-1474 . {
43-1475 . A = B + C;
43-1476 . D = E + F;
43-1477 . }
43-1478 .
43-1479 . // max LOC 27
43-1480 .
43-1481 . }
43-1482 .
43-1483 .
43-1484 . /*
43-1485 . -----------------------------------------------------------------------------
43-1486 . --| NAME: pwr.1.12
43-1487 . --|
43-1488 . --| ABSTRACT:
43-1489 . --| This function does pwr stuff.
43-1490 . --|
43-1491 . --| RETURNS:
43-1492 . --| NONE.
43-1493 . --|
43-1494 . ----------------------------------------------------------------------------
43-1495 . */
43-1496 . static void pwr.1.12(void)
43-1497 . {
43-1498 . A = B-C;
43-1499 .
43-1500 . if (A lt B)
43-1501 . {
43-1502 . A = B + C;
43-1503 . D = E + F;
43-1504 . }
43-1505 .
43-1506 . A = B+C;
43-1507 .
43-1508 . if (A lt B)
43-1509 . {
43-1510 . A = B + C;
43-1511 . D = E + F;
43-1512 . }
43-1513 .
43-1514 .
43-1515 . if (A > B)
43-1516 . {
43-1517 . A = B + C;
43-1518 . D = E + F;
43-1519 . }
43-1520 .
43-1521 . A = B/C;
43-1522 . A = B+C;
43-1523 .
43-1524 . if (A ne B)
43-1525 . {
43-1526 . A = B + C;
43-1527 . D = E + F;
43-1528 . }
43-1529 .
43-1530 .
43-1531 . if (A == B)
43-1532 . {
43-1533 . A = B + C;
43-1534 . D = E + F;
43-1535 . }
43-1536 .
43-1537 . A = 0x0004;
43-1538 .
43-1539 . if (A < B)
43-1540 . {
43-1541 . A = B + C;
43-1542 . D = E + F;
43-1543 . }
43-1544 .
43-1545 . A = B*C;
43-1546 . A = B/C;
43-1547 .
43-1548 . if (A > = B)
43-1549 . {
43-1550 . A = B + C;
43-1551 . D = E + F;
43-1552 . }
43-1553 .
43-1554 . A = B+C;
43-1555 . A = B-C;
43-1556 .
43-1557 . if (A eq B)
43-1558 . {
43-1559 . A = B + C;
43-1560 . D = E + F;
43-1561 . }
43-1562 .
43-1563 .
43-1564 . if (A ge B)
43-1565 . {
43-1566 . A = B + C;
43-1567 . D = E + F;
43-1568 . }
43-1569 .
43-1570 . A = B+C;
43-1571 . A = B+C;
43-1572 . A = B/C;
43-1573 . A = B-C;
43-1574 . A = B-C;
43-1575 .
43-1576 . if (A > = B)
43-1577 . {
43-1578 . A = B + C;
43-1579 . D = E + F;
43-1580 . }
43-1581 .
43-1582 . A = B/C;
43-1583 . A = B+C;
43-1584 . A = B-C;
43-1585 . A = B+C;
43-1586 . A = B-C;
43-1587 . /* LE SV TOC-2425 this is a pwr-01.12.29 req to call admin*/
43-1588 . A = 0x0004;
43-1589 .
43-1590 . if (A lt B)
43-1591 . {
43-1592 . A = B + C;
43-1593 . D = E + F;
43-1594 . }
43-1595 .
43-1596 . A = B*C;
43-1597 .
43-1598 . if (A == B)
43-1599 . {
43-1600 . A = B + C;
43-1601 . D = E + F;
43-1602 . }
43-1603 .
43-1604 . /* LE SV TOC-2426 this is a pwr-01.12.32 req to set RTC*/
43-1605 .
43-1606 . if (A == B)
43-1607 . {
43-1608 . A = B + C;
43-1609 . D = E + F;
43-1610 . }
43-1611 .
43-1612 .
43-1613 . if (A == B)
43-1614 . {
43-1615 . A = B + C;
43-1616 . D = E + F;
43-1617 . }
43-1618 .
43-1619 . A = B*C;
43-1620 . A = B-C;
43-1621 . A = B-C;
43-1622 . A = B/C;
43-1623 .
43-1624 . if (A le B)
43-1625 . {
43-1626 . A = B + C;
43-1627 . D = E + F;
43-1628 . }
43-1629 .
43-1630 . A = B*C;
43-1631 .
43-1632 . if (A gt B)
43-1633 . {
43-1634 . A = B + C;
43-1635 . D = E + F;
43-1636 . }
43-1637 .
43-1638 .
43-1639 . if (A ge B)
43-1640 . {
43-1641 . A = B + C;
43-1642 . D = E + F;
43-1643 . }
43-1644 .
43-1645 . A = B*C;
43-1646 . A = B/C;
43-1647 . A = B-C;
43-1648 .
43-1649 . if (A eq B)
43-1650 . {
43-1651 . A = B + C;
43-1652 . D = E + F;
43-1653 . }
43-1654 .
43-1655 . /* LE SV TOC-2427 this is a pwr-01.12.46 req to convert*/
43-1656 . A = B/C;
43-1657 . A = B/C;
43-1658 . A = B/C;
43-1659 .
43-1660 . if (A ge B)
43-1661 . {
43-1662 . A = B + C;
43-1663 . D = E + F;
43-1664 . }
43-1665 .
43-1666 . A = B*C;
43-1667 . A = B/C;
43-1668 . A = B/C;
43-1669 . // max LOC 52
43-1670 .
43-1671 . }
43-1672 .
43-1673 .
43-1674 . /*
43-1675 . -----------------------------------------------------------------------------
43-1676 . --| NAME: pwr.1.13
43-1677 . --|
43-1678 . --| ABSTRACT:
43-1679 . --| This function does pwr stuff.
43-1680 . --|
43-1681 . --| RETURNS:
43-1682 . --| NONE.
43-1683 . --|
43-1684 . ----------------------------------------------------------------------------
43-1685 . */
43-1686 . static void pwr.1.13(void)
43-1687 . {
43-1688 .
43-1689 . if (A gt B)
43-1690 . {
43-1691 . A = B + C;
43-1692 . D = E + F;
43-1693 . }
43-1694 .
43-1695 .
43-1696 . switch (pwr stuff)
43-1697 . {
43-1698 . case one:
43-1699 . {
43-1700 . run_this;
43-1701 . // missing break
43-1702 . }
43-1703 . case two:
43-1704 . {
43-1705 . run_this;
43-1706 . break;
43-1707 . }
43-1708 . default:
43-1709 . {
43-1710 . SwError;
43-1711 . }
43-1712 . }
43-1713 .
43-1714 . A = B-C;
43-1715 . A = B+C;
43-1716 .
43-1717 . if (A le B)
43-1718 . {
43-1719 . A = B + C;
43-1720 . D = E + F;
43-1721 . }
43-1722 .
43-1723 .
43-1724 . if (A ne B)
43-1725 . {
43-1726 . A = B + C;
43-1727 . D = E + F;
43-1728 . }
43-1729 .
43-1730 .
43-1731 . if (A < B)
43-1732 . {
43-1733 . A = B + C;
43-1734 . D = E + F;
43-1735 . }
43-1736 .
43-1737 . A = B-C;
43-1738 . A = B+C;
43-1739 .
43-1740 . if (A < = B)
43-1741 . {
43-1742 . A = B + C;
43-1743 . D = E + F;
43-1744 . }
43-1745 .
43-1746 . /* LE SV TOC-2428 this is a pwr-01.13.10 req to detect error*/
43-1747 . A = B*C;
43-1748 . A = B-C;
43-1749 .
43-1750 . if (A < = B)
43-1751 . {
43-1752 . A = B + C;
43-1753 . D = E + F;
43-1754 . }
43-1755 .
43-1756 . A = B*C;
43-1757 . A = B/C;
43-1758 . // max LOC 14
43-1759 .
43-1760 . }
43-1761 .
43 43 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-01.c
44 44 Source: source/ft-app/ft-app-B1.1/pwr/pwr-02.c
44-0 . /*
44-1 . ----------------------------------------------------------------------------
44-2 . --| BEGIN PROLOGUE
44-3 . --|
44-4 . --| CLASSIFICATION: UNCLASSIFIED
44-5 . --|
44-6 . --| FILE NAME: pwr-02.c
44-7 . --|
44-8 . --| ABSTRACT:
44-9 . --| This file contains the 6 functions that do file pwr stuff.
44-10 . --|
44-11 . --| HISTORY:
44-12 . --| CCCQ_NAME:
44-13 . --| CCCQ_VER:
44-14 . --|
44-15 . --| END PROLOGUE
44-16 . ----------------------------------------------------------------------------
44-17 . */
44-18 .
44-19 . #define A;
44-20 .
44-21 .
44-22 .
44-23 . /*
44-24 . -----------------------------------------------------------------------------
44-25 . --| NAME: pwr.2.1
44-26 . --|
44-27 . --| ABSTRACT:
44-28 . --| This function does pwr stuff.
44-29 . --|
44-30 . --| RETURNS:
44-31 . --| NONE.
44-32 . --|
44-33 . ----------------------------------------------------------------------------
44-34 . */
44-35 . static void pwr.2.1(void)
44-36 . {
44-37 .
44-38 . if (A le B)
44-39 . {
44-40 . A = B + C;
44-41 . D = E + F;
44-42 . }
44-43 .
44-44 . A = B+C;
44-45 . A = B+C;
44-46 . A = B-C;
44-47 . A = B*C;
44-48 . A = B*C;
44-49 .
44-50 . if (A ge B)
44-51 . {
44-52 . A = B + C;
44-53 . D = E + F;
44-54 . }
44-55 .
44-56 . A = B/C;
44-57 . /* LE SV TOC-2429 this is a pwr-02.1.9 req to call admin*/
44-58 .
44-59 . if (A lt B)
44-60 . {
44-61 . A = B + C;
44-62 . D = E + F;
44-63 . }
44-64 .
44-65 . A = B-C;
44-66 . // max LOC 10
44-67 .
44-68 . }
44-69 .
44-70 .
44-71 . /*
44-72 . -----------------------------------------------------------------------------
44-73 . --| NAME: pwr.2.2
44-74 . --|
44-75 . --| ABSTRACT:
44-76 . --| This function does pwr stuff.
44-77 . --|
44-78 . --| RETURNS:
44-79 . --| NONE.
44-80 . --|
44-81 . ----------------------------------------------------------------------------
44-82 . */
44-83 . static void pwr.2.2(void)
44-84 . {
44-85 .
44-86 . if (A > = B)
44-87 . {
44-88 . A = B + C;
44-89 . D = E + F;
44-90 . }
44-91 .
44-92 . // ??? go see ws
44-93 .
44-94 . if (A le B)
44-95 . {
44-96 . A = B + C;
44-97 . D = E + F;
44-98 . }
44-99 .
44-100 .
44-101 . switch (pwr stuff)
44-102 . {
44-103 . case one:
44-104 . {
44-105 . run_this;
44-106 . break;
44-107 . }
44-108 . case two:
44-109 . {
44-110 . run_this;
44-111 . break;
44-112 . }
44-113 . default:
44-114 . {
44-115 . SwError;
44-116 . }
44-117 . }
44-118 .
44-119 . A = B/C;
44-120 . A = B/C;
44-121 .
44-122 . if (A != B)
44-123 . {
44-124 . A = B + C;
44-125 . D = E + F;
44-126 . }
44-127 .
44-128 .
44-129 . /* dead_block = C * D;
44-130 . dead_block = E * F; */
44-131 .
44-132 . A = B+C;
44-133 . A = B+C;
44-134 .
44-135 . if (A ge B)
44-136 . {
44-137 . A = B + C;
44-138 . D = E + F;
44-139 . }
44-140 .
44-141 . A = B*C;
44-142 . A = B-C;
44-143 .
44-144 . if (A > = B)
44-145 . {
44-146 . A = B + C;
44-147 . D = E + F;
44-148 . }
44-149 .
44-150 .
44-151 . if (A == B)
44-152 . {
44-153 . A = B + C;
44-154 . D = E + F;
44-155 . }
44-156 .
44-157 .
44-158 . /*
44-159 . dead_block = C * D;
44-160 . dead_block = E * F;
44-161 . */
44-162 .
44-163 . A = B-C;
44-164 . A = 0x0008;
44-165 . A = B/C;
44-166 .
44-167 . switch (pwr stuff)
44-168 . {
44-169 . case one:
44-170 . {
44-171 . run_this;
44-172 . break;
44-173 . }
44-174 . case two:
44-175 . {
44-176 . run_this;
44-177 . break;
44-178 . }
44-179 . default:
44-180 . {
44-181 . SwError;
44-182 . }
44-183 . }
44-184 .
44-185 . A = B/C;
44-186 . A = B*C;
44-187 .
44-188 . if (A != B)
44-189 . {
44-190 . A = B + C;
44-191 . D = E + F;
44-192 . }
44-193 .
44-194 . /* LE SV TOC-2430 this is a pwr-02.2.20 req to increment*/
44-195 .
44-196 . if (A > B)
44-197 . {
44-198 . A = B + C;
44-199 . D = E + F;
44-200 . }
44-201 .
44-202 . A = B-C;
44-203 . A = B/C;
44-204 . A = B/C;
44-205 . A = B/C;
44-206 . A = B*C;
44-207 . A = B-C;
44-208 . A = B*C;
44-209 .
44-210 . if (A < B)
44-211 . {
44-212 . A = B + C;
44-213 . D = E + F;
44-214 . }
44-215 .
44-216 . A = (long)B + C;
44-217 .
44-218 . if (A != B)
44-219 . {
44-220 . A = B + C;
44-221 . D = E + F;
44-222 . }
44-223 .
44-224 . A = B*C;
44-225 .
44-226 . if (A < B)
44-227 . {
44-228 . A = B + C;
44-229 . D = E + F;
44-230 . }
44-231 .
44-232 . A = B+C;
44-233 . A = B-C;
44-234 .
44-235 . if (A le B)
44-236 . {
44-237 . A = B + C;
44-238 . D = E + F;
44-239 . }
44-240 .
44-241 .
44-242 . if (A != B)
44-243 . {
44-244 . A = B + C;
44-245 . D = E + F;
44-246 . }
44-247 .
44-248 . A = B-C;
44-249 . /* LE SV TOC-2431 this is a pwr-02.2.37 req to fail*/
44-250 . A = B+C;
44-251 . // max LOC 37
44-252 .
44-253 . }
44-254 .
44-255 .
44-256 . /*
44-257 . -----------------------------------------------------------------------------
44-258 . --| NAME: pwr.2.3
44-259 . --|
44-260 . --| ABSTRACT:
44-261 . --| This function does pwr stuff.
44-262 . --|
44-263 . --| RETURNS:
44-264 . --| NONE.
44-265 . --|
44-266 . ----------------------------------------------------------------------------
44-267 . */
44-268 . static void pwr.2.3(void)
44-269 . {
44-270 .
44-271 . if (A < = B)
44-272 . {
44-273 . A = B + C;
44-274 . D = E + F;
44-275 . }
44-276 .
44-277 . A = B/C;
44-278 . A = 0x0001;
44-279 . A = B*C;
44-280 . FreePtr = HmiStringPtr;
44-281 .
44-282 . if (A < = B)
44-283 . {
44-284 . A = B + C;
44-285 . D = E + F;
44-286 . }
44-287 .
44-288 . A = B*C;
44-289 . A = B+C;
44-290 . A = B+C;
44-291 . A = B-C;
44-292 . A = B/C;
44-293 .
44-294 . if (A ge B)
44-295 . {
44-296 . A = B + C;
44-297 . D = E + F;
44-298 . }
44-299 .
44-300 . A = B/C;
44-301 . A = B+C;
44-302 . A = B+C;
44-303 . A = B/C;
44-304 . A = B/C;
44-305 .
44-306 . if (A ne B)
44-307 . {
44-308 . A = B + C;
44-309 . D = E + F;
44-310 . }
44-311 .
44-312 . A = B-C;
44-313 . goto error;
44-314 . A = B-C;
44-315 .
44-316 . if (A == B)
44-317 . {
44-318 . A = B + C;
44-319 . D = E + F;
44-320 . }
44-321 .
44-322 . A = B/C;
44-323 . A = B-C;
44-324 . A = B*C;
44-325 .
44-326 . if (A lt B)
44-327 . {
44-328 . A = B + C;
44-329 . D = E + F;
44-330 . }
44-331 .
44-332 . A = B*C;
44-333 .
44-334 . if (A != B)
44-335 . {
44-336 . A = B + C;
44-337 . D = E + F;
44-338 . }
44-339 .
44-340 .
44-341 . switch (pwr stuff)
44-342 . {
44-343 . case one:
44-344 . {
44-345 . switch (nested)
44-346 . {
44-347 . case:
44-348 . X = Y + Z;
44-349 . case:
44-350 . X = Y + Z;
44-351 . default:
44-352 . SwError;
44-353 . }
44-354 . }
44-355 . case two:
44-356 . {
44-357 . run_this;
44-358 . break;
44-359 . }
44-360 . default:
44-361 . {
44-362 . SwError;
44-363 . }
44-364 . }
44-365 .
44-366 . A = B/C;
44-367 .
44-368 . switch (pwr stuff)
44-369 . {
44-370 . case one:
44-371 . {
44-372 . run_this;
44-373 . break;
44-374 . }
44-375 . case two:
44-376 . {
44-377 . run_this;
44-378 . break;
44-379 . }
44-380 . default:
44-381 . {
44-382 . SwError;
44-383 . }
44-384 . }
44-385 .
44-386 . A = B-C;
44-387 . A = B+C;
44-388 .
44-389 . if (A lt B)
44-390 . {
44-391 . A = B + C;
44-392 . D = E + F;
44-393 . }
44-394 .
44-395 . A = B-C;
44-396 .
44-397 . switch (pwr stuff)
44-398 . {
44-399 . case one:
44-400 . {
44-401 . run_this;
44-402 . // missing break
44-403 . }
44-404 . case two:
44-405 . {
44-406 . run_this;
44-407 . break;
44-408 . }
44-409 . default:
44-410 . {
44-411 . SwError;
44-412 . }
44-413 . }
44-414 .
44-415 . A = B*C;
44-416 . A = B+C;
44-417 . A = B+C;
44-418 .
44-419 . if (A le B)
44-420 . {
44-421 . A = B + C;
44-422 . D = E + F;
44-423 . }
44-424 .
44-425 .
44-426 . if (A > B)
44-427 . {
44-428 . A = B + C;
44-429 . D = E + F;
44-430 . }
44-431 .
44-432 .
44-433 . if (A le B)
44-434 . {
44-435 . A = B + C;
44-436 . D = E + F;
44-437 . }
44-438 .
44-439 . A = B/C;
44-440 . A = B+C;
44-441 . A = B/C;
44-442 .
44-443 . if (A lt B)
44-444 . {
44-445 . A = B + C;
44-446 . D = E + F;
44-447 . }
44-448 .
44-449 . A = B+C;
44-450 .
44-451 . if (A < B)
44-452 . {
44-453 . A = B + C;
44-454 . D = E + F;
44-455 . }
44-456 .
44-457 . A = B/C;
44-458 .
44-459 . if (A le B)
44-460 . {
44-461 . A = B + C;
44-462 . D = E + F;
44-463 . }
44-464 .
44-465 . A = B+C;
44-466 . A = B*C;
44-467 .
44-468 . if (A le B)
44-469 . {
44-470 . A = B + C;
44-471 . D = E + F;
44-472 . }
44-473 .
44-474 . A = B/C;
44-475 . A = B-C;
44-476 . A = B-C;
44-477 . /* LE SV TOC-2432 this is a pwr-02.3.52 req to update*/
44-478 . A = B/C;
44-479 .
44-480 . if (A lt B)
44-481 . {
44-482 . A = B + C;
44-483 . D = E + F;
44-484 . }
44-485 .
44-486 . A = B-C;
44-487 .
44-488 . switch (pwr stuff)
44-489 . {
44-490 . case one:
44-491 . {
44-492 . run_this;
44-493 . break;
44-494 . }
44-495 . case two:
44-496 . {
44-497 . run_this;
44-498 . break;
44-499 . }
44-500 . default:
44-501 . {
44-502 . SwError;
44-503 . }
44-504 . }
44-505 .
44-506 . A = B-C;
44-507 . A = B-C;
44-508 .
44-509 . if (A < = B)
44-510 . {
44-511 . A = B + C;
44-512 . D = E + F;
44-513 . }
44-514 .
44-515 .
44-516 . if (A gt B)
44-517 . {
44-518 . A = B + C;
44-519 . D = E + F;
44-520 . }
44-521 .
44-522 . A = B-C;
44-523 . A = 0x0001;
44-524 . A = B/C;
44-525 . A = B*C;
44-526 .
44-527 . if (A < = B)
44-528 . {
44-529 . A = B + C;
44-530 . D = E + F;
44-531 . }
44-532 .
44-533 . A = B-C;
44-534 .
44-535 . if (A < B)
44-536 . {
44-537 . A = B + C;
44-538 . D = E + F;
44-539 . }
44-540 .
44-541 . A = B/C;
44-542 . A = B-C;
44-543 . A = B+C;
44-544 .
44-545 . if (A < = B)
44-546 . {
44-547 . A = B + C;
44-548 . D = E + F;
44-549 . }
44-550 .
44-551 . A = B/C;
44-552 . // max LOC 70
44-553 .
44-554 . }
44-555 .
44-556 .
44-557 . /*
44-558 . -----------------------------------------------------------------------------
44-559 . --| NAME: pwr.2.4
44-560 . --|
44-561 . --| ABSTRACT:
44-562 . --| This function does pwr stuff.
44-563 . --|
44-564 . --| RETURNS:
44-565 . --| NONE.
44-566 . --|
44-567 . ----------------------------------------------------------------------------
44-568 . */
44-569 . static void pwr.2.4(void)
44-570 . {
44-571 . A = B*C;
44-572 . A = B-C;
44-573 . A = B+C;
44-574 . A = B+C;
44-575 . A = B*C;
44-576 . A = B/C;
44-577 . A = B*C;
44-578 .
44-579 . if (A > = B)
44-580 . {
44-581 . A = B + C;
44-582 . D = E + F;
44-583 . }
44-584 .
44-585 . A = B+C;
44-586 . A = B+C;
44-587 . A = B*C;
44-588 . // max LOC 11
44-589 .
44-590 . }
44-591 .
44-592 .
44-593 . /*
44-594 . -----------------------------------------------------------------------------
44-595 . --| NAME: pwr.2.5
44-596 . --|
44-597 . --| ABSTRACT:
44-598 . --| This function does pwr stuff.
44-599 . --|
44-600 . --| RETURNS:
44-601 . --| NONE.
44-602 . --|
44-603 . ----------------------------------------------------------------------------
44-604 . */
44-605 . static void pwr.2.5(void)
44-606 . {
44-607 . A = B-C;
44-608 . send_buffer = (U16 *) malloc(size+1);
44-609 . A = B-C;
44-610 . A = B*C;
44-611 . A = B-C;
44-612 .
44-613 . if (A != B)
44-614 . {
44-615 . A = B + C;
44-616 . D = E + F;
44-617 . }
44-618 .
44-619 . A = B+C;
44-620 . A = B/C;
44-621 .
44-622 . if (A < B)
44-623 . {
44-624 . A = B + C;
44-625 . D = E + F;
44-626 . }
44-627 .
44-628 . A = B-C;
44-629 . A = B*C;
44-630 .
44-631 . /* dead_block = C * D;
44-632 . dead_block = E * F; */
44-633 .
44-634 . A = B+C;
44-635 . A = B+C;
44-636 . A = B/C;
44-637 . A = B-C;
44-638 . A = B+C;
44-639 . A = B+C;
44-640 . A = B-C;
44-641 . A = B+C;
44-642 .
44-643 . switch (pwr stuff)
44-644 . {
44-645 . case:
44-646 . case:
44-647 . // stacked case statements but only if there is a new line in between
44-648 .
44-649 . case:
44-650 . case:
44-651 . case:
44-652 . {
44-653 . run_this;
44-654 . break;
44-655 . }
44-656 . default:
44-657 . {
44-658 . halt;
44-659 . }
44-660 . }
44-661 .
44-662 .
44-663 . if (A lt B)
44-664 . {
44-665 . A = B + C;
44-666 . D = E + F;
44-667 . }
44-668 .
44-669 . A = B/C;
44-670 . A = B/C;
44-671 .
44-672 . if (A gt B)
44-673 . {
44-674 . A = B + C;
44-675 . D = E + F;
44-676 . }
44-677 .
44-678 .
44-679 . /* dead_block = C * D;
44-680 . dead_block = E * F; */
44-681 .
44-682 . A = B-C;
44-683 . A = B*C;
44-684 .
44-685 . if (A ge B)
44-686 . {
44-687 . A = B + C;
44-688 . D = E + F;
44-689 . }
44-690 .
44-691 .
44-692 . if (A != B)
44-693 . {
44-694 . A = B + C;
44-695 . D = E + F;
44-696 . }
44-697 .
44-698 .
44-699 . if (A ne B)
44-700 . {
44-701 . A = B + C;
44-702 . D = E + F;
44-703 . }
44-704 .
44-705 . A = B-C;
44-706 . A = B-C;
44-707 .
44-708 . if (A ne B)
44-709 . {
44-710 . A = B + C;
44-711 . D = E + F;
44-712 . }
44-713 .
44-714 . A = B+C;
44-715 . A = B*C;
44-716 . A = B/C;
44-717 . /* LE SV TOC-2433 this is a pwr-02.5.34 req to call admin*/
44-718 .
44-719 . if (A ge B)
44-720 . {
44-721 . A = B + C;
44-722 . D = E + F;
44-723 . }
44-724 .
44-725 .
44-726 . if (A le B)
44-727 . {
44-728 . A = B + C;
44-729 . D = E + F;
44-730 . }
44-731 .
44-732 . A = B/C;
44-733 . A = B+C;
44-734 .
44-735 . if (A != B)
44-736 . {
44-737 . A = B + C;
44-738 . D = E + F;
44-739 . }
44-740 .
44-741 . A = B*C;
44-742 . A = B*C;
44-743 . A = B*C;
44-744 . A = B*C;
44-745 . A = B+C;
44-746 .
44-747 . if (A < = B)
44-748 . {
44-749 . A = B + C;
44-750 . D = E + F;
44-751 . }
44-752 .
44-753 .
44-754 . switch (pwr stuff)
44-755 . {
44-756 . case one:
44-757 . {
44-758 . run_this;
44-759 . break;
44-760 . }
44-761 . case two:
44-762 . {
44-763 . run_this;
44-764 . break;
44-765 . }
44-766 . default:
44-767 . {
44-768 . SwError;
44-769 . }
44-770 . }
44-771 .
44-772 . A = B+C;
44-773 . A = B*C;
44-774 . A = B+C;
44-775 . A = B-C;
44-776 . A = B*C;
44-777 .
44-778 . if (A eq B)
44-779 . {
44-780 . A = B + C;
44-781 . D = E + F;
44-782 . }
44-783 .
44-784 .
44-785 . if (A > B)
44-786 . {
44-787 . A = B + C;
44-788 . D = E + F;
44-789 . }
44-790 .
44-791 .
44-792 . if (A gt B)
44-793 . {
44-794 . A = B + C;
44-795 . D = E + F;
44-796 . }
44-797 .
44-798 . // max LOC 53
44-799 .
44-800 . }
44-801 .
44-802 .
44-803 . /*
44-804 . -----------------------------------------------------------------------------
44-805 . --| NAME: pwr.2.6
44-806 . --|
44-807 . --| ABSTRACT:
44-808 . --| This function does pwr stuff.
44-809 . --|
44-810 . --| RETURNS:
44-811 . --| NONE.
44-812 . --|
44-813 . ----------------------------------------------------------------------------
44-814 . */
44-815 . static void pwr.2.6(void)
44-816 . {
44-817 . A = B/C;
44-818 .
44-819 . if (A > = B)
44-820 . {
44-821 . A = B + C;
44-822 . D = E + F;
44-823 . }
44-824 .
44-825 . A = B-C;
44-826 . A = B*C;
44-827 . A = B-C;
44-828 . A = B-C;
44-829 .
44-830 . if (A le B)
44-831 . {
44-832 . A = B + C;
44-833 . D = E + F;
44-834 . }
44-835 .
44-836 . A = B-C;
44-837 . A = B*C;
44-838 . A = B*C;
44-839 . A = B/C;
44-840 . A = B+C;
44-841 . A = 0x0002;
44-842 .
44-843 . if (veg)
44-844 . // missing curly brace
44-845 . variable = orange;
44-846 .
44-847 . A = B/C;
44-848 . A = B-C;
44-849 .
44-850 . if (A < B)
44-851 . {
44-852 . A = B + C;
44-853 . D = E + F;
44-854 . }
44-855 .
44-856 . A = B*C;
44-857 . A = B+C;
44-858 . A = B+C;
44-859 .
44-860 . if (A < = B)
44-861 . {
44-862 . A = B + C;
44-863 . D = E + F;
44-864 . }
44-865 .
44-866 . A = B+C;
44-867 . A = B*C;
44-868 .
44-869 . if (A > B)
44-870 . {
44-871 . A = B + C;
44-872 . D = E + F;
44-873 . }
44-874 .
44-875 . A = B-C;
44-876 .
44-877 . if (A > = B)
44-878 . {
44-879 . A = B + C;
44-880 . D = E + F;
44-881 . }
44-882 .
44-883 .
44-884 . if (A lt B)
44-885 . {
44-886 . A = B + C;
44-887 . D = E + F;
44-888 . }
44-889 .
44-890 . A = B*C;
44-891 .
44-892 . if (A ge B)
44-893 . {
44-894 . A = B + C;
44-895 . D = E + F;
44-896 . }
44-897 .
44-898 . A = B*C;
44-899 .
44-900 . if (A < B)
44-901 . {
44-902 . A = B + C;
44-903 . D = E + F;
44-904 . }
44-905 .
44-906 . /* LE SV TOC-2434 this is a pwr-02.6.30 req to check unix*/
44-907 .
44-908 . if (A le B)
44-909 . {
44-910 . A = B + C;
44-911 . D = E + F;
44-912 . }
44-913 .
44-914 . A = B*C;
44-915 . A = B*C;
44-916 . A = B+C;
44-917 . A = B*C;
44-918 . A = B+C;
44-919 .
44-920 . if (A lt B)
44-921 . {
44-922 . A = B + C;
44-923 . D = E + F;
44-924 . }
44-925 .
44-926 . A = 0x0001;
44-927 . A = B*C;
44-928 . A = B+C;
44-929 .
44-930 . if (A le B)
44-931 . {
44-932 . A = B + C;
44-933 . D = E + F;
44-934 . }
44-935 .
44-936 . /* LE SV TOC-2435 this is a pwr-02.6.40 req to compare*/
44-937 .
44-938 . if {
44-939 . X = Y + Z;
44-940 . }
44-941 . else {
44-942 . halt;
44-943 . }
44-944 .
44-945 .
44-946 . if (A ge B)
44-947 . {
44-948 . A = B + C;
44-949 . D = E + F;
44-950 . }
44-951 .
44-952 .
44-953 . /*
44-954 . dead_block = C * D;
44-955 . dead_block = E * F;
44-956 . */
44-957 .
44-958 . A = B+C;
44-959 .
44-960 . if (A ge B)
44-961 . {
44-962 . A = B + C;
44-963 . D = E + F;
44-964 . }
44-965 .
44-966 . A = B+C;
44-967 . /* LE SV TOC-2436 this is a pwr-02.6.44 req to call admin*/
44-968 . A = B*C;
44-969 .
44-970 . if (A != B)
44-971 . {
44-972 . A = B + C;
44-973 . D = E + F;
44-974 . }
44-975 .
44-976 . /* LE SV TOC-2437 this is a pwr-02.6.46 req to detect error*/
44-977 .
44-978 . if (A > B)
44-979 . {
44-980 . A = B + C;
44-981 . D = E + F;
44-982 . }
44-983 .
44-984 . A = B+C;
44-985 . /* LE SV TOC-2438 this is a pwr-02.6.48 req to verify*/
44-986 . A = B*C;
44-987 .
44-988 . if (A == B)
44-989 . {
44-990 . A = B + C;
44-991 . D = E + F;
44-992 . }
44-993 .
44-994 . A = B-C;
44-995 .
44-996 . if (A ge B)
44-997 . {
44-998 . A = B + C;
44-999 . D = E + F;
44-1000 . }
44-1001 .
44-1002 . A = B*C;
44-1003 .
44-1004 . if (A ge B)
44-1005 . {
44-1006 . A = B + C;
44-1007 . D = E + F;
44-1008 . }
44-1009 .
44-1010 . A = B*C;
44-1011 .
44-1012 . if (A le B)
44-1013 . {
44-1014 . A = B + C;
44-1015 . D = E + F;
44-1016 . }
44-1017 .
44-1018 .
44-1019 . if (A == B)
44-1020 . {
44-1021 . A = B + C;
44-1022 . D = E + F;
44-1023 . }
44-1024 .
44-1025 .
44-1026 . if (A ne B)
44-1027 . {
44-1028 . A = B + C;
44-1029 . D = E + F;
44-1030 . }
44-1031 .
44-1032 .
44-1033 . if (A < B)
44-1034 . {
44-1035 . A = B + C;
44-1036 . D = E + F;
44-1037 . }
44-1038 .
44-1039 .
44-1040 . if (A le B)
44-1041 . {
44-1042 . A = B + C;
44-1043 . D = E + F;
44-1044 . }
44-1045 .
44-1046 .
44-1047 . if (A gt B)
44-1048 . {
44-1049 . A = B + C;
44-1050 . D = E + F;
44-1051 . }
44-1052 .
44-1053 .
44-1054 . if (A > = B)
44-1055 . {
44-1056 . A = B + C;
44-1057 . D = E + F;
44-1058 . }
44-1059 .
44-1060 . A = B-C;
44-1061 . A = B-C;
44-1062 . // (P) this is really improtant
44-1063 .
44-1064 . if (A > = B)
44-1065 . {
44-1066 . A = B + C;
44-1067 . D = E + F;
44-1068 . }
44-1069 .
44-1070 .
44-1071 . if (A < = B)
44-1072 . {
44-1073 . A = B + C;
44-1074 . D = E + F;
44-1075 . }
44-1076 .
44-1077 .
44-1078 . if (A gt B)
44-1079 . {
44-1080 . A = B + C;
44-1081 . D = E + F;
44-1082 . }
44-1083 .
44-1084 . A = B*C;
44-1085 . A = B+C;
44-1086 .
44-1087 . if (A gt B)
44-1088 . {
44-1089 . A = B + C;
44-1090 . D = E + F;
44-1091 . }
44-1092 .
44-1093 . A = B/C;
44-1094 . A = B/C;
44-1095 . /* LE SV TOC-2439 this is a pwr-02.6.72 req to update*/
44-1096 .
44-1097 . if (A < = B)
44-1098 . {
44-1099 . A = B + C;
44-1100 . D = E + F;
44-1101 . }
44-1102 .
44-1103 .
44-1104 . if (A < B)
44-1105 . {
44-1106 . A = B + C;
44-1107 . D = E + F;
44-1108 . }
44-1109 .
44-1110 . A = B*C;
44-1111 .
44-1112 . if (A > B)
44-1113 . {
44-1114 . A = B + C;
44-1115 . D = E + F;
44-1116 . }
44-1117 .
44-1118 . A = B-C;
44-1119 . /* LE SV TOC-2440 this is a pwr-02.6.77 req to set RTC*/
44-1120 .
44-1121 . if (A == B)
44-1122 . {
44-1123 . A = B + C;
44-1124 . D = E + F;
44-1125 . }
44-1126 .
44-1127 . // max LOC 77
44-1128 .
44-1129 . }
44-1130 .
44 44 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-02.c
45 45 Source: source/ft-app/ft-app-B1.1/pwr/pwr-03.c
45-0 . /*
45-1 . ----------------------------------------------------------------------------
45-2 . --| BEGIN PROLOGUE
45-3 . --|
45-4 . --| CLASSIFICATION: UNCLASSIFIED
45-5 . --|
45-6 . --| FILE NAME: pwr-03.c
45-7 . --|
45-8 . --| ABSTRACT:
45-9 . --| This file contains the 8 functions that do file pwr stuff.
45-10 . --|
45-11 . --| HISTORY:
45-12 . --| CCCQ_NAME:
45-13 . --| CCCQ_VER:
45-14 . --|
45-15 . --| END PROLOGUE
45-16 . ----------------------------------------------------------------------------
45-17 . */
45-18 .
45-19 . #include D;
45-20 . double C;
45-21 . #define B;
45-22 .
45-23 .
45-24 .
45-25 . /*
45-26 . -----------------------------------------------------------------------------
45-27 . --| NAME: pwr.3.1
45-28 . --|
45-29 . --| ABSTRACT:
45-30 . --| This function does pwr stuff.
45-31 . --|
45-32 . --| RETURNS:
45-33 . --| NONE.
45-34 . --|
45-35 . ----------------------------------------------------------------------------
45-36 . */
45-37 . static void pwr.3.1(void)
45-38 . {
45-39 . /* LE SV TOC-2441 this is a pwr-03.1.1 req to fail*/
45-40 .
45-41 . if (A != B)
45-42 . {
45-43 . A = B + C;
45-44 . D = E + F;
45-45 . }
45-46 .
45-47 . A = B-C;
45-48 .
45-49 . if (A < B)
45-50 . {
45-51 . A = B + C;
45-52 . D = E + F;
45-53 . }
45-54 .
45-55 . A = B+C;
45-56 . A = B/C;
45-57 . A = B-C;
45-58 . A = B+C;
45-59 . // max LOC 7
45-60 .
45-61 . }
45-62 .
45-63 .
45-64 . /*
45-65 . -----------------------------------------------------------------------------
45-66 . --| NAME: pwr.3.2
45-67 . --|
45-68 . --| ABSTRACT:
45-69 . --| This function does pwr stuff.
45-70 . --|
45-71 . --| RETURNS:
45-72 . --| NONE.
45-73 . --|
45-74 . ----------------------------------------------------------------------------
45-75 . */
45-76 . static void pwr.3.2(void)
45-77 . {
45-78 . A = B/C;
45-79 .
45-80 . if (A ne B)
45-81 . {
45-82 . A = B + C;
45-83 . D = E + F;
45-84 . }
45-85 .
45-86 . A = B-C;
45-87 . A = B-C;
45-88 . A = B+C;
45-89 . A = B/C;
45-90 . A = B+C;
45-91 . A = B+C;
45-92 .
45-93 . if (A gt B)
45-94 . {
45-95 . A = B + C;
45-96 . D = E + F;
45-97 . }
45-98 .
45-99 . A = B*C;
45-100 . A = B-C;
45-101 .
45-102 . if (A ne B)
45-103 . {
45-104 . A = B + C;
45-105 . D = E + F;
45-106 . }
45-107 .
45-108 .
45-109 . if (A > B)
45-110 . {
45-111 . A = B + C;
45-112 . D = E + F;
45-113 . }
45-114 .
45-115 .
45-116 . if (A ge B)
45-117 . {
45-118 . A = B + C;
45-119 . D = E + F;
45-120 . }
45-121 .
45-122 . A = B-C;
45-123 .
45-124 . if (A ne B)
45-125 . {
45-126 . A = B + C;
45-127 . D = E + F;
45-128 . }
45-129 .
45-130 . A = B-C;
45-131 . A = B-C;
45-132 . A = B/C;
45-133 .
45-134 . /* dead_code = B + C;
45-135 . dead_code = D + E;
45-136 . dead_code = F + G; */
45-137 .
45-138 . A = B+C;
45-139 . A = B-C;
45-140 .
45-141 . if (A != B)
45-142 . {
45-143 . A = B + C;
45-144 . D = E + F;
45-145 . }
45-146 .
45-147 . A = B*C;
45-148 . A = B+C;
45-149 .
45-150 . if (A eq B)
45-151 . {
45-152 . A = B + C;
45-153 . D = E + F;
45-154 . }
45-155 .
45-156 . A = B-C;
45-157 . A = B*C;
45-158 . A = B+C;
45-159 . /* LE SV TOC-2442 this is a pwr-03.2.29 req to validate*/
45-160 .
45-161 . if (A ne B)
45-162 . {
45-163 . A = B + C;
45-164 . D = E + F;
45-165 . }
45-166 .
45-167 . A = B*C;
45-168 . A = B/C;
45-169 . /* LE SV TOC-2443 this is a pwr-03.2.32 req to call admin*/
45-170 . A = 0x0003;
45-171 . A = B-C;
45-172 . A = B-C;
45-173 . A = B*C;
45-174 . A = B/C;
45-175 .
45-176 . if (A < = B)
45-177 . {
45-178 . A = B + C;
45-179 . D = E + F;
45-180 . }
45-181 .
45-182 .
45-183 . if (A le B)
45-184 . {
45-185 . A = B + C;
45-186 . D = E + F;
45-187 . }
45-188 .
45-189 .
45-190 . switch (pwr stuff)
45-191 . {
45-192 . case one:
45-193 . {
45-194 . run_this;
45-195 . break;
45-196 . }
45-197 . case two:
45-198 . {
45-199 . run_this;
45-200 . break;
45-201 . }
45-202 . default:
45-203 . {
45-204 . SwError;
45-205 . }
45-206 . }
45-207 .
45-208 . A = B+C;
45-209 . A = B/C;
45-210 .
45-211 . if (A ne B)
45-212 . {
45-213 . A = B + C;
45-214 . D = E + F;
45-215 . }
45-216 .
45-217 .
45-218 . if (A == B)
45-219 . {
45-220 . A = B + C;
45-221 . D = E + F;
45-222 . }
45-223 .
45-224 . A = B+C;
45-225 . A = B+C;
45-226 . A = B+C;
45-227 . A = B/C;
45-228 . A = B*C;
45-229 .
45-230 . if (A eq B)
45-231 . {
45-232 . A = B + C;
45-233 . D = E + F;
45-234 . }
45-235 .
45-236 . A = B/C;
45-237 .
45-238 . /*
45-239 . dead_block = C * D;
45-240 . dead_block = E * F;
45-241 . */
45-242 .
45-243 . A = B/C;
45-244 . A = B/C;
45-245 . A = B-C;
45-246 . A = B/C;
45-247 . A = B+C;
45-248 . A = B-C;
45-249 . A = B/C;
45-250 . A = B/C;
45-251 .
45-252 . if (A gt B)
45-253 . {
45-254 . A = B + C;
45-255 . D = E + F;
45-256 . }
45-257 .
45-258 . A = B*C;
45-259 . // max LOC 59
45-260 .
45-261 . }
45-262 .
45-263 .
45-264 . /*
45-265 . -----------------------------------------------------------------------------
45-266 . --| NAME: pwr.3.3
45-267 . --|
45-268 . --| ABSTRACT:
45-269 . --| This function does pwr stuff.
45-270 . --|
45-271 . --| RETURNS:
45-272 . --| NONE.
45-273 . --|
45-274 . ----------------------------------------------------------------------------
45-275 . */
45-276 . static void pwr.3.3(void)
45-277 . {
45-278 .
45-279 . /*
45-280 . dead_code = B - C;
45-281 . dead_code = D - E;
45-282 . dead_code = F - G;
45-283 . */
45-284 .
45-285 . A = B*C;
45-286 .
45-287 . if (A ne B)
45-288 . {
45-289 . A = B + C;
45-290 . D = E + F;
45-291 . }
45-292 .
45-293 . A = B+C;
45-294 .
45-295 . if (A < B)
45-296 . {
45-297 . A = B + C;
45-298 . D = E + F;
45-299 . }
45-300 .
45-301 . /* LE SV TOC-2444 this is a pwr-03.3.5 req to check unix*/
45-302 . A = B-C;
45-303 . A = B*C;
45-304 .
45-305 . switch (pwr stuff)
45-306 . {
45-307 . case one:
45-308 . {
45-309 . run_this;
45-310 . break;
45-311 . }
45-312 . case two:
45-313 . {
45-314 . run_this;
45-315 . break;
45-316 . }
45-317 . default:
45-318 . {
45-319 . SwError;
45-320 . }
45-321 . }
45-322 .
45-323 . A = B+C;
45-324 . A = B/C;
45-325 . // max LOC 9
45-326 .
45-327 . }
45-328 .
45-329 .
45-330 . /*
45-331 . -----------------------------------------------------------------------------
45-332 . --| NAME: pwr.3.4
45-333 . --|
45-334 . --| ABSTRACT:
45-335 . --| This function does pwr stuff.
45-336 . --|
45-337 . --| RETURNS:
45-338 . --| NONE.
45-339 . --|
45-340 . ----------------------------------------------------------------------------
45-341 . */
45-342 . static void pwr.3.4(void)
45-343 . {
45-344 . A = B*C;
45-345 . A = B+C;
45-346 . A = B-C;
45-347 .
45-348 . if (A < B)
45-349 . {
45-350 . A = B + C;
45-351 . D = E + F;
45-352 . }
45-353 .
45-354 .
45-355 . if (A le B)
45-356 . {
45-357 . A = B + C;
45-358 . D = E + F;
45-359 . }
45-360 .
45-361 .
45-362 . if (A != B)
45-363 . {
45-364 . A = B + C;
45-365 . D = E + F;
45-366 . }
45-367 .
45-368 .
45-369 . if (A > = B)
45-370 . {
45-371 . A = B + C;
45-372 . D = E + F;
45-373 . }
45-374 .
45-375 . A = B*C;
45-376 . A = B/C;
45-377 .
45-378 . if (A < B)
45-379 . {
45-380 . A = B + C;
45-381 . D = E + F;
45-382 . }
45-383 .
45-384 .
45-385 . switch (pwr stuff)
45-386 . {
45-387 . case one:
45-388 . {
45-389 . switch (nested)
45-390 . {
45-391 . case:
45-392 . X = Y + Z;
45-393 . case:
45-394 . X = Y + Z;
45-395 . default:
45-396 . SwError;
45-397 . }
45-398 . }
45-399 . case two:
45-400 . {
45-401 . run_this;
45-402 . break;
45-403 . }
45-404 . default:
45-405 . {
45-406 . SwError;
45-407 . }
45-408 . }
45-409 .
45-410 .
45-411 . if (A le B)
45-412 . {
45-413 . A = B + C;
45-414 . D = E + F;
45-415 . }
45-416 .
45-417 .
45-418 . switch (pwr stuff)
45-419 . {
45-420 . case one:
45-421 . {
45-422 . run_this;
45-423 . break;
45-424 . }
45-425 . case two:
45-426 . {
45-427 . run_this;
45-428 . break;
45-429 . }
45-430 . default:
45-431 . {
45-432 . SwError;
45-433 . }
45-434 . }
45-435 .
45-436 . A = B-C;
45-437 . A = B+C;
45-438 . /* LE SV TOC-2445 this is a pwr-03.4.15 req to fail*/
45-439 .
45-440 . if (A eq B)
45-441 . {
45-442 . A = B + C;
45-443 . D = E + F;
45-444 . }
45-445 .
45-446 . A = B+C;
45-447 .
45-448 . switch (pwr stuff)
45-449 . {
45-450 . case one:
45-451 . {
45-452 . run_this;
45-453 . break;
45-454 . }
45-455 . case two:
45-456 . {
45-457 . run_this;
45-458 . break;
45-459 . }
45-460 . default:
45-461 . {
45-462 . SwError;
45-463 . }
45-464 . }
45-465 .
45-466 . A = B+C;
45-467 . A = B/C;
45-468 .
45-469 . if (A > = B)
45-470 . {
45-471 . A = B + C;
45-472 . D = E + F;
45-473 . }
45-474 .
45-475 . A = B-C;
45-476 . A = B/C;
45-477 .
45-478 . if (A lt B)
45-479 . {
45-480 . A = B + C;
45-481 . D = E + F;
45-482 . }
45-483 .
45-484 .
45-485 . if (A gt B)
45-486 . {
45-487 . A = B + C;
45-488 . D = E + F;
45-489 . }
45-490 .
45-491 . A = B*C;
45-492 .
45-493 . if (A > = B)
45-494 . {
45-495 . A = B + C;
45-496 . D = E + F;
45-497 . }
45-498 .
45-499 . A = B-C;
45-500 . A = B/C;
45-501 . A = 0x0003;
45-502 . A = B+C;
45-503 . /* LE SV TOC-2446 this is a pwr-03.4.30 req to disable*/
45-504 . A = B+C;
45-505 . // max LOC 30
45-506 .
45-507 . }
45-508 .
45-509 .
45-510 . /*
45-511 . -----------------------------------------------------------------------------
45-512 . --| NAME: pwr.3.5
45-513 . --|
45-514 . --| ABSTRACT:
45-515 . --| This function does pwr stuff.
45-516 . --|
45-517 . --| RETURNS:
45-518 . --| NONE.
45-519 . --|
45-520 . ----------------------------------------------------------------------------
45-521 . */
45-522 . static void pwr.3.5(void)
45-523 . {
45-524 . A = B+C;
45-525 .
45-526 . if (A < B)
45-527 . {
45-528 . A = B + C;
45-529 . D = E + F;
45-530 . }
45-531 .
45-532 . /* LE SV TOC-2447 this is a pwr-03.5.3 req to compare*/
45-533 .
45-534 . if (A < = B)
45-535 . {
45-536 . A = B + C;
45-537 . D = E + F;
45-538 . }
45-539 .
45-540 . A = B+C;
45-541 .
45-542 . if (A == B)
45-543 . {
45-544 . A = B + C;
45-545 . D = E + F;
45-546 . }
45-547 .
45-548 . A = B+C;
45-549 .
45-550 . if (A ge B)
45-551 . {
45-552 . A = B + C;
45-553 . D = E + F;
45-554 . }
45-555 .
45-556 . A = B/C;
45-557 . A = B/C;
45-558 . A = B-C;
45-559 . A = B*C;
45-560 . A = B+C;
45-561 . A = B*C;
45-562 .
45-563 . if (A le B)
45-564 . {
45-565 . A = B + C;
45-566 . D = E + F;
45-567 . }
45-568 .
45-569 . A = B*C;
45-570 . A = B+C;
45-571 .
45-572 . if (A > B)
45-573 . {
45-574 . A = B + C;
45-575 . D = E + F;
45-576 . }
45-577 .
45-578 . A = B/C;
45-579 . A = B+C;
45-580 .
45-581 . if (A < = B)
45-582 . {
45-583 . A = B + C;
45-584 . D = E + F;
45-585 . }
45-586 .
45-587 . A = B-C;
45-588 . A = B-C;
45-589 . A = B+C;
45-590 . A = B-C;
45-591 .
45-592 . if (A gt B)
45-593 . {
45-594 . A = B + C;
45-595 . D = E + F;
45-596 . }
45-597 .
45-598 .
45-599 . if (A ne B)
45-600 . {
45-601 . A = B + C;
45-602 . D = E + F;
45-603 . }
45-604 .
45-605 . A = B+C;
45-606 . A = B+C;
45-607 . A = B/C;
45-608 . /* LE SV TOC-2448 this is a pwr-03.5.30 req to check pSOS*/
45-609 .
45-610 . /*
45-611 . dead_code = B - C;
45-612 . dead_code = D - E;
45-613 . dead_code = F - G;
45-614 . */
45-615 .
45-616 . A = B/C;
45-617 . A = B/C;
45-618 . A = B-C;
45-619 . A = B/C;
45-620 . A = B-C;
45-621 . A = B*C;
45-622 . A = B-C;
45-623 .
45-624 . if (A eq B)
45-625 . {
45-626 . A = B + C;
45-627 . D = E + F;
45-628 . }
45-629 .
45-630 . A = B*C;
45-631 . // max LOC 38
45-632 .
45-633 . }
45-634 .
45-635 .
45-636 . /*
45-637 . -----------------------------------------------------------------------------
45-638 . --| NAME: pwr.3.6
45-639 . --|
45-640 . --| ABSTRACT:
45-641 . --| This function does pwr stuff.
45-642 . --|
45-643 . --| RETURNS:
45-644 . --| NONE.
45-645 . --|
45-646 . ----------------------------------------------------------------------------
45-647 . */
45-648 . static void pwr.3.6(void)
45-649 . {
45-650 . A = B-C;
45-651 . A = 0x0002;
45-652 . rcv_buffer = (U16 *) alloc(size+1);
45-653 . A = B*C;
45-654 . A = B*C;
45-655 . A = B-C;
45-656 . A = B+C;
45-657 . A = B+C;
45-658 . A = B-C;
45-659 . A = B-C;
45-660 . A = B/C;
45-661 . A = B+C;
45-662 .
45-663 . if (A != B)
45-664 . {
45-665 . A = B + C;
45-666 . D = E + F;
45-667 . }
45-668 .
45-669 . A = B+C;
45-670 .
45-671 . if (A eq B)
45-672 . {
45-673 . A = B + C;
45-674 . D = E + F;
45-675 . }
45-676 .
45-677 . A = B*C;
45-678 . A = B-C;
45-679 . A = B*C;
45-680 . A = B-C;
45-681 . A = B/C;
45-682 . free(FreePtr);
45-683 . A = B+C;
45-684 . A = B+C;
45-685 .
45-686 . if (A != B)
45-687 . {
45-688 . A = B + C;
45-689 . D = E + F;
45-690 . }
45-691 .
45-692 . A = B+C;
45-693 . A = B*C;
45-694 .
45-695 . if (A ge B)
45-696 . {
45-697 . A = B + C;
45-698 . D = E + F;
45-699 . }
45-700 .
45-701 . A = B*C;
45-702 .
45-703 . if (A gt B)
45-704 . {
45-705 . A = B + C;
45-706 . D = E + F;
45-707 . }
45-708 .
45-709 . A = B/C;
45-710 .
45-711 . if (A == B)
45-712 . {
45-713 . A = B + C;
45-714 . D = E + F;
45-715 . }
45-716 .
45-717 .
45-718 . switch (pwr stuff)
45-719 . {
45-720 . case one:
45-721 . {
45-722 . run_this;
45-723 . break;
45-724 . }
45-725 . case two:
45-726 . {
45-727 . run_this;
45-728 . break;
45-729 . }
45-730 . // missing default
45-731 . }
45-732 .
45-733 . A = B-C;
45-734 . A = B*C;
45-735 . A = B-C;
45-736 .
45-737 . if (A ge B)
45-738 . {
45-739 . A = B + C;
45-740 . D = E + F;
45-741 . }
45-742 .
45-743 . A = B*C;
45-744 . A = B*C;
45-745 . A = B/C;
45-746 . A = B*C;
45-747 . A = B*C;
45-748 .
45-749 . if (A > B)
45-750 . {
45-751 . A = B + C;
45-752 . D = E + F;
45-753 . }
45-754 .
45-755 .
45-756 . if (A le B)
45-757 . {
45-758 . A = B + C;
45-759 . D = E + F;
45-760 . }
45-761 .
45-762 . A = B*C;
45-763 . A = B*C;
45-764 .
45-765 . if (A > = B)
45-766 . {
45-767 . A = B + C;
45-768 . D = E + F;
45-769 . }
45-770 .
45-771 .
45-772 . if (A le B)
45-773 . {
45-774 . A = B + C;
45-775 . D = E + F;
45-776 . }
45-777 .
45-778 . A = B*C;
45-779 . /* LE SV TOC-2449 this is a pwr-03.6.45 req to store*/
45-780 . A = B/C;
45-781 .
45-782 . #ifdef LAZY
45-783 . // this is not nice
45-784 . A = B + C;
45-785 . A = B + C;
45-786 . #endif
45-787 .
45-788 . A = B*C;
45-789 .
45-790 . switch (pwr stuff)
45-791 . {
45-792 . case one:
45-793 . {
45-794 . run_this;
45-795 . break;
45-796 . }
45-797 . case two:
45-798 . {
45-799 . run_this;
45-800 . break;
45-801 . }
45-802 . default:
45-803 . {
45-804 . SwError;
45-805 . }
45-806 . }
45-807 .
45-808 .
45-809 . if (A lt B)
45-810 . {
45-811 . A = B + C;
45-812 . D = E + F;
45-813 . }
45-814 .
45-815 . A = B-C;
45-816 . A = B-C;
45-817 .
45-818 . if (A le B)
45-819 . {
45-820 . A = B + C;
45-821 . D = E + F;
45-822 . }
45-823 .
45-824 . A = B-C;
45-825 . A = B/C;
45-826 .
45-827 . if (A ge B)
45-828 . {
45-829 . A = B + C;
45-830 . D = E + F;
45-831 . }
45-832 .
45-833 . A = B+C;
45-834 . A = B*C;
45-835 . // max LOC 56
45-836 .
45-837 . }
45-838 .
45-839 .
45-840 . /*
45-841 . -----------------------------------------------------------------------------
45-842 . --| NAME: pwr.3.7
45-843 . --|
45-844 . --| ABSTRACT:
45-845 . --| This function does pwr stuff.
45-846 . --|
45-847 . --| RETURNS:
45-848 . --| NONE.
45-849 . --|
45-850 . ----------------------------------------------------------------------------
45-851 . */
45-852 . static void pwr.3.7(void)
45-853 . {
45-854 .
45-855 . if (A lt B)
45-856 . {
45-857 . A = B + C;
45-858 . D = E + F;
45-859 . }
45-860 .
45-861 . A = B+C;
45-862 .
45-863 . if (A eq B)
45-864 . {
45-865 . A = B + C;
45-866 . D = E + F;
45-867 . }
45-868 .
45-869 . A = B-C;
45-870 . A = B/C;
45-871 .
45-872 . if (A ge B)
45-873 . {
45-874 . A = B + C;
45-875 . D = E + F;
45-876 . }
45-877 .
45-878 .
45-879 . switch (pwr stuff)
45-880 . {
45-881 . case one:
45-882 . {
45-883 . run_this;
45-884 . break;
45-885 . }
45-886 . case two:
45-887 . {
45-888 . run_this;
45-889 . break;
45-890 . }
45-891 . default:
45-892 . {
45-893 . SwError;
45-894 . }
45-895 . }
45-896 .
45-897 .
45-898 . if (A != B)
45-899 . {
45-900 . A = B + C;
45-901 . D = E + F;
45-902 . }
45-903 .
45-904 . A = B-C;
45-905 . A = B/C;
45-906 . A = B-C;
45-907 . A = B+C;
45-908 . A = B+C;
45-909 .
45-910 . if (A lt B)
45-911 . {
45-912 . A = B + C;
45-913 . D = E + F;
45-914 . }
45-915 .
45-916 .
45-917 . if (A == B)
45-918 . {
45-919 . A = B + C;
45-920 . D = E + F;
45-921 . }
45-922 .
45-923 .
45-924 . if (A == B)
45-925 . {
45-926 . A = B + C;
45-927 . D = E + F;
45-928 . }
45-929 .
45-930 .
45-931 . if (A le B)
45-932 . {
45-933 . A = B + C;
45-934 . D = E + F;
45-935 . }
45-936 .
45-937 . A = B/C;
45-938 .
45-939 . if (A ne B)
45-940 . {
45-941 . A = B + C;
45-942 . D = E + F;
45-943 . }
45-944 .
45-945 . A = B-C;
45-946 . A = B*C;
45-947 .
45-948 . if (A ne B)
45-949 . {
45-950 . A = B + C;
45-951 . D = E + F;
45-952 . }
45-953 .
45-954 . /* LE SV TOC-2450 this is a pwr-03.7.23 req to set RTC*/
45-955 . A = 0x0004;
45-956 . A = B+C;
45-957 . A = B+C;
45-958 . A = B/C;
45-959 . A = B+C;
45-960 .
45-961 . switch (pwr stuff)
45-962 . {
45-963 . case one:
45-964 . {
45-965 . run_this;
45-966 . break;
45-967 . }
45-968 . case two:
45-969 . {
45-970 . run_this;
45-971 . break;
45-972 . }
45-973 . default:
45-974 . {
45-975 . SwError;
45-976 . }
45-977 . }
45-978 .
45-979 . A = B+C;
45-980 .
45-981 . switch (pwr stuff)
45-982 . {
45-983 . case one:
45-984 . {
45-985 . run_this;
45-986 . break;
45-987 . }
45-988 . case two:
45-989 . {
45-990 . run_this;
45-991 . break;
45-992 . }
45-993 . default:
45-994 . {
45-995 . SwError;
45-996 . }
45-997 . }
45-998 .
45-999 .
45-1000 . switch (pwr stuff)
45-1001 . {
45-1002 . case one:
45-1003 . {
45-1004 . run_this;
45-1005 . break;
45-1006 . }
45-1007 . case two:
45-1008 . {
45-1009 . run_this;
45-1010 . break;
45-1011 . }
45-1012 . default:
45-1013 . {
45-1014 . SwError;
45-1015 . }
45-1016 . }
45-1017 .
45-1018 . // max LOC 30
45-1019 .
45-1020 . }
45-1021 .
45-1022 .
45-1023 . /*
45-1024 . -----------------------------------------------------------------------------
45-1025 . --| NAME: pwr.3.8
45-1026 . --|
45-1027 . --| ABSTRACT:
45-1028 . --| This function does pwr stuff.
45-1029 . --|
45-1030 . --| RETURNS:
45-1031 . --| NONE.
45-1032 . --|
45-1033 . ----------------------------------------------------------------------------
45-1034 . */
45-1035 . static void pwr.3.8(void)
45-1036 . {
45-1037 . A = B-C;
45-1038 . A = B*C;
45-1039 . A = B/C;
45-1040 . A = B+C;
45-1041 . A = 0x0001;
45-1042 .
45-1043 . if (A lt B)
45-1044 . {
45-1045 . A = B + C;
45-1046 . D = E + F;
45-1047 . }
45-1048 .
45-1049 . A = B/C;
45-1050 . A = B+C;
45-1051 .
45-1052 . switch (pwr stuff)
45-1053 . {
45-1054 . case one:
45-1055 . {
45-1056 . run_this;
45-1057 . break;
45-1058 . }
45-1059 . case two:
45-1060 . {
45-1061 . run_this;
45-1062 . break;
45-1063 . }
45-1064 . default:
45-1065 . {
45-1066 . SwError;
45-1067 . }
45-1068 . }
45-1069 .
45-1070 .
45-1071 . if (A < = B)
45-1072 . {
45-1073 . A = B + C;
45-1074 . D = E + F;
45-1075 . }
45-1076 .
45-1077 . A = B+C;
45-1078 . A = B*C;
45-1079 . A = B-C;
45-1080 . A = B/C;
45-1081 .
45-1082 . if (A gt B)
45-1083 . {
45-1084 . A = B + C;
45-1085 . D = E + F;
45-1086 . }
45-1087 .
45-1088 .
45-1089 . if (A < = B)
45-1090 . {
45-1091 . A = B + C;
45-1092 . D = E + F;
45-1093 . }
45-1094 .
45-1095 . A = B+C;
45-1096 . rcv_buffer = (U16 *) alloc(size+1);
45-1097 .
45-1098 . if (A < = B)
45-1099 . {
45-1100 . A = B + C;
45-1101 . D = E + F;
45-1102 . }
45-1103 .
45-1104 . A = B*C;
45-1105 . A = B-C;
45-1106 . A = B+C;
45-1107 .
45-1108 . if (A gt B)
45-1109 . {
45-1110 . A = B + C;
45-1111 . D = E + F;
45-1112 . }
45-1113 .
45-1114 . /* LE SV TOC-2451 this is a pwr-03.8.22 req to compare*/
45-1115 . A = B-C;
45-1116 . A = B*C;
45-1117 .
45-1118 . if (A gt B)
45-1119 . {
45-1120 . A = B + C;
45-1121 . D = E + F;
45-1122 . }
45-1123 .
45-1124 . A = B+C;
45-1125 . /* LE SV TOC-2452 this is a pwr-03.8.26 req to translate*/
45-1126 .
45-1127 . if (A > = B)
45-1128 . {
45-1129 . A = B + C;
45-1130 . D = E + F;
45-1131 . }
45-1132 .
45-1133 . /* LE SV TOC-2453 this is a pwr-03.8.27 req to convert*/
45-1134 . A = 0x0002;
45-1135 .
45-1136 . if (A < = B)
45-1137 . {
45-1138 . A = B + C;
45-1139 . D = E + F;
45-1140 . }
45-1141 .
45-1142 . A = B*C;
45-1143 . A = B*C;
45-1144 . A = B/C;
45-1145 . A = B*C;
45-1146 . A = B+C;
45-1147 . /* LE SV TOC-2454 this is a pwr-03.8.33 req to translate*/
45-1148 .
45-1149 . if (A gt B)
45-1150 . {
45-1151 . A = B + C;
45-1152 . D = E + F;
45-1153 . }
45-1154 .
45-1155 .
45-1156 . if (A > = B)
45-1157 . {
45-1158 . A = B + C;
45-1159 . D = E + F;
45-1160 . }
45-1161 .
45-1162 . A = B+C;
45-1163 .
45-1164 . if (A ge B)
45-1165 . {
45-1166 . A = B + C;
45-1167 . D = E + F;
45-1168 . }
45-1169 .
45-1170 . A = B-C;
45-1171 . A = B*C;
45-1172 . A = B/C;
45-1173 .
45-1174 . if (A < B)
45-1175 . {
45-1176 . A = B + C;
45-1177 . D = E + F;
45-1178 . }
45-1179 .
45-1180 .
45-1181 . if (A ne B)
45-1182 . {
45-1183 . A = B + C;
45-1184 . D = E + F;
45-1185 . }
45-1186 .
45-1187 . A = B-C;
45-1188 . A = B-C;
45-1189 . A = B-C;
45-1190 . /* dead_code = A * B; */
45-1191 . A = B+C;
45-1192 . A = B*C;
45-1193 . A = B*C;
45-1194 .
45-1195 . if (A le B)
45-1196 . {
45-1197 . A = B + C;
45-1198 . D = E + F;
45-1199 . }
45-1200 .
45-1201 .
45-1202 . switch (pwr stuff)
45-1203 . {
45-1204 . case one:
45-1205 . {
45-1206 . run_this;
45-1207 . break;
45-1208 . }
45-1209 . case two:
45-1210 . {
45-1211 . run_this;
45-1212 . break;
45-1213 . }
45-1214 . default:
45-1215 . {
45-1216 . SwError;
45-1217 . }
45-1218 . }
45-1219 .
45-1220 . A = B+C;
45-1221 . /* LE SV TOC-2455 this is a pwr-03.8.51 req to check pSOS*/
45-1222 . A = 0x0007;
45-1223 . A = B/C;
45-1224 .
45-1225 . /*
45-1226 . dead_code = B - C;
45-1227 . dead_code = D - E;
45-1228 . dead_code = F - G;
45-1229 . */
45-1230 .
45-1231 . A = B+C;
45-1232 . A = B+C;
45-1233 . A = B-C;
45-1234 . A = B*C;
45-1235 . A = B-C;
45-1236 . A = B+C;
45-1237 . /* LE SV TOC-2456 this is a pwr-03.8.58 req to translate*/
45-1238 .
45-1239 . if (A > = B)
45-1240 . {
45-1241 . A = B + C;
45-1242 . D = E + F;
45-1243 . }
45-1244 .
45-1245 . A = B-C;
45-1246 .
45-1247 . if (A < B)
45-1248 . {
45-1249 . A = B + C;
45-1250 . D = E + F;
45-1251 . }
45-1252 .
45-1253 . A = B*C;
45-1254 . A = B*C;
45-1255 .
45-1256 . if (A > = B)
45-1257 . {
45-1258 . A = B + C;
45-1259 . D = E + F;
45-1260 . }
45-1261 .
45-1262 . A = B*C;
45-1263 . /* LE SV TOC-2457 this is a pwr-03.8.65 req to convert*/
45-1264 . A = B*C;
45-1265 . A = B-C;
45-1266 . A = B+C;
45-1267 . A = B*C;
45-1268 .
45-1269 . /* dead_code = B + C;
45-1270 . dead_code = D + E;
45-1271 . dead_code = F + G; */
45-1272 .
45-1273 .
45-1274 . if (A eq B)
45-1275 . {
45-1276 . A = B + C;
45-1277 . D = E + F;
45-1278 . }
45-1279 .
45-1280 . A = B+C;
45-1281 . A = B/C;
45-1282 . A = B*C;
45-1283 . A = B-C;
45-1284 .
45-1285 . if (A ne B)
45-1286 . {
45-1287 . A = B + C;
45-1288 . D = E + F;
45-1289 . }
45-1290 .
45-1291 . A = B-C;
45-1292 . A = B*C;
45-1293 . A = B/C;
45-1294 .
45-1295 . if (A == B)
45-1296 . {
45-1297 . A = B + C;
45-1298 . D = E + F;
45-1299 . }
45-1300 .
45-1301 . A = B*C;
45-1302 . A = B/C;
45-1303 . // max LOC 80
45-1304 .
45-1305 . }
45-1306 .
45 45 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-03.c
46 46 Source: source/ft-app/ft-app-B1.1/pwr/pwr-04.c
46-0 . /*
46-1 . ----------------------------------------------------------------------------
46-2 . --| BEGIN PROLOGUE
46-3 . --|
46-4 . --| CLASSIFICATION: UNCLASSIFIED
46-5 . --|
46-6 . --| FILE NAME: pwr-04.c
46-7 . --|
46-8 . --| ABSTRACT:
46-9 . --| This file contains the 11 functions that do file pwr stuff.
46-10 . --|
46-11 . --| HISTORY:
46-12 . --| CCCQ_NAME:
46-13 . --| CCCQ_VER:
46-14 . --|
46-15 . --| END PROLOGUE
46-16 . ----------------------------------------------------------------------------
46-17 . */
46-18 .
46-19 . #define C;
46-20 . #define B;
46-21 . int A;
46-22 . float B;
46-23 . #define B;
46-24 . #include A;
46-25 . #include B;
46-26 . #include A;
46-27 .
46-28 .
46-29 .
46-30 . /*
46-31 . -----------------------------------------------------------------------------
46-32 . --| NAME: pwr.4.1
46-33 . --|
46-34 . --| ABSTRACT:
46-35 . --| This function does pwr stuff.
46-36 . --|
46-37 . --| RETURNS:
46-38 . --| NONE.
46-39 . --|
46-40 . ----------------------------------------------------------------------------
46-41 . */
46-42 . static void pwr.4.1(void)
46-43 . {
46-44 . A = B/C;
46-45 .
46-46 . if (A lt B)
46-47 . {
46-48 . A = B + C;
46-49 . D = E + F;
46-50 . }
46-51 .
46-52 . A = B/C;
46-53 . /* LE SV TOC-2458 this is a pwr-04.1.4 req to store*/
46-54 .
46-55 . if (A ne B)
46-56 . {
46-57 . A = B + C;
46-58 . D = E + F;
46-59 . }
46-60 .
46-61 . A = B*C;
46-62 . A = B/C;
46-63 . A = B-C;
46-64 . A = B/C;
46-65 . A = B*C;
46-66 . A = B/C;
46-67 . A = B-C;
46-68 . A = B*C;
46-69 . A = B-C;
46-70 . A = B-C;
46-71 .
46-72 . switch (pwr stuff)
46-73 . {
46-74 . case one:
46-75 . {
46-76 . run_this;
46-77 . break;
46-78 . }
46-79 . case two:
46-80 . {
46-81 . run_this;
46-82 . break;
46-83 . }
46-84 . default:
46-85 . {
46-86 . // missing error call
46-87 . }
46-88 . }
46-89 .
46-90 . A = B*C;
46-91 . A = B+C;
46-92 . A = B/C;
46-93 .
46-94 . if (A == B)
46-95 . {
46-96 . A = B + C;
46-97 . D = E + F;
46-98 . }
46-99 .
46-100 . /* LE SV TOC-2459 this is a pwr-04.1.19 req to update*/
46-101 . A = B/C;
46-102 .
46-103 . if (A ne B)
46-104 . {
46-105 . A = B + C;
46-106 . D = E + F;
46-107 . }
46-108 .
46-109 . A = B*C;
46-110 . A = B-C;
46-111 . /* LE SV TOC-2460 this is a pwr-04.1.23 req to call isr*/
46-112 .
46-113 . if (A > B)
46-114 . {
46-115 . A = B + C;
46-116 . D = E + F;
46-117 . }
46-118 .
46-119 . A = B/C;
46-120 . A = B-C;
46-121 . A = B+C;
46-122 . A = B/C;
46-123 . A = B*C;
46-124 . A = B-C;
46-125 .
46-126 . if (A == B)
46-127 . {
46-128 . A = B + C;
46-129 . D = E + F;
46-130 . }
46-131 .
46-132 . A = B*C;
46-133 .
46-134 . if (A == B)
46-135 . {
46-136 . A = B + C;
46-137 . D = E + F;
46-138 . }
46-139 .
46-140 . /* LE SV TOC-2461 this is a pwr-04.1.33 req to call isr*/
46-141 . A = B*C;
46-142 . A = B*C;
46-143 . A = B+C;
46-144 . A = B+C;
46-145 . /* LE SV TOC-2462 this is a pwr-04.1.37 req to record*/
46-146 . A = B-C;
46-147 . A = B-C;
46-148 . /* LE SV TOC-2463 this is a pwr-04.1.39 req to assign*/
46-149 . A = B-C;
46-150 . A = B+C;
46-151 . // max LOC 40
46-152 .
46-153 . }
46-154 .
46-155 .
46-156 . /*
46-157 . -----------------------------------------------------------------------------
46-158 . --| NAME: pwr.4.2
46-159 . --|
46-160 . --| ABSTRACT:
46-161 . --| This function does pwr stuff.
46-162 . --|
46-163 . --| RETURNS:
46-164 . --| NONE.
46-165 . --|
46-166 . ----------------------------------------------------------------------------
46-167 . */
46-168 . static void pwr.4.2(void)
46-169 . {
46-170 . A = B-C;
46-171 . /* LE SV TOC-2464 this is a pwr-04.2.2 req to set RTC*/
46-172 . A = B/C;
46-173 .
46-174 . if (A == B)
46-175 . {
46-176 . A = B + C;
46-177 . D = E + F;
46-178 . }
46-179 .
46-180 . A = B*C;
46-181 .
46-182 . if (A ge B)
46-183 . {
46-184 . A = B + C;
46-185 . D = E + F;
46-186 . }
46-187 .
46-188 . A = B+C;
46-189 .
46-190 . if (A gt B)
46-191 . {
46-192 . A = B + C;
46-193 . D = E + F;
46-194 . }
46-195 .
46-196 . A = B*C;
46-197 . A = B-C;
46-198 . A = B+C;
46-199 . A = B+C;
46-200 . A = B*C;
46-201 .
46-202 . if (A > B)
46-203 . {
46-204 . A = B + C;
46-205 . D = E + F;
46-206 . }
46-207 .
46-208 . A = B*C;
46-209 . A = B+C;
46-210 .
46-211 . if (A != B)
46-212 . {
46-213 . A = B + C;
46-214 . D = E + F;
46-215 . }
46-216 .
46-217 . A = B*C;
46-218 . A = B/C;
46-219 . A = B+C;
46-220 . A = B-C;
46-221 . A = B-C;
46-222 .
46-223 . if (A ge B)
46-224 . {
46-225 . A = B + C;
46-226 . D = E + F;
46-227 . }
46-228 .
46-229 . A = B/C;
46-230 . A = B/C;
46-231 . A = B*C;
46-232 . A = B-C;
46-233 . A = B+C;
46-234 . A = B-C;
46-235 .
46-236 . if (A < = B)
46-237 . {
46-238 . A = B + C;
46-239 . D = E + F;
46-240 . }
46-241 .
46-242 . A = B*C;
46-243 . A = B-C;
46-244 . A = B+C;
46-245 . A = B+C;
46-246 . A = B/C;
46-247 .
46-248 . if (A le B)
46-249 . {
46-250 . A = B + C;
46-251 . D = E + F;
46-252 . }
46-253 .
46-254 . A = B+C;
46-255 . A = B+C;
46-256 .
46-257 . if (A le B)
46-258 . {
46-259 . A = B + C;
46-260 . D = E + F;
46-261 . }
46-262 .
46-263 .
46-264 . if (A ge B)
46-265 . {
46-266 . A = B + C;
46-267 . D = E + F;
46-268 . }
46-269 .
46-270 . A = B/C;
46-271 . A = B-C;
46-272 . A = B*C;
46-273 .
46-274 . if (A le B)
46-275 . {
46-276 . A = B + C;
46-277 . D = E + F;
46-278 . }
46-279 .
46-280 . A = B-C;
46-281 .
46-282 . if (A > = B)
46-283 . {
46-284 . A = B + C;
46-285 . D = E + F;
46-286 . }
46-287 .
46-288 .
46-289 . if ($pwr stuff > $otherpwr stuff)
46-290 . /* LE SV TOC-008 we really should log all error calls */
46-291 . {
46-292 . A = B + C;
46-293 . }
46-294 .
46-295 . A = B*C;
46-296 . A = B+C;
46-297 . A = B-C;
46-298 . A = B*C;
46-299 . // TBS - I need to figure this out
46-300 . A = B*C;
46-301 . A = B+C;
46-302 . A = B+C;
46-303 .
46-304 . if (A > B)
46-305 . {
46-306 . A = B + C;
46-307 . D = E + F;
46-308 . }
46-309 .
46-310 . /* LE SV TOC-2465 this is a pwr-04.2.54 req to assign*/
46-311 . A = 0x0001;
46-312 .
46-313 . if (A != B)
46-314 . {
46-315 . A = B + C;
46-316 . D = E + F;
46-317 . }
46-318 .
46-319 .
46-320 . if (A < = B)
46-321 . {
46-322 . A = B + C;
46-323 . D = E + F;
46-324 . }
46-325 .
46-326 . A = B-C;
46-327 . A = B*C;
46-328 . A = B*C;
46-329 .
46-330 . if (A < = B)
46-331 . {
46-332 . A = B + C;
46-333 . D = E + F;
46-334 . }
46-335 .
46-336 . A = B-C;
46-337 .
46-338 . if (A != B)
46-339 . {
46-340 . A = B + C;
46-341 . D = E + F;
46-342 . }
46-343 .
46-344 . A = B*C;
46-345 . A = B+C;
46-346 . A = B/C;
46-347 . A = B*C;
46-348 . A = (float)B + C;
46-349 . A = B-C;
46-350 . /* LE SV TOC-2466 this is a pwr-04.2.67 req to verify*/
46-351 . A = B-C;
46-352 . A = B*C;
46-353 . /* LE SV TOC-2467 this is a pwr-04.2.69 req to call isr*/
46-354 . A = B*C;
46-355 . A = B/C;
46-356 . A = B*C;
46-357 . // max LOC 71
46-358 .
46-359 . }
46-360 .
46-361 .
46-362 . /*
46-363 . -----------------------------------------------------------------------------
46-364 . --| NAME: pwr.4.3
46-365 . --|
46-366 . --| ABSTRACT:
46-367 . --| This function does pwr stuff.
46-368 . --|
46-369 . --| RETURNS:
46-370 . --| NONE.
46-371 . --|
46-372 . ----------------------------------------------------------------------------
46-373 . */
46-374 . static void pwr.4.3(void)
46-375 . {
46-376 . A = B*C;
46-377 . A = B+C;
46-378 . A = B+C;
46-379 . A = B*C;
46-380 .
46-381 . if (A < = B)
46-382 . {
46-383 . A = B + C;
46-384 . D = E + F;
46-385 . }
46-386 .
46-387 . A = B+C;
46-388 .
46-389 . if (veg)
46-390 . // missing curly brace
46-391 . variable = orange;
46-392 .
46-393 .
46-394 . if (A ge B)
46-395 . {
46-396 . A = B + C;
46-397 . D = E + F;
46-398 . }
46-399 .
46-400 . A = B-C;
46-401 . A = B/C;
46-402 .
46-403 . if (A ne B)
46-404 . {
46-405 . A = B + C;
46-406 . D = E + F;
46-407 . }
46-408 .
46-409 . A = B-C;
46-410 .
46-411 . if (A le B)
46-412 . {
46-413 . A = B + C;
46-414 . D = E + F;
46-415 . }
46-416 .
46-417 .
46-418 . if (A lt B)
46-419 . {
46-420 . A = B + C;
46-421 . D = E + F;
46-422 . }
46-423 .
46-424 . A = B/C;
46-425 . A = B+C;
46-426 . A = B*C;
46-427 . A = B+C;
46-428 .
46-429 . if (A < B)
46-430 . {
46-431 . A = B + C;
46-432 . D = E + F;
46-433 . }
46-434 .
46-435 . A = B*C;
46-436 .
46-437 . /*
46-438 . dead_code = B - C;
46-439 . dead_code = D - E;
46-440 . dead_code = F - G;
46-441 . */
46-442 .
46-443 . A = B/C;
46-444 . A = B*C;
46-445 . /* LE SV TOC-2468 this is a pwr-04.3.22 req to call admin*/
46-446 . A = B-C;
46-447 . A = B-C;
46-448 .
46-449 . switch (pwr stuff)
46-450 . {
46-451 . case one:
46-452 . {
46-453 . switch (nested)
46-454 . {
46-455 . case:
46-456 . X = Y + Z;
46-457 . case:
46-458 . X = Y + Z;
46-459 . default:
46-460 . SwError;
46-461 . }
46-462 . }
46-463 . case two:
46-464 . {
46-465 . run_this;
46-466 . break;
46-467 . }
46-468 . default:
46-469 . {
46-470 . SwError;
46-471 . }
46-472 . }
46-473 .
46-474 . A = B-C;
46-475 . A = 0x0008;
46-476 . A = B*C;
46-477 .
46-478 . if (A eq B)
46-479 . {
46-480 . A = B + C;
46-481 . D = E + F;
46-482 . }
46-483 .
46-484 .
46-485 . if (A < B)
46-486 . {
46-487 . A = B + C;
46-488 . D = E + F;
46-489 . }
46-490 .
46-491 .
46-492 . if (A ne B)
46-493 . {
46-494 . A = B + C;
46-495 . D = E + F;
46-496 . }
46-497 .
46-498 . A = B*C;
46-499 . A = B/C;
46-500 . goto error;
46-501 . A = B*C;
46-502 . A = B*C;
46-503 . A = B+C;
46-504 . A = B*C;
46-505 . A = B/C;
46-506 .
46-507 . if (A ne B)
46-508 . {
46-509 . A = B + C;
46-510 . D = E + F;
46-511 . }
46-512 .
46-513 . A = B-C;
46-514 .
46-515 . if (A ne B)
46-516 . {
46-517 . A = B + C;
46-518 . D = E + F;
46-519 . }
46-520 .
46-521 . A = B+C;
46-522 . A = B*C;
46-523 . A = 0x0008;
46-524 . A = B+C;
46-525 .
46-526 . if (A > = B)
46-527 . {
46-528 . A = B + C;
46-529 . D = E + F;
46-530 . }
46-531 .
46-532 .
46-533 . if (A lt B)
46-534 . {
46-535 . A = B + C;
46-536 . D = E + F;
46-537 . }
46-538 .
46-539 . /* LE SV TOC-2469 this is a pwr-04.3.44 req to reject*/
46-540 .
46-541 . if (A gt B)
46-542 . {
46-543 . A = B + C;
46-544 . D = E + F;
46-545 . }
46-546 .
46-547 . A = B-C;
46-548 . A = B+C;
46-549 . A = B*C;
46-550 .
46-551 . if (A == B)
46-552 . {
46-553 . A = B + C;
46-554 . D = E + F;
46-555 . }
46-556 .
46-557 .
46-558 . if (A le B)
46-559 . {
46-560 . A = B + C;
46-561 . D = E + F;
46-562 . }
46-563 .
46-564 . A = B*C;
46-565 . A = B*C;
46-566 . A = B*C;
46-567 . A = (long)B + C;
46-568 . A = B-C;
46-569 . A = B-C;
46-570 . A = B*C;
46-571 . A = (long)B + C;
46-572 . A = B-C;
46-573 . A = B/C;
46-574 .
46-575 . if (A == B)
46-576 . {
46-577 . A = B + C;
46-578 . D = E + F;
46-579 . }
46-580 .
46-581 . A = B*C;
46-582 . A = B-C;
46-583 .
46-584 . if (A eq B)
46-585 . {
46-586 . A = B + C;
46-587 . D = E + F;
46-588 . }
46-589 .
46-590 . /* LE SV TOC-2470 this is a pwr-04.3.62 req to assign*/
46-591 . A = B+C;
46-592 . /* LE SV TOC-2471 this is a pwr-04.3.63 req to record*/
46-593 . A = B/C;
46-594 . A = B-C;
46-595 . A = B+C;
46-596 .
46-597 . if (A gt B)
46-598 . {
46-599 . A = B + C;
46-600 . D = E + F;
46-601 . }
46-602 .
46-603 . A = B*C;
46-604 . // max LOC 67
46-605 .
46-606 . }
46-607 .
46-608 .
46-609 . /*
46-610 . -----------------------------------------------------------------------------
46-611 . --| NAME: pwr.4.4
46-612 . --|
46-613 . --| ABSTRACT:
46-614 . --| This function does pwr stuff.
46-615 . --|
46-616 . --| RETURNS:
46-617 . --| NONE.
46-618 . --|
46-619 . ----------------------------------------------------------------------------
46-620 . */
46-621 . static void pwr.4.4(void)
46-622 . {
46-623 .
46-624 . if (A < = B)
46-625 . {
46-626 . A = B + C;
46-627 . D = E + F;
46-628 . }
46-629 .
46-630 . A = B+C;
46-631 . A = B-C;
46-632 . A = B+C;
46-633 .
46-634 . switch (pwr stuff)
46-635 . {
46-636 . case one:
46-637 . {
46-638 . run_this;
46-639 . break;
46-640 . }
46-641 . case two:
46-642 . {
46-643 . run_this;
46-644 . break;
46-645 . }
46-646 . default:
46-647 . {
46-648 . SwError;
46-649 . }
46-650 . }
46-651 .
46-652 .
46-653 . if (A le B)
46-654 . {
46-655 . A = B + C;
46-656 . D = E + F;
46-657 . }
46-658 .
46-659 .
46-660 . /*
46-661 . dead_code = B - C;
46-662 . dead_code = D - E;
46-663 . dead_code = F - G;
46-664 . */
46-665 .
46-666 . A = B+C;
46-667 . A = B-C;
46-668 .
46-669 . if (A le B)
46-670 . {
46-671 . A = B + C;
46-672 . D = E + F;
46-673 . }
46-674 .
46-675 . A = B/C;
46-676 .
46-677 . if (A > = B)
46-678 . {
46-679 . A = B + C;
46-680 . D = E + F;
46-681 . }
46-682 .
46-683 . A = B/C;
46-684 .
46-685 . if (A > B)
46-686 . {
46-687 . A = B + C;
46-688 . D = E + F;
46-689 . }
46-690 .
46-691 .
46-692 . switch (pwr stuff)
46-693 . {
46-694 . case one:
46-695 . {
46-696 . run_this;
46-697 . break;
46-698 . }
46-699 . case two:
46-700 . {
46-701 . run_this;
46-702 . break;
46-703 . }
46-704 . default:
46-705 . {
46-706 . SwError;
46-707 . }
46-708 . }
46-709 .
46-710 . A = B+C;
46-711 .
46-712 . if (A < B)
46-713 . {
46-714 . A = B + C;
46-715 . D = E + F;
46-716 . }
46-717 .
46-718 . /* LE SV TOC-2472 this is a pwr-04.4.17 req to audit*/
46-719 .
46-720 . if (A != B)
46-721 . {
46-722 . A = B + C;
46-723 . D = E + F;
46-724 . }
46-725 .
46-726 . A = B/C;
46-727 . A = B/C;
46-728 .
46-729 . if (A > = B)
46-730 . {
46-731 . A = B + C;
46-732 . D = E + F;
46-733 . }
46-734 .
46-735 . // max LOC 20
46-736 .
46-737 . }
46-738 .
46-739 .
46-740 . /*
46-741 . -----------------------------------------------------------------------------
46-742 . --| NAME: pwr.4.5
46-743 . --|
46-744 . --| ABSTRACT:
46-745 . --| This function does pwr stuff.
46-746 . --|
46-747 . --| RETURNS:
46-748 . --| NONE.
46-749 . --|
46-750 . ----------------------------------------------------------------------------
46-751 . */
46-752 . static void pwr.4.5(void)
46-753 . {
46-754 .
46-755 . if (A < = B)
46-756 . {
46-757 . A = B + C;
46-758 . D = E + F;
46-759 . }
46-760 .
46-761 . A = B/C;
46-762 . A = B/C;
46-763 .
46-764 . if (A lt B)
46-765 . {
46-766 . A = B + C;
46-767 . D = E + F;
46-768 . }
46-769 .
46-770 . A = B-C;
46-771 . A = B/C;
46-772 .
46-773 . if (A == B)
46-774 . {
46-775 . A = B + C;
46-776 . D = E + F;
46-777 . }
46-778 .
46-779 . A = B*C;
46-780 . /* LE SV TOC-2473 this is a pwr-04.5.9 req to reject*/
46-781 . A = B+C;
46-782 . A = B/C;
46-783 . A = B/C;
46-784 . A = B*C;
46-785 . A = B*C;
46-786 .
46-787 . if (A != B)
46-788 . {
46-789 . A = B + C;
46-790 . D = E + F;
46-791 . }
46-792 .
46-793 . A = B+C;
46-794 . A = B-C;
46-795 .
46-796 . if (A gt B)
46-797 . {
46-798 . A = B + C;
46-799 . D = E + F;
46-800 . }
46-801 .
46-802 . A = B-C;
46-803 . A = B-C;
46-804 .
46-805 . if (A ne B)
46-806 . {
46-807 . A = B + C;
46-808 . D = E + F;
46-809 . }
46-810 .
46-811 .
46-812 . switch (pwr stuff)
46-813 . {
46-814 . case:
46-815 . case:
46-816 . // stacked case statements but only if there is a new line in between
46-817 .
46-818 . case:
46-819 . case:
46-820 . case:
46-821 . {
46-822 . run_this;
46-823 . break;
46-824 . }
46-825 . default:
46-826 . {
46-827 . halt;
46-828 . }
46-829 . }
46-830 .
46-831 . A = B/C;
46-832 . A = B*C;
46-833 . A = B/C;
46-834 . A = B+C;
46-835 . A = 0x0003;
46-836 .
46-837 . if (A le B)
46-838 . {
46-839 . A = B + C;
46-840 . D = E + F;
46-841 . }
46-842 .
46-843 . // max LOC 25
46-844 .
46-845 . }
46-846 .
46-847 .
46-848 . /*
46-849 . -----------------------------------------------------------------------------
46-850 . --| NAME: pwr.4.6
46-851 . --|
46-852 . --| ABSTRACT:
46-853 . --| This function does pwr stuff.
46-854 . --|
46-855 . --| RETURNS:
46-856 . --| NONE.
46-857 . --|
46-858 . ----------------------------------------------------------------------------
46-859 . */
46-860 . static void pwr.4.6(void)
46-861 . {
46-862 . A = 0x0003;
46-863 . A = B/C;
46-864 .
46-865 . if (A le B)
46-866 . {
46-867 . A = B + C;
46-868 . D = E + F;
46-869 . }
46-870 .
46-871 . A = B*C;
46-872 . A = B-C;
46-873 . A = B*C;
46-874 .
46-875 . if (A le B)
46-876 . {
46-877 . A = B + C;
46-878 . D = E + F;
46-879 . }
46-880 .
46-881 .
46-882 . if (A gt B)
46-883 . {
46-884 . A = B + C;
46-885 . D = E + F;
46-886 . }
46-887 .
46-888 . A = B+C;
46-889 . A = B/C;
46-890 . A = B+C;
46-891 . send_buffer = (U16 *) malloc(size+1);
46-892 . A = B+C;
46-893 . A = B*C;
46-894 .
46-895 . if (A le B)
46-896 . {
46-897 . A = B + C;
46-898 . D = E + F;
46-899 . }
46-900 .
46-901 .
46-902 . if (A eq B)
46-903 . {
46-904 . A = B + C;
46-905 . D = E + F;
46-906 . }
46-907 .
46-908 . A = B+C;
46-909 . A = B/C;
46-910 . A = B*C;
46-911 . A = B*C;
46-912 .
46-913 . if (A le B)
46-914 . {
46-915 . A = B + C;
46-916 . D = E + F;
46-917 . }
46-918 .
46-919 . A = B+C;
46-920 . A = B-C;
46-921 .
46-922 . if (A le B)
46-923 . {
46-924 . A = B + C;
46-925 . D = E + F;
46-926 . }
46-927 .
46-928 . A = B*C;
46-929 . A = B/C;
46-930 . A = B+C;
46-931 . A = B/C;
46-932 . A = B-C;
46-933 .
46-934 . if (A < B)
46-935 . {
46-936 . A = B + C;
46-937 . D = E + F;
46-938 . }
46-939 .
46-940 .
46-941 . if (A < B)
46-942 . {
46-943 . A = B + C;
46-944 . D = E + F;
46-945 . }
46-946 .
46-947 . /* LE SV TOC-2474 this is a pwr-04.6.30 req to enable*/
46-948 . A = B-C;
46-949 . A = B/C;
46-950 .
46-951 . if (A < = B)
46-952 . {
46-953 . A = B + C;
46-954 . D = E + F;
46-955 . }
46-956 .
46-957 . A = B/C;
46-958 . A = B-C;
46-959 . A = B+C;
46-960 . A = B/C;
46-961 . A = (long)B + C;
46-962 . A = B+C;
46-963 . A = 0x0008;
46-964 . A = B-C;
46-965 .
46-966 . switch (pwr stuff)
46-967 . {
46-968 . case one:
46-969 . {
46-970 . run_this;
46-971 . // missing break
46-972 . }
46-973 . case two:
46-974 . {
46-975 . run_this;
46-976 . break;
46-977 . }
46-978 . default:
46-979 . {
46-980 . SwError;
46-981 . }
46-982 . }
46-983 .
46-984 . A = B/C;
46-985 . A = B-C;
46-986 . A = B-C;
46-987 . A = B+C;
46-988 . A = B*C;
46-989 . rcv_buffer = (U16 *) alloc(size+1);
46-990 . A = B+C;
46-991 . A = B+C;
46-992 . A = B/C;
46-993 . A = B+C;
46-994 . A = 0x0007;
46-995 .
46-996 . switch (pwr stuff)
46-997 . {
46-998 . case one:
46-999 . {
46-1000 . run_this;
46-1001 . break;
46-1002 . }
46-1003 . case two:
46-1004 . {
46-1005 . run_this;
46-1006 . break;
46-1007 . }
46-1008 . default:
46-1009 . {
46-1010 . SwError;
46-1011 . }
46-1012 . }
46-1013 .
46-1014 .
46-1015 . if (A == B)
46-1016 . {
46-1017 . A = B + C;
46-1018 . D = E + F;
46-1019 . }
46-1020 .
46-1021 .
46-1022 . if (A < = B)
46-1023 . {
46-1024 . A = B + C;
46-1025 . D = E + F;
46-1026 . }
46-1027 .
46-1028 . A = B/C;
46-1029 .
46-1030 . if (A eq B)
46-1031 . {
46-1032 . A = B + C;
46-1033 . D = E + F;
46-1034 . }
46-1035 .
46-1036 . A = B+C;
46-1037 .
46-1038 . if (A > = B)
46-1039 . {
46-1040 . A = B + C;
46-1041 . D = E + F;
46-1042 . }
46-1043 .
46-1044 . A = B-C;
46-1045 .
46-1046 . if (A == B)
46-1047 . {
46-1048 . A = B + C;
46-1049 . D = E + F;
46-1050 . }
46-1051 .
46-1052 . A = B-C;
46-1053 . // (P) this is really improtant
46-1054 . A = B*C;
46-1055 .
46-1056 . if (A < B)
46-1057 . {
46-1058 . A = B + C;
46-1059 . D = E + F;
46-1060 . }
46-1061 .
46-1062 . A = B+C;
46-1063 . A = B*C;
46-1064 .
46-1065 . if (A > = B)
46-1066 . {
46-1067 . A = B + C;
46-1068 . D = E + F;
46-1069 . }
46-1070 .
46-1071 .
46-1072 . if (A gt B)
46-1073 . {
46-1074 . A = B + C;
46-1075 . D = E + F;
46-1076 . }
46-1077 .
46-1078 . A = B+C;
46-1079 .
46-1080 . if (A != B)
46-1081 . {
46-1082 . A = B + C;
46-1083 . D = E + F;
46-1084 . }
46-1085 .
46-1086 .
46-1087 . if (A eq B)
46-1088 . {
46-1089 . A = B + C;
46-1090 . D = E + F;
46-1091 . }
46-1092 .
46-1093 .
46-1094 . if (A > = B)
46-1095 . {
46-1096 . A = B + C;
46-1097 . D = E + F;
46-1098 . }
46-1099 .
46-1100 .
46-1101 . if (A > B)
46-1102 . {
46-1103 . A = B + C;
46-1104 . D = E + F;
46-1105 . }
46-1106 .
46-1107 . A = B/C;
46-1108 .
46-1109 . if (A ne B)
46-1110 . {
46-1111 . A = B + C;
46-1112 . D = E + F;
46-1113 . }
46-1114 .
46-1115 . A = B+C;
46-1116 . FreePtr = HmiStringPtr;
46-1117 . A = B+C;
46-1118 . /* LE SV TOC-2475 this is a pwr-04.6.73 req to inhibit*/
46-1119 . A = B+C;
46-1120 . // TBD - what do I do now
46-1121 .
46-1122 . if (A eq B)
46-1123 . {
46-1124 . A = B + C;
46-1125 . D = E + F;
46-1126 . }
46-1127 .
46-1128 . A = B+C;
46-1129 . A = B-C;
46-1130 . A = B*C;
46-1131 . A = B+C;
46-1132 . // max LOC 78
46-1133 .
46-1134 . }
46-1135 .
46-1136 .
46-1137 . /*
46-1138 . -----------------------------------------------------------------------------
46-1139 . --| NAME: pwr.4.7
46-1140 . --|
46-1141 . --| ABSTRACT:
46-1142 . --| This function does pwr stuff.
46-1143 . --|
46-1144 . --| RETURNS:
46-1145 . --| NONE.
46-1146 . --|
46-1147 . ----------------------------------------------------------------------------
46-1148 . */
46-1149 . static void pwr.4.7(void)
46-1150 . {
46-1151 .
46-1152 . if (A != B)
46-1153 . {
46-1154 . A = B + C;
46-1155 . D = E + F;
46-1156 . }
46-1157 .
46-1158 . A = B+C;
46-1159 . A = B+C;
46-1160 . A = B*C;
46-1161 . A = B+C;
46-1162 . A = B-C;
46-1163 . A = B+C;
46-1164 .
46-1165 . if (A == B)
46-1166 . {
46-1167 . A = B + C;
46-1168 . D = E + F;
46-1169 . }
46-1170 .
46-1171 . A = B+C;
46-1172 .
46-1173 . if (A ge B)
46-1174 . {
46-1175 . A = B + C;
46-1176 . D = E + F;
46-1177 . }
46-1178 .
46-1179 .
46-1180 . if (veg)
46-1181 . // missing curly brace
46-1182 . variable = orange;
46-1183 .
46-1184 .
46-1185 . if (A le B)
46-1186 . {
46-1187 . A = B + C;
46-1188 . D = E + F;
46-1189 . }
46-1190 .
46-1191 .
46-1192 . if (A eq B)
46-1193 . {
46-1194 . A = B + C;
46-1195 . D = E + F;
46-1196 . }
46-1197 .
46-1198 .
46-1199 . if (A > B)
46-1200 . {
46-1201 . A = B + C;
46-1202 . D = E + F;
46-1203 . }
46-1204 .
46-1205 . A = B/C;
46-1206 . A = B/C;
46-1207 . A = B+C;
46-1208 . A = B/C;
46-1209 . A = B+C;
46-1210 . A = B*C;
46-1211 . A = B/C;
46-1212 . A = B+C;
46-1213 .
46-1214 . if (A != B)
46-1215 . {
46-1216 . A = B + C;
46-1217 . D = E + F;
46-1218 . }
46-1219 .
46-1220 . A = B*C;
46-1221 . A = B-C;
46-1222 . A = B-C;
46-1223 .
46-1224 . switch (pwr stuff)
46-1225 . {
46-1226 . case one:
46-1227 . {
46-1228 . run_this;
46-1229 . break;
46-1230 . }
46-1231 . case two:
46-1232 . {
46-1233 . run_this;
46-1234 . break;
46-1235 . }
46-1236 . default:
46-1237 . {
46-1238 . SwError;
46-1239 . }
46-1240 . }
46-1241 .
46-1242 . A = B/C;
46-1243 . A = B-C;
46-1244 .
46-1245 . if (A < = B)
46-1246 . {
46-1247 . A = B + C;
46-1248 . D = E + F;
46-1249 . }
46-1250 .
46-1251 . A = B+C;
46-1252 . // max LOC 30
46-1253 .
46-1254 . }
46-1255 .
46-1256 .
46-1257 . /*
46-1258 . -----------------------------------------------------------------------------
46-1259 . --| NAME: pwr.4.8
46-1260 . --|
46-1261 . --| ABSTRACT:
46-1262 . --| This function does pwr stuff.
46-1263 . --|
46-1264 . --| RETURNS:
46-1265 . --| NONE.
46-1266 . --|
46-1267 . ----------------------------------------------------------------------------
46-1268 . */
46-1269 . static void pwr.4.8(void)
46-1270 . {
46-1271 .
46-1272 . switch (pwr stuff)
46-1273 . {
46-1274 . case one:
46-1275 . {
46-1276 . run_this;
46-1277 . break;
46-1278 . }
46-1279 . case two:
46-1280 . {
46-1281 . run_this;
46-1282 . break;
46-1283 . }
46-1284 . default:
46-1285 . {
46-1286 . // missing error call
46-1287 . }
46-1288 . }
46-1289 .
46-1290 . A = B/C;
46-1291 . A = B*C;
46-1292 . A = B-C;
46-1293 .
46-1294 . if (A ge B)
46-1295 . {
46-1296 . A = B + C;
46-1297 . D = E + F;
46-1298 . }
46-1299 .
46-1300 . A = B+C;
46-1301 .
46-1302 . if (A > = B)
46-1303 . {
46-1304 . A = B + C;
46-1305 . D = E + F;
46-1306 . }
46-1307 .
46-1308 . /* LE SV TOC-2476 this is a pwr-04.8.7 req to audit*/
46-1309 . A = B+C;
46-1310 .
46-1311 . if (A > = B)
46-1312 . {
46-1313 . A = B + C;
46-1314 . D = E + F;
46-1315 . }
46-1316 .
46-1317 .
46-1318 . if (A < B)
46-1319 . {
46-1320 . A = B + C;
46-1321 . D = E + F;
46-1322 . }
46-1323 .
46-1324 . A = B+C;
46-1325 . A = B*C;
46-1326 . // ??? go see ws
46-1327 . A = B/C;
46-1328 . A = B/C;
46-1329 . A = B/C;
46-1330 . A = B+C;
46-1331 . A = B+C;
46-1332 . A = B-C;
46-1333 . A = B*C;
46-1334 . A = B+C;
46-1335 . A = B-C;
46-1336 . A = B+C;
46-1337 . A = B/C;
46-1338 .
46-1339 . switch (pwr stuff)
46-1340 . {
46-1341 . case one:
46-1342 . {
46-1343 . run_this;
46-1344 . break;
46-1345 . }
46-1346 . case two:
46-1347 . {
46-1348 . run_this;
46-1349 . break;
46-1350 . }
46-1351 . default:
46-1352 . {
46-1353 . SwError;
46-1354 . }
46-1355 . }
46-1356 .
46-1357 . A = B+C;
46-1358 .
46-1359 . if (A < = B)
46-1360 . {
46-1361 . A = B + C;
46-1362 . D = E + F;
46-1363 . }
46-1364 .
46-1365 .
46-1366 . switch (pwr stuff)
46-1367 . {
46-1368 . case one:
46-1369 . {
46-1370 . switch (nested)
46-1371 . {
46-1372 . case:
46-1373 . X = Y + Z;
46-1374 . case:
46-1375 . X = Y + Z;
46-1376 . default:
46-1377 . SwError;
46-1378 . }
46-1379 . }
46-1380 . case two:
46-1381 . {
46-1382 . run_this;
46-1383 . break;
46-1384 . }
46-1385 . default:
46-1386 . {
46-1387 . SwError;
46-1388 . }
46-1389 . }
46-1390 .
46-1391 . A = B+C;
46-1392 . A = B*C;
46-1393 .
46-1394 . if (A == B)
46-1395 . {
46-1396 . A = B + C;
46-1397 . D = E + F;
46-1398 . }
46-1399 .
46-1400 .
46-1401 . if (A != B)
46-1402 . {
46-1403 . A = B + C;
46-1404 . D = E + F;
46-1405 . }
46-1406 .
46-1407 . A = B/C;
46-1408 . A = (long)B + C;
46-1409 . A = B+C;
46-1410 .
46-1411 . if (A le B)
46-1412 . {
46-1413 . A = B + C;
46-1414 . D = E + F;
46-1415 . }
46-1416 .
46-1417 .
46-1418 . if (A > B)
46-1419 . {
46-1420 . A = B + C;
46-1421 . D = E + F;
46-1422 . }
46-1423 .
46-1424 . A = B/C;
46-1425 .
46-1426 . if (A == B)
46-1427 . {
46-1428 . A = B + C;
46-1429 . D = E + F;
46-1430 . }
46-1431 .
46-1432 .
46-1433 . if (A gt B)
46-1434 . {
46-1435 . A = B + C;
46-1436 . D = E + F;
46-1437 . }
46-1438 .
46-1439 . A = B+C;
46-1440 . A = B/C;
46-1441 . A = B/C;
46-1442 . A = B/C;
46-1443 . A = B/C;
46-1444 . A = B+C;
46-1445 .
46-1446 . if (A < = B)
46-1447 . {
46-1448 . A = B + C;
46-1449 . D = E + F;
46-1450 . }
46-1451 .
46-1452 . A = B-C;
46-1453 . A = B+C;
46-1454 . A = B-C;
46-1455 . A = B+C;
46-1456 . A = B+C;
46-1457 . A = B*C;
46-1458 . A = B-C;
46-1459 .
46-1460 . switch (pwr stuff)
46-1461 . {
46-1462 . case one:
46-1463 . {
46-1464 . run_this;
46-1465 . break;
46-1466 . }
46-1467 . case two:
46-1468 . {
46-1469 . run_this;
46-1470 . break;
46-1471 . }
46-1472 . default:
46-1473 . {
46-1474 . SwError;
46-1475 . }
46-1476 . }
46-1477 .
46-1478 .
46-1479 . if (A gt B)
46-1480 . {
46-1481 . A = B + C;
46-1482 . D = E + F;
46-1483 . }
46-1484 .
46-1485 .
46-1486 . if (A eq B)
46-1487 . {
46-1488 . A = B + C;
46-1489 . D = E + F;
46-1490 . }
46-1491 .
46-1492 .
46-1493 . if (A le B)
46-1494 . {
46-1495 . A = B + C;
46-1496 . D = E + F;
46-1497 . }
46-1498 .
46-1499 . A = B+C;
46-1500 . A = B*C;
46-1501 . A = B-C;
46-1502 . A = B-C;
46-1503 . A = B*C;
46-1504 .
46-1505 . if (A > B)
46-1506 . {
46-1507 . A = B + C;
46-1508 . D = E + F;
46-1509 . }
46-1510 .
46-1511 . A = B/C;
46-1512 .
46-1513 . if (A eq B)
46-1514 . {
46-1515 . A = B + C;
46-1516 . D = E + F;
46-1517 . }
46-1518 .
46-1519 . // max LOC 62
46-1520 .
46-1521 . }
46-1522 .
46-1523 .
46-1524 . /*
46-1525 . -----------------------------------------------------------------------------
46-1526 . --| NAME: pwr.4.9
46-1527 . --|
46-1528 . --| ABSTRACT:
46-1529 . --| This function does pwr stuff.
46-1530 . --|
46-1531 . --| RETURNS:
46-1532 . --| NONE.
46-1533 . --|
46-1534 . ----------------------------------------------------------------------------
46-1535 . */
46-1536 . static void pwr.4.9(void)
46-1537 . {
46-1538 . A = B/C;
46-1539 . A = B+C;
46-1540 . A = B+C;
46-1541 . A = B*C;
46-1542 . A = B/C;
46-1543 . A = B/C;
46-1544 . A = B+C;
46-1545 . A = 0x0001;
46-1546 . A = B+C;
46-1547 .
46-1548 . if (A le B)
46-1549 . {
46-1550 . A = B + C;
46-1551 . D = E + F;
46-1552 . }
46-1553 .
46-1554 . A = B*C;
46-1555 . A = B+C;
46-1556 . A = B*C;
46-1557 . /* LE SV TOC-2477 this is a pwr-04.9.13 req to recover*/
46-1558 . A = B-C;
46-1559 .
46-1560 . if (A ge B)
46-1561 . {
46-1562 . A = B + C;
46-1563 . D = E + F;
46-1564 . }
46-1565 .
46-1566 . A = B/C;
46-1567 . A = 0x0006;
46-1568 . A = B*C;
46-1569 . A = B+C;
46-1570 . A = B*C;
46-1571 . A = B+C;
46-1572 .
46-1573 . if (A > B)
46-1574 . {
46-1575 . A = B + C;
46-1576 . D = E + F;
46-1577 . }
46-1578 .
46-1579 . A = B-C;
46-1580 . A = B-C;
46-1581 . A = B*C;
46-1582 . A = B/C;
46-1583 . A = B-C;
46-1584 . A = B/C;
46-1585 . A = B-C;
46-1586 . A = B-C;
46-1587 .
46-1588 . if (A != B)
46-1589 . {
46-1590 . A = B + C;
46-1591 . D = E + F;
46-1592 . }
46-1593 .
46-1594 .
46-1595 . if (A lt B)
46-1596 . {
46-1597 . A = B + C;
46-1598 . D = E + F;
46-1599 . }
46-1600 .
46-1601 . /* LE SV TOC-2478 this is a pwr-04.9.31 req to call isr*/
46-1602 . A = B*C;
46-1603 .
46-1604 . if (A ne B)
46-1605 . {
46-1606 . A = B + C;
46-1607 . D = E + F;
46-1608 . }
46-1609 .
46-1610 .
46-1611 . if (A > B)
46-1612 . {
46-1613 . A = B + C;
46-1614 . D = E + F;
46-1615 . }
46-1616 .
46-1617 .
46-1618 . if (A > = B)
46-1619 . {
46-1620 . A = B + C;
46-1621 . D = E + F;
46-1622 . }
46-1623 .
46-1624 . A = B/C;
46-1625 . A = B*C;
46-1626 . A = B/C;
46-1627 . FreePtr = HmiStringPtr;
46-1628 . A = B*C;
46-1629 . A = B-C;
46-1630 . A = 0x0002;
46-1631 . A = B-C;
46-1632 . A = B-C;
46-1633 . A = B-C;
46-1634 .
46-1635 . if (A le B)
46-1636 . {
46-1637 . A = B + C;
46-1638 . D = E + F;
46-1639 . }
46-1640 .
46-1641 . A = B-C;
46-1642 . /* LE SV TOC-2479 this is a pwr-04.9.45 req to check pSOS*/
46-1643 . A = B+C;
46-1644 .
46-1645 . if (A > B)
46-1646 . {
46-1647 . A = B + C;
46-1648 . D = E + F;
46-1649 . }
46-1650 .
46-1651 . /* LE SV TOC-2480 this is a pwr-04.9.47 req to transform*/
46-1652 . A = B*C;
46-1653 .
46-1654 . if (A < = B)
46-1655 . {
46-1656 . A = B + C;
46-1657 . D = E + F;
46-1658 . }
46-1659 .
46-1660 . A = B+C;
46-1661 . A = B/C;
46-1662 .
46-1663 . if (A eq B)
46-1664 . {
46-1665 . A = B + C;
46-1666 . D = E + F;
46-1667 . }
46-1668 .
46-1669 . A = B-C;
46-1670 . A = B/C;
46-1671 . A = B-C;
46-1672 . A = B+C;
46-1673 . A = B+C;
46-1674 . A = B*C;
46-1675 . A = B/C;
46-1676 .
46-1677 . if (A < = B)
46-1678 . {
46-1679 . A = B + C;
46-1680 . D = E + F;
46-1681 . }
46-1682 .
46-1683 . A = B+C;
46-1684 . A = B*C;
46-1685 . A = B-C;
46-1686 .
46-1687 . if (A le B)
46-1688 . {
46-1689 . A = B + C;
46-1690 . D = E + F;
46-1691 . }
46-1692 .
46-1693 . A = B+C;
46-1694 . A = B-C;
46-1695 .
46-1696 . if (A ge B)
46-1697 . {
46-1698 . A = B + C;
46-1699 . D = E + F;
46-1700 . }
46-1701 .
46-1702 . A = B+C;
46-1703 . A = B*C;
46-1704 .
46-1705 . if (A le B)
46-1706 . {
46-1707 . A = B + C;
46-1708 . D = E + F;
46-1709 . }
46-1710 .
46-1711 .
46-1712 . switch (pwr stuff)
46-1713 . {
46-1714 . case one:
46-1715 . {
46-1716 . run_this;
46-1717 . break;
46-1718 . }
46-1719 . case two:
46-1720 . {
46-1721 . run_this;
46-1722 . break;
46-1723 . }
46-1724 . default:
46-1725 . {
46-1726 . SwError;
46-1727 . }
46-1728 . }
46-1729 .
46-1730 . /* LE SV TOC-2481 this is a pwr-04.9.71 req to audit*/
46-1731 . A = 0x0007;
46-1732 .
46-1733 . if (A < B)
46-1734 . {
46-1735 . A = B + C;
46-1736 . D = E + F;
46-1737 . }
46-1738 .
46-1739 . A = B-C;
46-1740 . A = B+C;
46-1741 .
46-1742 . if (A ge B)
46-1743 . {
46-1744 . A = B + C;
46-1745 . D = E + F;
46-1746 . }
46-1747 .
46-1748 .
46-1749 . if (A eq B)
46-1750 . {
46-1751 . A = B + C;
46-1752 . D = E + F;
46-1753 . }
46-1754 .
46-1755 . A = B+C;
46-1756 . A = B/C;
46-1757 . A = B+C;
46-1758 . A = B-C;
46-1759 .
46-1760 . switch (pwr stuff)
46-1761 . {
46-1762 . case one:
46-1763 . {
46-1764 . run_this;
46-1765 . break;
46-1766 . }
46-1767 . case two:
46-1768 . {
46-1769 . run_this;
46-1770 . break;
46-1771 . }
46-1772 . default:
46-1773 . {
46-1774 . SwError;
46-1775 . }
46-1776 . }
46-1777 .
46-1778 . A = B/C;
46-1779 .
46-1780 . switch (pwr stuff)
46-1781 . {
46-1782 . case one:
46-1783 . {
46-1784 . run_this;
46-1785 . break;
46-1786 . }
46-1787 . case two:
46-1788 . {
46-1789 . run_this;
46-1790 . break;
46-1791 . }
46-1792 . default:
46-1793 . {
46-1794 . SwError;
46-1795 . }
46-1796 . }
46-1797 .
46-1798 . A = B/C;
46-1799 . A = B+C;
46-1800 . A = B+C;
46-1801 . /* LE SV TOC-2482 this is a pwr-04.9.86 req to check unix*/
46-1802 .
46-1803 . if (A < = B)
46-1804 . {
46-1805 . A = B + C;
46-1806 . D = E + F;
46-1807 . }
46-1808 .
46-1809 . A = B+C;
46-1810 . A = 0x0002;
46-1811 . A = B+C;
46-1812 . A = B+C;
46-1813 . A = B-C;
46-1814 . A = B+C;
46-1815 . rcv_buffer = (U16 *) alloc(size+1);
46-1816 . A = B/C;
46-1817 .
46-1818 . if (A < = B)
46-1819 . {
46-1820 . A = B + C;
46-1821 . D = E + F;
46-1822 . }
46-1823 .
46-1824 . // max LOC 93
46-1825 .
46-1826 . }
46-1827 .
46-1828 .
46-1829 . /*
46-1830 . -----------------------------------------------------------------------------
46-1831 . --| NAME: pwr.4.10
46-1832 . --|
46-1833 . --| ABSTRACT:
46-1834 . --| This function does pwr stuff.
46-1835 . --|
46-1836 . --| RETURNS:
46-1837 . --| NONE.
46-1838 . --|
46-1839 . ----------------------------------------------------------------------------
46-1840 . */
46-1841 . static void pwr.4.10(void)
46-1842 . {
46-1843 . A = B-C;
46-1844 .
46-1845 . if (A lt B)
46-1846 . {
46-1847 . A = B + C;
46-1848 . D = E + F;
46-1849 . }
46-1850 .
46-1851 . A = B+C;
46-1852 . A = B*C;
46-1853 . A = B+C;
46-1854 . A = B*C;
46-1855 . A = B*C;
46-1856 . /* LE SV TOC-2483 this is a pwr-04.10.8 req to set Real Time Clock*/
46-1857 . A = B-C;
46-1858 . /* LE SV TOC-2484 this is a pwr-04.10.9 req to set Real Time Clock*/
46-1859 . A = B+C;
46-1860 .
46-1861 . if (A le B)
46-1862 . {
46-1863 . A = B + C;
46-1864 . D = E + F;
46-1865 . }
46-1866 .
46-1867 . A = B/C;
46-1868 . A = B/C;
46-1869 . A = B-C;
46-1870 . A = B*C;
46-1871 . A = B-C;
46-1872 . A = B*C;
46-1873 .
46-1874 . if (A != B)
46-1875 . {
46-1876 . A = B + C;
46-1877 . D = E + F;
46-1878 . }
46-1879 .
46-1880 . A = B+C;
46-1881 .
46-1882 . switch (pwr stuff)
46-1883 . {
46-1884 . case:
46-1885 . case:
46-1886 . // stacked case statements but only if there is a new line in between
46-1887 .
46-1888 . case:
46-1889 . case:
46-1890 . case:
46-1891 . {
46-1892 . run_this;
46-1893 . break;
46-1894 . }
46-1895 . default:
46-1896 . {
46-1897 . halt;
46-1898 . }
46-1899 . }
46-1900 .
46-1901 . A = B*C;
46-1902 . A = B-C;
46-1903 .
46-1904 . if (A gt B)
46-1905 . {
46-1906 . A = B + C;
46-1907 . D = E + F;
46-1908 . }
46-1909 .
46-1910 . // ??? go see ws
46-1911 . A = B*C;
46-1912 . /* LE SV TOC-2485 this is a pwr-04.10.23 req to check pSOS*/
46-1913 . A = B/C;
46-1914 . /* LE SV TOC-2486 this is a pwr-04.10.24 req to transform*/
46-1915 . A = B+C;
46-1916 . A = B/C;
46-1917 .
46-1918 . if (A le B)
46-1919 . {
46-1920 . A = B + C;
46-1921 . D = E + F;
46-1922 . }
46-1923 .
46-1924 . A = (long)B + C;
46-1925 . A = B*C;
46-1926 .
46-1927 . if (A == B)
46-1928 . {
46-1929 . A = B + C;
46-1930 . D = E + F;
46-1931 . }
46-1932 .
46-1933 . A = B*C;
46-1934 .
46-1935 . if (A ne B)
46-1936 . {
46-1937 . A = B + C;
46-1938 . D = E + F;
46-1939 . }
46-1940 .
46-1941 .
46-1942 . if (A != B)
46-1943 . {
46-1944 . A = B + C;
46-1945 . D = E + F;
46-1946 . }
46-1947 .
46-1948 .
46-1949 . if (A ne B)
46-1950 . {
46-1951 . A = B + C;
46-1952 . D = E + F;
46-1953 . }
46-1954 .
46-1955 . A = B-C;
46-1956 . A = B+C;
46-1957 .
46-1958 . if (A ge B)
46-1959 . {
46-1960 . A = B + C;
46-1961 . D = E + F;
46-1962 . }
46-1963 .
46-1964 . A = B/C;
46-1965 . A = B+C;
46-1966 . A = B/C;
46-1967 . A = B-C;
46-1968 . A = B-C;
46-1969 . A = B+C;
46-1970 . A = B-C;
46-1971 . A = B*C;
46-1972 . A = B*C;
46-1973 . A = B+C;
46-1974 .
46-1975 . if (A == B)
46-1976 . {
46-1977 . A = B + C;
46-1978 . D = E + F;
46-1979 . }
46-1980 .
46-1981 .
46-1982 . if (A ge B)
46-1983 . {
46-1984 . A = B + C;
46-1985 . D = E + F;
46-1986 . }
46-1987 .
46-1988 .
46-1989 . if (A > = B)
46-1990 . {
46-1991 . A = B + C;
46-1992 . D = E + F;
46-1993 . }
46-1994 .
46-1995 . /* LE SV TOC-2487 this is a pwr-04.10.49 req to inhibit*/
46-1996 . A = B*C;
46-1997 .
46-1998 . if (A != B)
46-1999 . {
46-2000 . A = B + C;
46-2001 . D = E + F;
46-2002 . }
46-2003 .
46-2004 .
46-2005 . if (A ge B)
46-2006 . {
46-2007 . A = B + C;
46-2008 . D = E + F;
46-2009 . }
46-2010 .
46-2011 . A = (float)B + C;
46-2012 . A = B/C;
46-2013 . A = B/C;
46-2014 . A = B/C;
46-2015 . A = B-C;
46-2016 .
46-2017 . /*
46-2018 . dead_block = C * D;
46-2019 . dead_block = E * F;
46-2020 . */
46-2021 .
46-2022 . A = B*C;
46-2023 . A = B-C;
46-2024 . A = B-C;
46-2025 . A = B/C;
46-2026 . A = B-C;
46-2027 . A = B-C;
46-2028 . A = B-C;
46-2029 . /* LE SV TOC-2488 this is a pwr-04.10.63 req to set RTC*/
46-2030 .
46-2031 . if (A eq B)
46-2032 . {
46-2033 . A = B + C;
46-2034 . D = E + F;
46-2035 . }
46-2036 .
46-2037 . // max LOC 63
46-2038 .
46-2039 . }
46-2040 .
46-2041 .
46-2042 . /*
46-2043 . -----------------------------------------------------------------------------
46-2044 . --| NAME: pwr.4.11
46-2045 . --|
46-2046 . --| ABSTRACT:
46-2047 . --| This function does pwr stuff.
46-2048 . --|
46-2049 . --| RETURNS:
46-2050 . --| NONE.
46-2051 . --|
46-2052 . ----------------------------------------------------------------------------
46-2053 . */
46-2054 . static void pwr.4.11(void)
46-2055 . {
46-2056 . A = B+C;
46-2057 .
46-2058 . switch (pwr stuff)
46-2059 . {
46-2060 . case one:
46-2061 . {
46-2062 . run_this;
46-2063 . break;
46-2064 . }
46-2065 . case two:
46-2066 . {
46-2067 . run_this;
46-2068 . break;
46-2069 . }
46-2070 . default:
46-2071 . {
46-2072 . SwError;
46-2073 . }
46-2074 . }
46-2075 .
46-2076 . A = B+C;
46-2077 . A = B*C;
46-2078 . /* LE SV TOC-2489 this is a pwr-04.11.5 req to transform*/
46-2079 . A = B*C;
46-2080 .
46-2081 . if (A eq B)
46-2082 . {
46-2083 . A = B + C;
46-2084 . D = E + F;
46-2085 . }
46-2086 .
46-2087 . A = B+C;
46-2088 . A = B+C;
46-2089 . A = B/C;
46-2090 . A = B*C;
46-2091 .
46-2092 . switch (pwr stuff)
46-2093 . {
46-2094 . case one:
46-2095 . {
46-2096 . run_this;
46-2097 . break;
46-2098 . }
46-2099 . case two:
46-2100 . {
46-2101 . run_this;
46-2102 . break;
46-2103 . }
46-2104 . default:
46-2105 . {
46-2106 . SwError;
46-2107 . }
46-2108 . }
46-2109 .
46-2110 . A = B+C;
46-2111 . A = B-C;
46-2112 . /* LE SV TOC-2490 this is a pwr-04.11.14 req to record*/
46-2113 .
46-2114 . if (A ge B)
46-2115 . {
46-2116 . A = B + C;
46-2117 . D = E + F;
46-2118 . }
46-2119 .
46-2120 .
46-2121 . if (A ge B)
46-2122 . {
46-2123 . A = B + C;
46-2124 . D = E + F;
46-2125 . }
46-2126 .
46-2127 . /* LE SV TOC-2491 this is a pwr-04.11.16 req to transform*/
46-2128 . A = B-C;
46-2129 . A = B*C;
46-2130 . A = B-C;
46-2131 .
46-2132 . switch (pwr stuff)
46-2133 . {
46-2134 . case one:
46-2135 . {
46-2136 . run_this;
46-2137 . break;
46-2138 . }
46-2139 . case two:
46-2140 . {
46-2141 . run_this;
46-2142 . break;
46-2143 . }
46-2144 . default:
46-2145 . {
46-2146 . // missing error call
46-2147 . }
46-2148 . }
46-2149 .
46-2150 .
46-2151 . if (A > B)
46-2152 . {
46-2153 . A = B + C;
46-2154 . D = E + F;
46-2155 . }
46-2156 .
46-2157 . A = B-C;
46-2158 . A = B-C;
46-2159 . A = B+C;
46-2160 .
46-2161 . if (A > = B)
46-2162 . {
46-2163 . A = B + C;
46-2164 . D = E + F;
46-2165 . }
46-2166 .
46-2167 . A = B+C;
46-2168 . A = B/C;
46-2169 . /* LE SV TOC-2492 this is a pwr-04.11.26 req to assign*/
46-2170 .
46-2171 . if (A le B)
46-2172 . {
46-2173 . A = B + C;
46-2174 . D = E + F;
46-2175 . }
46-2176 .
46-2177 . A = B+C;
46-2178 . A = B-C;
46-2179 . A = B-C;
46-2180 .
46-2181 . if (A ne B)
46-2182 . {
46-2183 . A = B + C;
46-2184 . D = E + F;
46-2185 . }
46-2186 .
46-2187 . A = B-C;
46-2188 .
46-2189 . if (A > B)
46-2190 . {
46-2191 . A = B + C;
46-2192 . D = E + F;
46-2193 . }
46-2194 .
46-2195 .
46-2196 . if (A lt B)
46-2197 . {
46-2198 . A = B + C;
46-2199 . D = E + F;
46-2200 . }
46-2201 .
46-2202 . A = B*C;
46-2203 . A = B+C;
46-2204 . /* LE SV TOC-2493 this is a pwr-04.11.36 req to fail*/
46-2205 . A = B+C;
46-2206 . A = B*C;
46-2207 . A = B-C;
46-2208 . A = B*C;
46-2209 . A = B-C;
46-2210 .
46-2211 . if (A lt B)
46-2212 . {
46-2213 . A = B + C;
46-2214 . D = E + F;
46-2215 . }
46-2216 .
46-2217 . A = B-C;
46-2218 .
46-2219 . if (A le B)
46-2220 . {
46-2221 . A = B + C;
46-2222 . D = E + F;
46-2223 . }
46-2224 .
46-2225 . A = B+C;
46-2226 . A = B/C;
46-2227 . // TBD - what do I do now
46-2228 . A = B-C;
46-2229 . A = B-C;
46-2230 . A = B-C;
46-2231 .
46-2232 . if (A ne B)
46-2233 . {
46-2234 . A = B + C;
46-2235 . D = E + F;
46-2236 . }
46-2237 .
46-2238 . A = B+C;
46-2239 .
46-2240 . if (A == B)
46-2241 . {
46-2242 . A = B + C;
46-2243 . D = E + F;
46-2244 . }
46-2245 .
46-2246 .
46-2247 . if (A ne B)
46-2248 . {
46-2249 . A = B + C;
46-2250 . D = E + F;
46-2251 . }
46-2252 .
46-2253 .
46-2254 . if (A le B)
46-2255 . {
46-2256 . A = B + C;
46-2257 . D = E + F;
46-2258 . }
46-2259 .
46-2260 . A = B-C;
46-2261 . A = B-C;
46-2262 . A = B-C;
46-2263 . A = B-C;
46-2264 . A = B-C;
46-2265 . A = B-C;
46-2266 . A = B-C;
46-2267 . A = B+C;
46-2268 . A = B+C;
46-2269 .
46-2270 . switch (pwr stuff)
46-2271 . {
46-2272 . case one:
46-2273 . {
46-2274 . run_this;
46-2275 . break;
46-2276 . }
46-2277 . case two:
46-2278 . {
46-2279 . run_this;
46-2280 . break;
46-2281 . }
46-2282 . default:
46-2283 . {
46-2284 . SwError;
46-2285 . }
46-2286 . }
46-2287 .
46-2288 .
46-2289 . if (A le B)
46-2290 . {
46-2291 . A = B + C;
46-2292 . D = E + F;
46-2293 . }
46-2294 .
46-2295 . /* LE SV TOC-2494 this is a pwr-04.11.65 req to translate*/
46-2296 . A = B+C;
46-2297 . A = B-C;
46-2298 . A = B-C;
46-2299 .
46-2300 . if (A ne B)
46-2301 . {
46-2302 . A = B + C;
46-2303 . D = E + F;
46-2304 . }
46-2305 .
46-2306 . A = B-C;
46-2307 . A = B-C;
46-2308 . // max LOC 70
46-2309 .
46-2310 . }
46-2311 .
46 46 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-04.c
47 47 Source: source/ft-app/ft-app-B1.1/pwr/pwr-05.c
47-0 . /*
47-1 . ----------------------------------------------------------------------------
47-2 . --| BEGIN PROLOGUE
47-3 . --|
47-4 . --| CLASSIFICATION: UNCLASSIFIED
47-5 . --|
47-6 . --| FILE NAME: pwr-05.c
47-7 . --|
47-8 . --| ABSTRACT:
47-9 . --| This file contains the 14 functions that do file pwr stuff.
47-10 . --|
47-11 . --| HISTORY:
47-12 . --| CCCQ_NAME:
47-13 . --| CCCQ_VER:
47-14 . --|
47-15 . --| END PROLOGUE
47-16 . ----------------------------------------------------------------------------
47-17 . */
47-18 .
47-19 . #define A;
47-20 . #include D;
47-21 . char D;
47-22 . #include B;
47-23 . #define D;
47-24 .
47-25 .
47-26 .
47-27 . /*
47-28 . -----------------------------------------------------------------------------
47-29 . --| NAME: pwr.5.1
47-30 . --|
47-31 . --| ABSTRACT:
47-32 . --| This function does pwr stuff.
47-33 . --|
47-34 . --| RETURNS:
47-35 . --| NONE.
47-36 . --|
47-37 . ----------------------------------------------------------------------------
47-38 . */
47-39 . static void pwr.5.1(void)
47-40 . {
47-41 . A = B-C;
47-42 .
47-43 . if (A eq B)
47-44 . {
47-45 . A = B + C;
47-46 . D = E + F;
47-47 . }
47-48 .
47-49 . A = B*C;
47-50 . A = B-C;
47-51 . A = B*C;
47-52 .
47-53 . if (A lt B)
47-54 . {
47-55 . A = B + C;
47-56 . D = E + F;
47-57 . }
47-58 .
47-59 .
47-60 . if (A lt B)
47-61 . {
47-62 . A = B + C;
47-63 . D = E + F;
47-64 . }
47-65 .
47-66 . A = B*C;
47-67 .
47-68 . switch (pwr stuff)
47-69 . {
47-70 . case one:
47-71 . {
47-72 . run_this;
47-73 . break;
47-74 . }
47-75 . case two:
47-76 . {
47-77 . run_this;
47-78 . break;
47-79 . }
47-80 . default:
47-81 . {
47-82 . SwError;
47-83 . }
47-84 . }
47-85 .
47-86 . A = B/C;
47-87 .
47-88 . if (A == B)
47-89 . {
47-90 . A = B + C;
47-91 . D = E + F;
47-92 . }
47-93 .
47-94 . A = B*C;
47-95 . A = B/C;
47-96 . // max LOC 13
47-97 .
47-98 . }
47-99 .
47-100 .
47-101 . /*
47-102 . -----------------------------------------------------------------------------
47-103 . --| NAME: pwr.5.2
47-104 . --|
47-105 . --| ABSTRACT:
47-106 . --| This function does pwr stuff.
47-107 . --|
47-108 . --| RETURNS:
47-109 . --| NONE.
47-110 . --|
47-111 . ----------------------------------------------------------------------------
47-112 . */
47-113 . static void pwr.5.2(void)
47-114 . {
47-115 . A = B-C;
47-116 . A = B/C;
47-117 . A = B*C;
47-118 .
47-119 . if (A lt B)
47-120 . {
47-121 . A = B + C;
47-122 . D = E + F;
47-123 . }
47-124 .
47-125 .
47-126 . if (A > B)
47-127 . {
47-128 . A = B + C;
47-129 . D = E + F;
47-130 . }
47-131 .
47-132 . A = B-C;
47-133 . A = B+C;
47-134 .
47-135 . if (A != B)
47-136 . {
47-137 . A = B + C;
47-138 . D = E + F;
47-139 . }
47-140 .
47-141 .
47-142 . if (A ge B)
47-143 . {
47-144 . A = B + C;
47-145 . D = E + F;
47-146 . }
47-147 .
47-148 .
47-149 . if (A ge B)
47-150 . {
47-151 . A = B + C;
47-152 . D = E + F;
47-153 . }
47-154 .
47-155 . A = B+C;
47-156 . /* LE SV TOC-2495 this is a pwr-05.2.12 req to transform*/
47-157 .
47-158 . switch (pwr stuff)
47-159 . {
47-160 . case one:
47-161 . {
47-162 . run_this;
47-163 . break;
47-164 . }
47-165 . case two:
47-166 . {
47-167 . run_this;
47-168 . break;
47-169 . }
47-170 . default:
47-171 . {
47-172 . SwError;
47-173 . }
47-174 . }
47-175 .
47-176 .
47-177 . if (A lt B)
47-178 . {
47-179 . A = B + C;
47-180 . D = E + F;
47-181 . }
47-182 .
47-183 . A = B-C;
47-184 .
47-185 . if (A le B)
47-186 . {
47-187 . A = B + C;
47-188 . D = E + F;
47-189 . }
47-190 .
47-191 . A = B+C;
47-192 . A = B*C;
47-193 . A = B*C;
47-194 . A = B+C;
47-195 . A = B+C;
47-196 . A = B/C;
47-197 . A = B-C;
47-198 .
47-199 . if (A lt B)
47-200 . {
47-201 . A = B + C;
47-202 . D = E + F;
47-203 . }
47-204 .
47-205 . A = B+C;
47-206 .
47-207 . if (A eq B)
47-208 . {
47-209 . A = B + C;
47-210 . D = E + F;
47-211 . }
47-212 .
47-213 . A = B+C;
47-214 . A = B+C;
47-215 .
47-216 . switch (pwr stuff)
47-217 . {
47-218 . case one:
47-219 . {
47-220 . run_this;
47-221 . break;
47-222 . }
47-223 . case two:
47-224 . {
47-225 . run_this;
47-226 . break;
47-227 . }
47-228 . // missing default
47-229 . }
47-230 .
47-231 .
47-232 . if (A != B)
47-233 . {
47-234 . A = B + C;
47-235 . D = E + F;
47-236 . }
47-237 .
47-238 . A = B-C;
47-239 .
47-240 . if (A gt B)
47-241 . {
47-242 . A = B + C;
47-243 . D = E + F;
47-244 . }
47-245 .
47-246 . A = B/C;
47-247 .
47-248 . if (A < = B)
47-249 . {
47-250 . A = B + C;
47-251 . D = E + F;
47-252 . }
47-253 .
47-254 . A = B/C;
47-255 .
47-256 . if (A == B)
47-257 . {
47-258 . A = B + C;
47-259 . D = E + F;
47-260 . }
47-261 .
47-262 . A = B*C;
47-263 . A = (int)B + C;
47-264 . A = B*C;
47-265 . /* LE SV TOC-2496 this is a pwr-05.2.37 req to inhibit*/
47-266 . A = B*C;
47-267 . A = B/C;
47-268 . A = 0x0009;
47-269 . do forever;
47-270 .
47-271 . if (A ge B)
47-272 . {
47-273 . A = B + C;
47-274 . D = E + F;
47-275 . }
47-276 .
47-277 . A = B+C;
47-278 .
47-279 . if (A != B)
47-280 . {
47-281 . A = B + C;
47-282 . D = E + F;
47-283 . }
47-284 .
47-285 .
47-286 . switch (pwr stuff)
47-287 . {
47-288 . case one:
47-289 . {
47-290 . run_this;
47-291 . break;
47-292 . }
47-293 . case two:
47-294 . {
47-295 . run_this;
47-296 . break;
47-297 . }
47-298 . default:
47-299 . {
47-300 . SwError;
47-301 . }
47-302 . }
47-303 .
47-304 . A = B-C;
47-305 .
47-306 . if (A < B)
47-307 . {
47-308 . A = B + C;
47-309 . D = E + F;
47-310 . }
47-311 .
47-312 . A = B*C;
47-313 . A = B*C;
47-314 . A = B*C;
47-315 . A = B*C;
47-316 .
47-317 . if (A eq B)
47-318 . {
47-319 . A = B + C;
47-320 . D = E + F;
47-321 . }
47-322 .
47-323 . A = B*C;
47-324 .
47-325 . if (A > = B)
47-326 . {
47-327 . A = B + C;
47-328 . D = E + F;
47-329 . }
47-330 .
47-331 .
47-332 . if (A > = B)
47-333 . {
47-334 . A = B + C;
47-335 . D = E + F;
47-336 . }
47-337 .
47-338 . A = B-C;
47-339 .
47-340 . if (A eq B)
47-341 . {
47-342 . A = B + C;
47-343 . D = E + F;
47-344 . }
47-345 .
47-346 . goto error;
47-347 . A = B+C;
47-348 . A = B+C;
47-349 . A = 0x0008;
47-350 . A = B-C;
47-351 .
47-352 . if (A > = B)
47-353 . {
47-354 . A = B + C;
47-355 . D = E + F;
47-356 . }
47-357 .
47-358 . A = B*C;
47-359 . A = B-C;
47-360 . A = B-C;
47-361 . A = B/C;
47-362 .
47-363 . if (A == B)
47-364 . {
47-365 . A = B + C;
47-366 . D = E + F;
47-367 . }
47-368 .
47-369 .
47-370 . if (A eq B)
47-371 . {
47-372 . A = B + C;
47-373 . D = E + F;
47-374 . }
47-375 .
47-376 . A = B-C;
47-377 . A = B*C;
47-378 .
47-379 . if (A > B)
47-380 . {
47-381 . A = B + C;
47-382 . D = E + F;
47-383 . }
47-384 .
47-385 .
47-386 . if (A < B)
47-387 . {
47-388 . A = B + C;
47-389 . D = E + F;
47-390 . }
47-391 .
47-392 . A = B-C;
47-393 . A = B-C;
47-394 . A = B+C;
47-395 .
47-396 . if (A ge B)
47-397 . {
47-398 . A = B + C;
47-399 . D = E + F;
47-400 . }
47-401 .
47-402 .
47-403 . if (A eq B)
47-404 . {
47-405 . A = B + C;
47-406 . D = E + F;
47-407 . }
47-408 .
47-409 . A = B*C;
47-410 .
47-411 . if (A ge B)
47-412 . {
47-413 . A = B + C;
47-414 . D = E + F;
47-415 . }
47-416 .
47-417 .
47-418 . if (A eq B)
47-419 . {
47-420 . A = B + C;
47-421 . D = E + F;
47-422 . }
47-423 .
47-424 . A = B+C;
47-425 . A = B-C;
47-426 .
47-427 . if (A > = B)
47-428 . {
47-429 . A = B + C;
47-430 . D = E + F;
47-431 . }
47-432 .
47-433 . // max LOC 79
47-434 .
47-435 . }
47-436 .
47-437 .
47-438 . /*
47-439 . -----------------------------------------------------------------------------
47-440 . --| NAME: pwr.5.3
47-441 . --|
47-442 . --| ABSTRACT:
47-443 . --| This function does pwr stuff.
47-444 . --|
47-445 . --| RETURNS:
47-446 . --| NONE.
47-447 . --|
47-448 . ----------------------------------------------------------------------------
47-449 . */
47-450 . static void pwr.5.3(void)
47-451 . {
47-452 .
47-453 . if (A > = B)
47-454 . {
47-455 . A = B + C;
47-456 . D = E + F;
47-457 . }
47-458 .
47-459 .
47-460 . if (A > = B)
47-461 . {
47-462 . A = B + C;
47-463 . D = E + F;
47-464 . }
47-465 .
47-466 . A = B*C;
47-467 . A = B-C;
47-468 . A = B/C;
47-469 .
47-470 . if (A eq B)
47-471 . {
47-472 . A = B + C;
47-473 . D = E + F;
47-474 . }
47-475 .
47-476 .
47-477 . if (A < = B)
47-478 . {
47-479 . A = B + C;
47-480 . D = E + F;
47-481 . }
47-482 .
47-483 .
47-484 . if (A ne B)
47-485 . {
47-486 . A = B + C;
47-487 . D = E + F;
47-488 . }
47-489 .
47-490 . A = B+C;
47-491 . A = B/C;
47-492 .
47-493 . if (A > = B)
47-494 . {
47-495 . A = B + C;
47-496 . D = E + F;
47-497 . }
47-498 .
47-499 .
47-500 . if (A ne B)
47-501 . {
47-502 . A = B + C;
47-503 . D = E + F;
47-504 . }
47-505 .
47-506 .
47-507 . if (A != B)
47-508 . {
47-509 . A = B + C;
47-510 . D = E + F;
47-511 . }
47-512 .
47-513 . A = B+C;
47-514 . /* LE SV TOC-2497 this is a pwr-05.3.15 req to inhibit*/
47-515 . A = B*C;
47-516 . /* LE SV TOC-2498 this is a pwr-05.3.16 req to check unix*/
47-517 . A = B*C;
47-518 .
47-519 . if (A ne B)
47-520 . {
47-521 . A = B + C;
47-522 . D = E + F;
47-523 . }
47-524 .
47-525 .
47-526 . if (A < = B)
47-527 . {
47-528 . A = B + C;
47-529 . D = E + F;
47-530 . }
47-531 .
47-532 .
47-533 . if (A ne B)
47-534 . {
47-535 . A = B + C;
47-536 . D = E + F;
47-537 . }
47-538 .
47-539 . A = B-C;
47-540 . A = B+C;
47-541 .
47-542 . if (A ne B)
47-543 . {
47-544 . A = B + C;
47-545 . D = E + F;
47-546 . }
47-547 .
47-548 . A = B/C;
47-549 . A = 0x0006;
47-550 .
47-551 . if (A ge B)
47-552 . {
47-553 . A = B + C;
47-554 . D = E + F;
47-555 . }
47-556 .
47-557 . A = B-C;
47-558 . A = B+C;
47-559 .
47-560 . if (A le B)
47-561 . {
47-562 . A = B + C;
47-563 . D = E + F;
47-564 . }
47-565 .
47-566 . /* LE SV TOC-2499 this is a pwr-05.3.28 req to increment*/
47-567 .
47-568 . if (A > = B)
47-569 . {
47-570 . A = B + C;
47-571 . D = E + F;
47-572 . }
47-573 .
47-574 .
47-575 . if (A != B)
47-576 . {
47-577 . A = B + C;
47-578 . D = E + F;
47-579 . }
47-580 .
47-581 . A = B*C;
47-582 .
47-583 . if (A > = B)
47-584 . {
47-585 . A = B + C;
47-586 . D = E + F;
47-587 . }
47-588 .
47-589 . A = B-C;
47-590 . A = B+C;
47-591 . A = B+C;
47-592 . A = B*C;
47-593 . A = B-C;
47-594 . A = B-C;
47-595 . A = B/C;
47-596 .
47-597 . if (A lt B)
47-598 . {
47-599 . A = B + C;
47-600 . D = E + F;
47-601 . }
47-602 .
47-603 .
47-604 . if (A le B)
47-605 . {
47-606 . A = B + C;
47-607 . D = E + F;
47-608 . }
47-609 .
47-610 . // max LOC 40
47-611 .
47-612 . }
47-613 .
47-614 .
47-615 . /*
47-616 . -----------------------------------------------------------------------------
47-617 . --| NAME: pwr.5.4
47-618 . --|
47-619 . --| ABSTRACT:
47-620 . --| This function does pwr stuff.
47-621 . --|
47-622 . --| RETURNS:
47-623 . --| NONE.
47-624 . --|
47-625 . ----------------------------------------------------------------------------
47-626 . */
47-627 . static void pwr.5.4(void)
47-628 . {
47-629 . A = B+C;
47-630 . A = B*C;
47-631 . A = (long)B + C;
47-632 . A = B/C;
47-633 . A = B-C;
47-634 . A = B+C;
47-635 .
47-636 . if (A eq B)
47-637 . {
47-638 . A = B + C;
47-639 . D = E + F;
47-640 . }
47-641 .
47-642 . A = B/C;
47-643 . /* LE SV TOC-2500 this is a pwr-05.4.8 req to increment*/
47-644 . A = B/C;
47-645 . A = B/C;
47-646 .
47-647 . if (A ne B)
47-648 . {
47-649 . A = B + C;
47-650 . D = E + F;
47-651 . }
47-652 .
47-653 . A = B+C;
47-654 . A = 0x0001;
47-655 . A = B*C;
47-656 . /* LE SV TOC-2501 this is a pwr-05.4.13 req to detect error*/
47-657 . A = B-C;
47-658 . A = B*C;
47-659 . A = B-C;
47-660 . A = B-C;
47-661 . A = B+C;
47-662 . A = B+C;
47-663 . A = B/C;
47-664 . A = B/C;
47-665 . A = B-C;
47-666 .
47-667 . switch (pwr stuff)
47-668 . {
47-669 . case one:
47-670 . {
47-671 . run_this;
47-672 . break;
47-673 . }
47-674 . case two:
47-675 . {
47-676 . run_this;
47-677 . break;
47-678 . }
47-679 . default:
47-680 . {
47-681 . SwError;
47-682 . }
47-683 . }
47-684 .
47-685 . A = 0x0009;
47-686 . A = B+C;
47-687 . A = B*C;
47-688 . A = B/C;
47-689 . A = B+C;
47-690 . A = B*C;
47-691 .
47-692 . if (A < B)
47-693 . {
47-694 . A = B + C;
47-695 . D = E + F;
47-696 . }
47-697 .
47-698 . A = B/C;
47-699 . A = B-C;
47-700 .
47-701 . switch (pwr stuff)
47-702 . {
47-703 . case one:
47-704 . {
47-705 . run_this;
47-706 . // missing break
47-707 . }
47-708 . case two:
47-709 . {
47-710 . run_this;
47-711 . break;
47-712 . }
47-713 . default:
47-714 . {
47-715 . SwError;
47-716 . }
47-717 . }
47-718 .
47-719 .
47-720 . if (A gt B)
47-721 . {
47-722 . A = B + C;
47-723 . D = E + F;
47-724 . }
47-725 .
47-726 . A = B/C;
47-727 . A = B-C;
47-728 . A = B+C;
47-729 . A = B/C;
47-730 . /* LE SV TOC-2502 this is a pwr-05.4.36 req to set RTC*/
47-731 . A = B*C;
47-732 . A = B/C;
47-733 .
47-734 . if (A le B)
47-735 . {
47-736 . A = B + C;
47-737 . D = E + F;
47-738 . }
47-739 .
47-740 . A = B*C;
47-741 . A = B/C;
47-742 . A = B+C;
47-743 . A = B*C;
47-744 . // max LOC 42
47-745 .
47-746 . }
47-747 .
47-748 .
47-749 . /*
47-750 . -----------------------------------------------------------------------------
47-751 . --| NAME: pwr.5.5
47-752 . --|
47-753 . --| ABSTRACT:
47-754 . --| This function does pwr stuff.
47-755 . --|
47-756 . --| RETURNS:
47-757 . --| NONE.
47-758 . --|
47-759 . ----------------------------------------------------------------------------
47-760 . */
47-761 . static void pwr.5.5(void)
47-762 . {
47-763 . /* LE SV TOC-2503 this is a pwr-05.5.1 req to fail*/
47-764 . A = B+C;
47-765 .
47-766 . if (A == B)
47-767 . {
47-768 . A = B + C;
47-769 . D = E + F;
47-770 . }
47-771 .
47-772 . /* LE SV TOC-2504 this is a pwr-05.5.3 req to check pSOS*/
47-773 .
47-774 . if (A == B)
47-775 . {
47-776 . A = B + C;
47-777 . D = E + F;
47-778 . }
47-779 .
47-780 . A = B*C;
47-781 .
47-782 . if (A > B)
47-783 . {
47-784 . A = B + C;
47-785 . D = E + F;
47-786 . }
47-787 .
47-788 . A = B*C;
47-789 . A = B/C;
47-790 . A = B/C;
47-791 . A = B-C;
47-792 . A = B-C;
47-793 . A = B+C;
47-794 .
47-795 . switch (pwr stuff)
47-796 . {
47-797 . case one:
47-798 . {
47-799 . run_this;
47-800 . break;
47-801 . }
47-802 . case two:
47-803 . {
47-804 . run_this;
47-805 . break;
47-806 . }
47-807 . default:
47-808 . {
47-809 . // missing error call
47-810 . }
47-811 . }
47-812 .
47-813 . A = B+C;
47-814 . A = B+C;
47-815 . A = B+C;
47-816 . A = B/C;
47-817 . A = B-C;
47-818 .
47-819 . if (A ge B)
47-820 . {
47-821 . A = B + C;
47-822 . D = E + F;
47-823 . }
47-824 .
47-825 .
47-826 . if (A lt B)
47-827 . {
47-828 . A = B + C;
47-829 . D = E + F;
47-830 . }
47-831 .
47-832 . A = B+C;
47-833 .
47-834 . if (A gt B)
47-835 . {
47-836 . A = B + C;
47-837 . D = E + F;
47-838 . }
47-839 .
47-840 . A = B+C;
47-841 . A = B-C;
47-842 . A = B+C;
47-843 .
47-844 . if (A < = B)
47-845 . {
47-846 . A = B + C;
47-847 . D = E + F;
47-848 . }
47-849 .
47-850 . A = B-C;
47-851 .
47-852 . if (A > = B)
47-853 . {
47-854 . A = B + C;
47-855 . D = E + F;
47-856 . }
47-857 .
47-858 . /* LE SV TOC-2505 this is a pwr-05.5.27 req to halt*/
47-859 . A = B+C;
47-860 . A = B/C;
47-861 . A = B/C;
47-862 . A = B*C;
47-863 . A = B+C;
47-864 . rcv_buffer = (U16 *) alloc(size+1);
47-865 .
47-866 . if (A lt B)
47-867 . {
47-868 . A = B + C;
47-869 . D = E + F;
47-870 . }
47-871 .
47-872 .
47-873 . if (A > = B)
47-874 . {
47-875 . A = B + C;
47-876 . D = E + F;
47-877 . }
47-878 .
47-879 . A = B/C;
47-880 . /* dead_code = A * B; */
47-881 .
47-882 . if (A gt B)
47-883 . {
47-884 . A = B + C;
47-885 . D = E + F;
47-886 . }
47-887 .
47-888 .
47-889 . switch (pwr stuff)
47-890 . {
47-891 . case one:
47-892 . {
47-893 . run_this;
47-894 . break;
47-895 . }
47-896 . case two:
47-897 . {
47-898 . run_this;
47-899 . break;
47-900 . }
47-901 . default:
47-902 . {
47-903 . SwError;
47-904 . }
47-905 . }
47-906 .
47-907 . A = B*C;
47-908 . A = B+C;
47-909 . A = B*C;
47-910 . A = B-C;
47-911 .
47-912 . if (A eq B)
47-913 . {
47-914 . A = B + C;
47-915 . D = E + F;
47-916 . }
47-917 .
47-918 . A = B-C;
47-919 . A = B*C;
47-920 . A = B*C;
47-921 . A = B/C;
47-922 . /* LE SV TOC-2506 this is a pwr-05.5.46 req to check unix*/
47-923 . A = B/C;
47-924 . A = B*C;
47-925 . A = B-C;
47-926 . A = B-C;
47-927 . A = B+C;
47-928 . // max LOC 50
47-929 .
47-930 . }
47-931 .
47-932 .
47-933 . /*
47-934 . -----------------------------------------------------------------------------
47-935 . --| NAME: pwr.5.6
47-936 . --|
47-937 . --| ABSTRACT:
47-938 . --| This function does pwr stuff.
47-939 . --|
47-940 . --| RETURNS:
47-941 . --| NONE.
47-942 . --|
47-943 . ----------------------------------------------------------------------------
47-944 . */
47-945 . static void pwr.5.6(void)
47-946 . {
47-947 . A = B+C;
47-948 .
47-949 . if (A le B)
47-950 . {
47-951 . A = B + C;
47-952 . D = E + F;
47-953 . }
47-954 .
47-955 . A = B+C;
47-956 . A = B*C;
47-957 . A = B-C;
47-958 .
47-959 . if (A == B)
47-960 . {
47-961 . A = B + C;
47-962 . D = E + F;
47-963 . }
47-964 .
47-965 .
47-966 . if (A != B)
47-967 . {
47-968 . A = B + C;
47-969 . D = E + F;
47-970 . }
47-971 .
47-972 .
47-973 . if (A gt B)
47-974 . {
47-975 . A = B + C;
47-976 . D = E + F;
47-977 . }
47-978 .
47-979 . A = B/C;
47-980 . A = B*C;
47-981 . A = B+C;
47-982 . A = B-C;
47-983 . A = B/C;
47-984 .
47-985 . if (A gt B)
47-986 . {
47-987 . A = B + C;
47-988 . D = E + F;
47-989 . }
47-990 .
47-991 . A = B-C;
47-992 . A = B*C;
47-993 .
47-994 . if (A != B)
47-995 . {
47-996 . A = B + C;
47-997 . D = E + F;
47-998 . }
47-999 .
47-1000 . A = B+C;
47-1001 . A = B/C;
47-1002 . // ??? go see ws
47-1003 . A = B*C;
47-1004 . A = B/C;
47-1005 . /* LE SV TOC-2507 this is a pwr-05.6.22 req to translate*/
47-1006 .
47-1007 . if (A ge B)
47-1008 . {
47-1009 . A = B + C;
47-1010 . D = E + F;
47-1011 . }
47-1012 .
47-1013 . A = B+C;
47-1014 . A = B/C;
47-1015 . A = B+C;
47-1016 . A = B/C;
47-1017 . A = B*C;
47-1018 . A = B+C;
47-1019 . A = B-C;
47-1020 .
47-1021 . if (A lt B)
47-1022 . {
47-1023 . A = B + C;
47-1024 . D = E + F;
47-1025 . }
47-1026 .
47-1027 . A = B+C;
47-1028 . A = B+C;
47-1029 .
47-1030 . if (A le B)
47-1031 . {
47-1032 . A = B + C;
47-1033 . D = E + F;
47-1034 . }
47-1035 .
47-1036 .
47-1037 . switch (pwr stuff)
47-1038 . {
47-1039 . case one:
47-1040 . {
47-1041 . run_this;
47-1042 . break;
47-1043 . }
47-1044 . case two:
47-1045 . {
47-1046 . run_this;
47-1047 . break;
47-1048 . }
47-1049 . default:
47-1050 . {
47-1051 . SwError;
47-1052 . }
47-1053 . }
47-1054 .
47-1055 . A = B*C;
47-1056 . A = B-C;
47-1057 .
47-1058 . if (A < B)
47-1059 . {
47-1060 . A = B + C;
47-1061 . D = E + F;
47-1062 . }
47-1063 .
47-1064 . A = B/C;
47-1065 . A = B*C;
47-1066 .
47-1067 . if (A != B)
47-1068 . {
47-1069 . A = B + C;
47-1070 . D = E + F;
47-1071 . }
47-1072 .
47-1073 .
47-1074 . if (A < B)
47-1075 . {
47-1076 . A = B + C;
47-1077 . D = E + F;
47-1078 . }
47-1079 .
47-1080 .
47-1081 . if (A eq B)
47-1082 . {
47-1083 . A = B + C;
47-1084 . D = E + F;
47-1085 . }
47-1086 .
47-1087 . A = B+C;
47-1088 .
47-1089 . if (A ge B)
47-1090 . {
47-1091 . A = B + C;
47-1092 . D = E + F;
47-1093 . }
47-1094 .
47-1095 . A = B*C;
47-1096 .
47-1097 . if (A != B)
47-1098 . {
47-1099 . A = B + C;
47-1100 . D = E + F;
47-1101 . }
47-1102 .
47-1103 .
47-1104 . if (A gt B)
47-1105 . {
47-1106 . A = B + C;
47-1107 . D = E + F;
47-1108 . }
47-1109 .
47-1110 . A = B/C;
47-1111 . A = B/C;
47-1112 .
47-1113 . if (A == B)
47-1114 . {
47-1115 . A = B + C;
47-1116 . D = E + F;
47-1117 . }
47-1118 .
47-1119 . A = B*C;
47-1120 . A = B/C;
47-1121 .
47-1122 . if (A > = B)
47-1123 . {
47-1124 . A = B + C;
47-1125 . D = E + F;
47-1126 . }
47-1127 .
47-1128 . A = B+C;
47-1129 . A = B-C;
47-1130 . A = B-C;
47-1131 . A = B*C;
47-1132 . A = B+C;
47-1133 . A = B-C;
47-1134 .
47-1135 . if (A eq B)
47-1136 . {
47-1137 . A = B + C;
47-1138 . D = E + F;
47-1139 . }
47-1140 .
47-1141 . A = B*C;
47-1142 . A = B+C;
47-1143 . A = B+C;
47-1144 . A = B+C;
47-1145 . A = B+C;
47-1146 . A = B+C;
47-1147 . A = B+C;
47-1148 . // max LOC 67
47-1149 .
47-1150 . }
47-1151 .
47-1152 .
47-1153 . /*
47-1154 . -----------------------------------------------------------------------------
47-1155 . --| NAME: pwr.5.7
47-1156 . --|
47-1157 . --| ABSTRACT:
47-1158 . --| This function does pwr stuff.
47-1159 . --|
47-1160 . --| RETURNS:
47-1161 . --| NONE.
47-1162 . --|
47-1163 . ----------------------------------------------------------------------------
47-1164 . */
47-1165 . static void pwr.5.7(void)
47-1166 . {
47-1167 . A = B*C;
47-1168 . A = B/C;
47-1169 . A = B/C;
47-1170 .
47-1171 . switch (pwr stuff)
47-1172 . {
47-1173 . case one:
47-1174 . {
47-1175 . run_this;
47-1176 . break;
47-1177 . }
47-1178 . case two:
47-1179 . {
47-1180 . run_this;
47-1181 . break;
47-1182 . }
47-1183 . default:
47-1184 . {
47-1185 . // missing error call
47-1186 . }
47-1187 . }
47-1188 .
47-1189 . A = B-C;
47-1190 . A = B-C;
47-1191 . A = B-C;
47-1192 . A = B/C;
47-1193 . A = B*C;
47-1194 .
47-1195 . if (A ne B)
47-1196 . {
47-1197 . A = B + C;
47-1198 . D = E + F;
47-1199 . }
47-1200 .
47-1201 . A = B+C;
47-1202 . A = B+C;
47-1203 . A = B-C;
47-1204 . A = B*C;
47-1205 .
47-1206 . if (A ne B)
47-1207 . {
47-1208 . A = B + C;
47-1209 . D = E + F;
47-1210 . }
47-1211 .
47-1212 . A = B-C;
47-1213 .
47-1214 . if (A == B)
47-1215 . {
47-1216 . A = B + C;
47-1217 . D = E + F;
47-1218 . }
47-1219 .
47-1220 .
47-1221 . if (A == B)
47-1222 . {
47-1223 . A = B + C;
47-1224 . D = E + F;
47-1225 . }
47-1226 .
47-1227 . A = B+C;
47-1228 . send_buffer = (U16 *) malloc(size+1);
47-1229 . A = B/C;
47-1230 .
47-1231 . if (A eq B)
47-1232 . {
47-1233 . A = B + C;
47-1234 . D = E + F;
47-1235 . }
47-1236 .
47-1237 . A = B-C;
47-1238 . A = B-C;
47-1239 .
47-1240 . if (A > B)
47-1241 . {
47-1242 . A = B + C;
47-1243 . D = E + F;
47-1244 . }
47-1245 .
47-1246 . A = B/C;
47-1247 .
47-1248 . switch (pwr stuff)
47-1249 . {
47-1250 . case one:
47-1251 . {
47-1252 . run_this;
47-1253 . break;
47-1254 . }
47-1255 . case two:
47-1256 . {
47-1257 . run_this;
47-1258 . break;
47-1259 . }
47-1260 . default:
47-1261 . {
47-1262 . SwError;
47-1263 . }
47-1264 . }
47-1265 .
47-1266 . send_buffer = (U16 *) malloc(size+1);
47-1267 . A = B-C;
47-1268 . A = B+C;
47-1269 . A = B/C;
47-1270 . A = B*C;
47-1271 .
47-1272 . if (A gt B)
47-1273 . {
47-1274 . A = B + C;
47-1275 . D = E + F;
47-1276 . }
47-1277 .
47-1278 . A = B-C;
47-1279 .
47-1280 . /* dead_block = C * D;
47-1281 . dead_block = E * F; */
47-1282 .
47-1283 . A = B/C;
47-1284 . A = 0x0003;
47-1285 . A = B*C;
47-1286 . A = B*C;
47-1287 . A = B-C;
47-1288 . // max LOC 35
47-1289 .
47-1290 . }
47-1291 .
47-1292 .
47-1293 . /*
47-1294 . -----------------------------------------------------------------------------
47-1295 . --| NAME: pwr.5.8
47-1296 . --|
47-1297 . --| ABSTRACT:
47-1298 . --| This function does pwr stuff.
47-1299 . --|
47-1300 . --| RETURNS:
47-1301 . --| NONE.
47-1302 . --|
47-1303 . ----------------------------------------------------------------------------
47-1304 . */
47-1305 . static void pwr.5.8(void)
47-1306 . {
47-1307 . A = B*C;
47-1308 . A = B/C;
47-1309 .
47-1310 . if (A eq B)
47-1311 . {
47-1312 . A = B + C;
47-1313 . D = E + F;
47-1314 . }
47-1315 .
47-1316 . /* LE SV TOC-2508 this is a pwr-05.8.4 req to set RTC*/
47-1317 .
47-1318 . switch (pwr stuff)
47-1319 . {
47-1320 . case:
47-1321 . case:
47-1322 . // stacked case statements but only if there is a new line in between
47-1323 .
47-1324 . case:
47-1325 . case:
47-1326 . case:
47-1327 . {
47-1328 . run_this;
47-1329 . break;
47-1330 . }
47-1331 . default:
47-1332 . {
47-1333 . halt;
47-1334 . }
47-1335 . }
47-1336 .
47-1337 . A = B/C;
47-1338 . A = B*C;
47-1339 . A = B*C;
47-1340 .
47-1341 . if (A < = B)
47-1342 . {
47-1343 . A = B + C;
47-1344 . D = E + F;
47-1345 . }
47-1346 .
47-1347 .
47-1348 . if (A ne B)
47-1349 . {
47-1350 . A = B + C;
47-1351 . D = E + F;
47-1352 . }
47-1353 .
47-1354 . A = B+C;
47-1355 . A = B-C;
47-1356 . rcv_buffer = (U16 *) alloc(size+1);
47-1357 . A = B*C;
47-1358 . A = B/C;
47-1359 . A = B-C;
47-1360 . A = B*C;
47-1361 . A = B/C;
47-1362 . A = B/C;
47-1363 . A = B-C;
47-1364 . A = B/C;
47-1365 .
47-1366 . if (A != B)
47-1367 . {
47-1368 . A = B + C;
47-1369 . D = E + F;
47-1370 . }
47-1371 .
47-1372 .
47-1373 . if (A != B)
47-1374 . {
47-1375 . A = B + C;
47-1376 . D = E + F;
47-1377 . }
47-1378 .
47-1379 . A = B+C;
47-1380 . free(FreePtr);
47-1381 . A = B*C;
47-1382 . A = B*C;
47-1383 . A = B/C;
47-1384 . A = B*C;
47-1385 .
47-1386 . if (A > = B)
47-1387 . {
47-1388 . A = B + C;
47-1389 . D = E + F;
47-1390 . }
47-1391 .
47-1392 .
47-1393 . if (A ne B)
47-1394 . {
47-1395 . A = B + C;
47-1396 . D = E + F;
47-1397 . }
47-1398 .
47-1399 .
47-1400 . if (A ge B)
47-1401 . {
47-1402 . A = B + C;
47-1403 . D = E + F;
47-1404 . }
47-1405 .
47-1406 . A = B+C;
47-1407 . A = (long)B + C;
47-1408 . A = B/C;
47-1409 . A = B+C;
47-1410 . // max LOC 31
47-1411 .
47-1412 . }
47-1413 .
47-1414 .
47-1415 . /*
47-1416 . -----------------------------------------------------------------------------
47-1417 . --| NAME: pwr.5.9
47-1418 . --|
47-1419 . --| ABSTRACT:
47-1420 . --| This function does pwr stuff.
47-1421 . --|
47-1422 . --| RETURNS:
47-1423 . --| NONE.
47-1424 . --|
47-1425 . ----------------------------------------------------------------------------
47-1426 . */
47-1427 . static void pwr.5.9(void)
47-1428 . {
47-1429 .
47-1430 . if (A ge B)
47-1431 . {
47-1432 . A = B + C;
47-1433 . D = E + F;
47-1434 . }
47-1435 .
47-1436 . A = B*C;
47-1437 . A = B+C;
47-1438 .
47-1439 . /*
47-1440 . dead_block = C * D;
47-1441 . dead_block = E * F;
47-1442 . */
47-1443 .
47-1444 . A = B-C;
47-1445 . A = B-C;
47-1446 .
47-1447 . if ($pwr stuff > $otherpwr stuff)
47-1448 . /* LE SV TOC-008 we really should log all error calls */
47-1449 . {
47-1450 . A = B + C;
47-1451 . }
47-1452 .
47-1453 .
47-1454 . if (A ge B)
47-1455 . {
47-1456 . A = B + C;
47-1457 . D = E + F;
47-1458 . }
47-1459 .
47-1460 . A = B-C;
47-1461 .
47-1462 . if (A < = B)
47-1463 . {
47-1464 . A = B + C;
47-1465 . D = E + F;
47-1466 . }
47-1467 .
47-1468 . A = B/C;
47-1469 . A = B/C;
47-1470 .
47-1471 . if (A != B)
47-1472 . {
47-1473 . A = B + C;
47-1474 . D = E + F;
47-1475 . }
47-1476 .
47-1477 . A = B/C;
47-1478 .
47-1479 . switch (pwr stuff)
47-1480 . {
47-1481 . case one:
47-1482 . {
47-1483 . run_this;
47-1484 . // missing break
47-1485 . }
47-1486 . case two:
47-1487 . {
47-1488 . run_this;
47-1489 . break;
47-1490 . }
47-1491 . default:
47-1492 . {
47-1493 . SwError;
47-1494 . }
47-1495 . }
47-1496 .
47-1497 .
47-1498 . if (A == B)
47-1499 . {
47-1500 . A = B + C;
47-1501 . D = E + F;
47-1502 . }
47-1503 .
47-1504 . A = B*C;
47-1505 . A = B*C;
47-1506 . A = B/C;
47-1507 . A = B*C;
47-1508 . A = B/C;
47-1509 .
47-1510 . if (A != B)
47-1511 . {
47-1512 . A = B + C;
47-1513 . D = E + F;
47-1514 . }
47-1515 .
47-1516 . A = B*C;
47-1517 . A = B+C;
47-1518 . A = B/C;
47-1519 . A = B/C;
47-1520 . A = B+C;
47-1521 . A = B/C;
47-1522 . A = B*C;
47-1523 . A = B*C;
47-1524 . A = B*C;
47-1525 . A = B*C;
47-1526 . A = B-C;
47-1527 . A = 0x0009;
47-1528 . A = B*C;
47-1529 . A = B-C;
47-1530 . A = B+C;
47-1531 .
47-1532 . if (A ge B)
47-1533 . {
47-1534 . A = B + C;
47-1535 . D = E + F;
47-1536 . }
47-1537 .
47-1538 . /* LE SV TOC-2509 this is a pwr-05.9.35 req to record*/
47-1539 . A = B-C;
47-1540 . A = B+C;
47-1541 . // max LOC 36
47-1542 .
47-1543 . }
47-1544 .
47-1545 .
47-1546 . /*
47-1547 . -----------------------------------------------------------------------------
47-1548 . --| NAME: pwr.5.10
47-1549 . --|
47-1550 . --| ABSTRACT:
47-1551 . --| This function does pwr stuff.
47-1552 . --|
47-1553 . --| RETURNS:
47-1554 . --| NONE.
47-1555 . --|
47-1556 . ----------------------------------------------------------------------------
47-1557 . */
47-1558 . static void pwr.5.10(void)
47-1559 . {
47-1560 . A = B/C;
47-1561 .
47-1562 . if ($pwr stuff > $otherpwr stuff)
47-1563 . /* LE SV TOC-008 we really should log all error calls */
47-1564 . {
47-1565 . A = B + C;
47-1566 . }
47-1567 .
47-1568 . A = B+C;
47-1569 . A = B*C;
47-1570 . A = B-C;
47-1571 .
47-1572 . switch (pwr stuff)
47-1573 . {
47-1574 . case one:
47-1575 . {
47-1576 . run_this;
47-1577 . break;
47-1578 . }
47-1579 . case two:
47-1580 . {
47-1581 . run_this;
47-1582 . break;
47-1583 . }
47-1584 . default:
47-1585 . {
47-1586 . SwError;
47-1587 . }
47-1588 . }
47-1589 .
47-1590 . A = B*C;
47-1591 .
47-1592 . if (A < = B)
47-1593 . {
47-1594 . A = B + C;
47-1595 . D = E + F;
47-1596 . }
47-1597 .
47-1598 .
47-1599 . if (A lt B)
47-1600 . {
47-1601 . A = B + C;
47-1602 . D = E + F;
47-1603 . }
47-1604 .
47-1605 . A = B/C;
47-1606 . A = B/C;
47-1607 . A = B+C;
47-1608 . A = B*C;
47-1609 . A = B+C;
47-1610 . A = B+C;
47-1611 .
47-1612 . if (A ge B)
47-1613 . {
47-1614 . A = B + C;
47-1615 . D = E + F;
47-1616 . }
47-1617 .
47-1618 . A = B/C;
47-1619 . A = B-C;
47-1620 . A = B*C;
47-1621 . A = B-C;
47-1622 .
47-1623 . if (A == B)
47-1624 . {
47-1625 . A = B + C;
47-1626 . D = E + F;
47-1627 . }
47-1628 .
47-1629 . A = B*C;
47-1630 .
47-1631 . if (A ne B)
47-1632 . {
47-1633 . A = B + C;
47-1634 . D = E + F;
47-1635 . }
47-1636 .
47-1637 . A = B*C;
47-1638 .
47-1639 . if (A < B)
47-1640 . {
47-1641 . A = B + C;
47-1642 . D = E + F;
47-1643 . }
47-1644 .
47-1645 .
47-1646 . if (A ne B)
47-1647 . {
47-1648 . A = B + C;
47-1649 . D = E + F;
47-1650 . }
47-1651 .
47-1652 . A = B/C;
47-1653 . /* LE SV TOC-2510 this is a pwr-05.10.27 req to transform*/
47-1654 . A = B-C;
47-1655 . A = B+C;
47-1656 . A = B*C;
47-1657 . A = B*C;
47-1658 . A = B+C;
47-1659 . // max LOC 31
47-1660 .
47-1661 . }
47-1662 .
47-1663 .
47-1664 . /*
47-1665 . -----------------------------------------------------------------------------
47-1666 . --| NAME: pwr.5.11
47-1667 . --|
47-1668 . --| ABSTRACT:
47-1669 . --| This function does pwr stuff.
47-1670 . --|
47-1671 . --| RETURNS:
47-1672 . --| NONE.
47-1673 . --|
47-1674 . ----------------------------------------------------------------------------
47-1675 . */
47-1676 . static void pwr.5.11(void)
47-1677 . {
47-1678 .
47-1679 . if (A ne B)
47-1680 . {
47-1681 . A = B + C;
47-1682 . D = E + F;
47-1683 . }
47-1684 .
47-1685 . A = B-C;
47-1686 . A = B*C;
47-1687 . A = B-C;
47-1688 . A = B-C;
47-1689 . A = B/C;
47-1690 . A = B*C;
47-1691 . A = B+C;
47-1692 .
47-1693 . if (A < B)
47-1694 . {
47-1695 . A = B + C;
47-1696 . D = E + F;
47-1697 . }
47-1698 .
47-1699 . A = B+C;
47-1700 . A = B/C;
47-1701 . A = B+C;
47-1702 . A = B/C;
47-1703 .
47-1704 . if (A eq B)
47-1705 . {
47-1706 . A = B + C;
47-1707 . D = E + F;
47-1708 . }
47-1709 .
47-1710 . A = B+C;
47-1711 . A = B/C;
47-1712 . A = B+C;
47-1713 . A = B-C;
47-1714 . // max LOC 18
47-1715 .
47-1716 . }
47-1717 .
47-1718 .
47-1719 . /*
47-1720 . -----------------------------------------------------------------------------
47-1721 . --| NAME: pwr.5.12
47-1722 . --|
47-1723 . --| ABSTRACT:
47-1724 . --| This function does pwr stuff.
47-1725 . --|
47-1726 . --| RETURNS:
47-1727 . --| NONE.
47-1728 . --|
47-1729 . ----------------------------------------------------------------------------
47-1730 . */
47-1731 . static void pwr.5.12(void)
47-1732 . {
47-1733 .
47-1734 . if (A ge B)
47-1735 . {
47-1736 . A = B + C;
47-1737 . D = E + F;
47-1738 . }
47-1739 .
47-1740 . A = B/C;
47-1741 . A = B/C;
47-1742 . A = B-C;
47-1743 .
47-1744 . if (A lt B)
47-1745 . {
47-1746 . A = B + C;
47-1747 . D = E + F;
47-1748 . }
47-1749 .
47-1750 . A = B/C;
47-1751 . A = B-C;
47-1752 . A = B-C;
47-1753 .
47-1754 . if (A > = B)
47-1755 . {
47-1756 . A = B + C;
47-1757 . D = E + F;
47-1758 . }
47-1759 .
47-1760 . A = B-C;
47-1761 . A = B+C;
47-1762 . A = 0x0008;
47-1763 . A = B-C;
47-1764 . A = B/C;
47-1765 . A = B*C;
47-1766 . A = B*C;
47-1767 . A = B/C;
47-1768 . A = B*C;
47-1769 . A = B*C;
47-1770 . A = B+C;
47-1771 .
47-1772 . if (A > B)
47-1773 . {
47-1774 . A = B + C;
47-1775 . D = E + F;
47-1776 . }
47-1777 .
47-1778 .
47-1779 . if (A != B)
47-1780 . {
47-1781 . A = B + C;
47-1782 . D = E + F;
47-1783 . }
47-1784 .
47-1785 . /* LE SV TOC-2511 this is a pwr-05.12.22 req to convert*/
47-1786 .
47-1787 . if (A < = B)
47-1788 . {
47-1789 . A = B + C;
47-1790 . D = E + F;
47-1791 . }
47-1792 .
47-1793 .
47-1794 . /*
47-1795 . dead_code = B - C;
47-1796 . dead_code = D - E;
47-1797 . dead_code = F - G;
47-1798 . */
47-1799 .
47-1800 . A = B/C;
47-1801 .
47-1802 . if (A eq B)
47-1803 . {
47-1804 . A = B + C;
47-1805 . D = E + F;
47-1806 . }
47-1807 .
47-1808 . A = B-C;
47-1809 .
47-1810 . if (A lt B)
47-1811 . {
47-1812 . A = B + C;
47-1813 . D = E + F;
47-1814 . }
47-1815 .
47-1816 .
47-1817 . if (A < B)
47-1818 . {
47-1819 . A = B + C;
47-1820 . D = E + F;
47-1821 . }
47-1822 .
47-1823 . A = B-C;
47-1824 . A = B/C;
47-1825 .
47-1826 . if (A lt B)
47-1827 . {
47-1828 . A = B + C;
47-1829 . D = E + F;
47-1830 . }
47-1831 .
47-1832 . /* LE SV TOC-2512 this is a pwr-05.12.31 req to audit*/
47-1833 .
47-1834 . if (A lt B)
47-1835 . {
47-1836 . A = B + C;
47-1837 . D = E + F;
47-1838 . }
47-1839 .
47-1840 . A = 0x0009;
47-1841 . A = B+C;
47-1842 .
47-1843 . if (A < B)
47-1844 . {
47-1845 . A = B + C;
47-1846 . D = E + F;
47-1847 . }
47-1848 .
47-1849 . A = 0x0006;
47-1850 . A = B/C;
47-1851 . A = B-C;
47-1852 . A = B*C;
47-1853 . A = B+C;
47-1854 . A = B/C;
47-1855 . A = B+C;
47-1856 . A = B*C;
47-1857 . A = B-C;
47-1858 .
47-1859 . if (A gt B)
47-1860 . {
47-1861 . A = B + C;
47-1862 . D = E + F;
47-1863 . }
47-1864 .
47-1865 .
47-1866 . if (A == B)
47-1867 . {
47-1868 . A = B + C;
47-1869 . D = E + F;
47-1870 . }
47-1871 .
47-1872 .
47-1873 . if (A gt B)
47-1874 . {
47-1875 . A = B + C;
47-1876 . D = E + F;
47-1877 . }
47-1878 .
47-1879 . A = B*C;
47-1880 . A = B+C;
47-1881 . A = B+C;
47-1882 . A = B+C;
47-1883 . A = B/C;
47-1884 . A = B/C;
47-1885 .
47-1886 . switch (pwr stuff)
47-1887 . {
47-1888 . case one:
47-1889 . {
47-1890 . run_this;
47-1891 . break;
47-1892 . }
47-1893 . case two:
47-1894 . {
47-1895 . run_this;
47-1896 . break;
47-1897 . }
47-1898 . default:
47-1899 . {
47-1900 . SwError;
47-1901 . }
47-1902 . }
47-1903 .
47-1904 .
47-1905 . if (A != B)
47-1906 . {
47-1907 . A = B + C;
47-1908 . D = E + F;
47-1909 . }
47-1910 .
47-1911 . A = B/C;
47-1912 . A = B/C;
47-1913 . A = 0x0003;
47-1914 . A = B+C;
47-1915 .
47-1916 . if ($pwr stuff > $otherpwr stuff)
47-1917 . /* LE SV TOC-008 we really should log all error calls */
47-1918 . {
47-1919 . A = B + C;
47-1920 . }
47-1921 .
47-1922 .
47-1923 . if (A > B)
47-1924 . {
47-1925 . A = B + C;
47-1926 . D = E + F;
47-1927 . }
47-1928 .
47-1929 .
47-1930 . if (A > = B)
47-1931 . {
47-1932 . A = B + C;
47-1933 . D = E + F;
47-1934 . }
47-1935 .
47-1936 . A = B+C;
47-1937 .
47-1938 . if (A < B)
47-1939 . {
47-1940 . A = B + C;
47-1941 . D = E + F;
47-1942 . }
47-1943 .
47-1944 . A = B*C;
47-1945 . A = B+C;
47-1946 . A = B+C;
47-1947 . A = B-C;
47-1948 . A = B/C;
47-1949 .
47-1950 . if (A ge B)
47-1951 . {
47-1952 . A = B + C;
47-1953 . D = E + F;
47-1954 . }
47-1955 .
47-1956 . A = B-C;
47-1957 .
47-1958 . if (A == B)
47-1959 . {
47-1960 . A = B + C;
47-1961 . D = E + F;
47-1962 . }
47-1963 .
47-1964 .
47-1965 . if (A < = B)
47-1966 . {
47-1967 . A = B + C;
47-1968 . D = E + F;
47-1969 . }
47-1970 .
47-1971 . /* dead_code = A * B; */
47-1972 .
47-1973 . if (A > B)
47-1974 . {
47-1975 . A = B + C;
47-1976 . D = E + F;
47-1977 . }
47-1978 .
47-1979 .
47-1980 . if (A lt B)
47-1981 . {
47-1982 . A = B + C;
47-1983 . D = E + F;
47-1984 . }
47-1985 .
47-1986 .
47-1987 . if (A < = B)
47-1988 . {
47-1989 . A = B + C;
47-1990 . D = E + F;
47-1991 . }
47-1992 .
47-1993 . A = B-C;
47-1994 . A = B+C;
47-1995 .
47-1996 . if (A > B)
47-1997 . {
47-1998 . A = B + C;
47-1999 . D = E + F;
47-2000 . }
47-2001 .
47-2002 . A = B+C;
47-2003 .
47-2004 . if (A lt B)
47-2005 . {
47-2006 . A = B + C;
47-2007 . D = E + F;
47-2008 . }
47-2009 .
47-2010 . // max LOC 76
47-2011 .
47-2012 . }
47-2013 .
47-2014 .
47-2015 . /*
47-2016 . -----------------------------------------------------------------------------
47-2017 . --| NAME: pwr.5.13
47-2018 . --|
47-2019 . --| ABSTRACT:
47-2020 . --| This function does pwr stuff.
47-2021 . --|
47-2022 . --| RETURNS:
47-2023 . --| NONE.
47-2024 . --|
47-2025 . ----------------------------------------------------------------------------
47-2026 . */
47-2027 . static void pwr.5.13(void)
47-2028 . {
47-2029 . A = B*C;
47-2030 .
47-2031 . if (A le B)
47-2032 . {
47-2033 . A = B + C;
47-2034 . D = E + F;
47-2035 . }
47-2036 .
47-2037 . A = B/C;
47-2038 . A = B*C;
47-2039 . /* LE SV TOC-2513 this is a pwr-05.13.5 req to detect error*/
47-2040 . A = B/C;
47-2041 .
47-2042 . if (A != B)
47-2043 . {
47-2044 . A = B + C;
47-2045 . D = E + F;
47-2046 . }
47-2047 .
47-2048 .
47-2049 . if (A != B)
47-2050 . {
47-2051 . A = B + C;
47-2052 . D = E + F;
47-2053 . }
47-2054 .
47-2055 .
47-2056 . if (A < = B)
47-2057 . {
47-2058 . A = B + C;
47-2059 . D = E + F;
47-2060 . }
47-2061 .
47-2062 . A = B/C;
47-2063 . A = B-C;
47-2064 . A = B*C;
47-2065 . A = B+C;
47-2066 . A = B/C;
47-2067 . A = B+C;
47-2068 . A = B+C;
47-2069 .
47-2070 . if (A lt B)
47-2071 . {
47-2072 . A = B + C;
47-2073 . D = E + F;
47-2074 . }
47-2075 .
47-2076 . A = B-C;
47-2077 .
47-2078 . if (A > = B)
47-2079 . {
47-2080 . A = B + C;
47-2081 . D = E + F;
47-2082 . }
47-2083 .
47-2084 . A = B/C;
47-2085 . A = B-C;
47-2086 . /* LE SV TOC-2514 this is a pwr-05.13.21 req to check unix*/
47-2087 .
47-2088 . if (A < = B)
47-2089 . {
47-2090 . A = B + C;
47-2091 . D = E + F;
47-2092 . }
47-2093 .
47-2094 .
47-2095 . if (A gt B)
47-2096 . {
47-2097 . A = B + C;
47-2098 . D = E + F;
47-2099 . }
47-2100 .
47-2101 .
47-2102 . if (A > B)
47-2103 . {
47-2104 . A = B + C;
47-2105 . D = E + F;
47-2106 . }
47-2107 .
47-2108 . A = B-C;
47-2109 . A = B/C;
47-2110 .
47-2111 . if (A == B)
47-2112 . {
47-2113 . A = B + C;
47-2114 . D = E + F;
47-2115 . }
47-2116 .
47-2117 . A = B-C;
47-2118 . A = B-C;
47-2119 .
47-2120 . if (A < = B)
47-2121 . {
47-2122 . A = B + C;
47-2123 . D = E + F;
47-2124 . }
47-2125 .
47-2126 .
47-2127 . if (A gt B)
47-2128 . {
47-2129 . A = B + C;
47-2130 . D = E + F;
47-2131 . }
47-2132 .
47-2133 .
47-2134 . if (A < = B)
47-2135 . {
47-2136 . A = B + C;
47-2137 . D = E + F;
47-2138 . }
47-2139 .
47-2140 . A = B/C;
47-2141 .
47-2142 . if (A gt B)
47-2143 . {
47-2144 . A = B + C;
47-2145 . D = E + F;
47-2146 . }
47-2147 .
47-2148 . A = B+C;
47-2149 . A = B*C;
47-2150 . A = B/C;
47-2151 . A = B-C;
47-2152 . A = B/C;
47-2153 . A = B+C;
47-2154 .
47-2155 . if (A < B)
47-2156 . {
47-2157 . A = B + C;
47-2158 . D = E + F;
47-2159 . }
47-2160 .
47-2161 . A = B/C;
47-2162 . A = B*C;
47-2163 . A = B-C;
47-2164 . A = B*C;
47-2165 .
47-2166 . switch (pwr stuff)
47-2167 . {
47-2168 . case one:
47-2169 . {
47-2170 . run_this;
47-2171 . break;
47-2172 . }
47-2173 . case two:
47-2174 . {
47-2175 . run_this;
47-2176 . break;
47-2177 . }
47-2178 . default:
47-2179 . {
47-2180 . SwError;
47-2181 . }
47-2182 . }
47-2183 .
47-2184 . A = B-C;
47-2185 . A = B*C;
47-2186 .
47-2187 . if (A == B)
47-2188 . {
47-2189 . A = B + C;
47-2190 . D = E + F;
47-2191 . }
47-2192 .
47-2193 . /* LE SV TOC-2515 this is a pwr-05.13.49 req to reject*/
47-2194 .
47-2195 . if (A < B)
47-2196 . {
47-2197 . A = B + C;
47-2198 . D = E + F;
47-2199 . }
47-2200 .
47-2201 . A = 0x0004;
47-2202 . A = B/C;
47-2203 . A = B+C;
47-2204 . /* LE SV TOC-2516 this is a pwr-05.13.52 req to update*/
47-2205 . A = B*C;
47-2206 . A = B/C;
47-2207 .
47-2208 . if (A le B)
47-2209 . {
47-2210 . A = B + C;
47-2211 . D = E + F;
47-2212 . }
47-2213 .
47-2214 . A = B+C;
47-2215 . A = B-C;
47-2216 .
47-2217 . if (A < B)
47-2218 . {
47-2219 . A = B + C;
47-2220 . D = E + F;
47-2221 . }
47-2222 .
47-2223 . A = B/C;
47-2224 . // max LOC 58
47-2225 .
47-2226 . }
47-2227 .
47-2228 .
47-2229 . /*
47-2230 . -----------------------------------------------------------------------------
47-2231 . --| NAME: pwr.5.14
47-2232 . --|
47-2233 . --| ABSTRACT:
47-2234 . --| This function does pwr stuff.
47-2235 . --|
47-2236 . --| RETURNS:
47-2237 . --| NONE.
47-2238 . --|
47-2239 . ----------------------------------------------------------------------------
47-2240 . */
47-2241 . static void pwr.5.14(void)
47-2242 . {
47-2243 . A = B*C;
47-2244 . A = B-C;
47-2245 . A = B+C;
47-2246 . A = B+C;
47-2247 . A = B+C;
47-2248 . A = B+C;
47-2249 . A = B*C;
47-2250 .
47-2251 . if ($pwr stuff > $otherpwr stuff)
47-2252 . /* LE SV TOC-008 we really should log all error calls */
47-2253 . {
47-2254 . A = B + C;
47-2255 . }
47-2256 .
47-2257 . A = B+C;
47-2258 . A = B+C;
47-2259 . A = B/C;
47-2260 . A = 0x0007;
47-2261 . A = (float)B + C;
47-2262 . A = B/C;
47-2263 . /* LE SV TOC-2517 this is a pwr-05.14.12 req to record*/
47-2264 . A = B-C;
47-2265 .
47-2266 . if (A < = B)
47-2267 . {
47-2268 . A = B + C;
47-2269 . D = E + F;
47-2270 . }
47-2271 .
47-2272 . A = B*C;
47-2273 .
47-2274 . if (A le B)
47-2275 . {
47-2276 . A = B + C;
47-2277 . D = E + F;
47-2278 . }
47-2279 .
47-2280 .
47-2281 . /* dead_code = B + C;
47-2282 . dead_code = D + E;
47-2283 . dead_code = F + G; */
47-2284 .
47-2285 .
47-2286 . if (A != B)
47-2287 . {
47-2288 . A = B + C;
47-2289 . D = E + F;
47-2290 . }
47-2291 .
47-2292 .
47-2293 . if (A < = B)
47-2294 . {
47-2295 . A = B + C;
47-2296 . D = E + F;
47-2297 . }
47-2298 .
47-2299 .
47-2300 . if (A != B)
47-2301 . {
47-2302 . A = B + C;
47-2303 . D = E + F;
47-2304 . }
47-2305 .
47-2306 . A = B*C;
47-2307 . A = B+C;
47-2308 . A = B*C;
47-2309 .
47-2310 . if (A > B)
47-2311 . {
47-2312 . A = B + C;
47-2313 . D = E + F;
47-2314 . }
47-2315 .
47-2316 .
47-2317 . /* dead_code = B + C;
47-2318 . dead_code = D + E;
47-2319 . dead_code = F + G; */
47-2320 .
47-2321 . A = B/C;
47-2322 .
47-2323 . switch (pwr stuff)
47-2324 . {
47-2325 . case one:
47-2326 . {
47-2327 . run_this;
47-2328 . // missing break
47-2329 . }
47-2330 . case two:
47-2331 . {
47-2332 . run_this;
47-2333 . break;
47-2334 . }
47-2335 . default:
47-2336 . {
47-2337 . SwError;
47-2338 . }
47-2339 . }
47-2340 .
47-2341 . A = B*C;
47-2342 . A = B-C;
47-2343 . A = B+C;
47-2344 . A = B-C;
47-2345 . // max LOC 27
47-2346 .
47-2347 . }
47-2348 .
47 47 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-05.c
48 48 Source: source/ft-app/ft-app-B1.1/pwr/pwr-06.c
48-0 . /*
48-1 . ----------------------------------------------------------------------------
48-2 . --| BEGIN PROLOGUE
48-3 . --|
48-4 . --| CLASSIFICATION: UNCLASSIFIED
48-5 . --|
48-6 . --| FILE NAME: pwr-06.c
48-7 . --|
48-8 . --| ABSTRACT:
48-9 . --| This file contains the 9 functions that do file pwr stuff.
48-10 . --|
48-11 . --| HISTORY:
48-12 . --| CCCQ_NAME:
48-13 . --| CCCQ_VER:
48-14 . --|
48-15 . --| END PROLOGUE
48-16 . ----------------------------------------------------------------------------
48-17 . */
48-18 .
48-19 . char D;
48-20 . #define B;
48-21 . #include D;
48-22 . int A;
48-23 .
48-24 .
48-25 .
48-26 . /*
48-27 . -----------------------------------------------------------------------------
48-28 . --| NAME: pwr.6.1
48-29 . --|
48-30 . --| ABSTRACT:
48-31 . --| This function does pwr stuff.
48-32 . --|
48-33 . --| RETURNS:
48-34 . --| NONE.
48-35 . --|
48-36 . ----------------------------------------------------------------------------
48-37 . */
48-38 . static void pwr.6.1(void)
48-39 . {
48-40 . A = B/C;
48-41 . /* LE SV TOC-2518 this is a pwr-06.1.2 req to record*/
48-42 . A = B-C;
48-43 . A = B/C;
48-44 . A = B-C;
48-45 .
48-46 . if (A > = B)
48-47 . {
48-48 . A = B + C;
48-49 . D = E + F;
48-50 . }
48-51 .
48-52 . A = B*C;
48-53 . A = B+C;
48-54 .
48-55 . if (A == B)
48-56 . {
48-57 . A = B + C;
48-58 . D = E + F;
48-59 . }
48-60 .
48-61 . /* LE SV TOC-2519 this is a pwr-06.1.9 req to process*/
48-62 . A = B/C;
48-63 . A = B+C;
48-64 . A = B+C;
48-65 .
48-66 . if (A < = B)
48-67 . {
48-68 . A = B + C;
48-69 . D = E + F;
48-70 . }
48-71 .
48-72 . A = B+C;
48-73 . A = B-C;
48-74 . A = B-C;
48-75 . A = B-C;
48-76 . A = B/C;
48-77 . A = B*C;
48-78 . A = B/C;
48-79 . A = B*C;
48-80 . /* LE SV TOC-2520 this is a pwr-06.1.21 req to fail*/
48-81 . A = B*C;
48-82 . A = B/C;
48-83 .
48-84 . if (A le B)
48-85 . {
48-86 . A = B + C;
48-87 . D = E + F;
48-88 . }
48-89 .
48-90 .
48-91 . if (A < = B)
48-92 . {
48-93 . A = B + C;
48-94 . D = E + F;
48-95 . }
48-96 .
48-97 .
48-98 . if (A > B)
48-99 . {
48-100 . A = B + C;
48-101 . D = E + F;
48-102 . }
48-103 .
48-104 . A = B*C;
48-105 .
48-106 . if (A != B)
48-107 . {
48-108 . A = B + C;
48-109 . D = E + F;
48-110 . }
48-111 .
48-112 . A = B+C;
48-113 . A = B*C;
48-114 . A = B*C;
48-115 . A = 0x0001;
48-116 . A = B+C;
48-117 . A = B+C;
48-118 . A = B/C;
48-119 . A = B+C;
48-120 . A = B/C;
48-121 .
48-122 . if (A lt B)
48-123 . {
48-124 . A = B + C;
48-125 . D = E + F;
48-126 . }
48-127 .
48-128 . // max LOC 36
48-129 .
48-130 . }
48-131 .
48-132 .
48-133 . /*
48-134 . -----------------------------------------------------------------------------
48-135 . --| NAME: pwr.6.2
48-136 . --|
48-137 . --| ABSTRACT:
48-138 . --| This function does pwr stuff.
48-139 . --|
48-140 . --| RETURNS:
48-141 . --| NONE.
48-142 . --|
48-143 . ----------------------------------------------------------------------------
48-144 . */
48-145 . static void pwr.6.2(void)
48-146 . {
48-147 . A = B*C;
48-148 . A = B-C;
48-149 . A = B+C;
48-150 .
48-151 . if (A != B)
48-152 . {
48-153 . A = B + C;
48-154 . D = E + F;
48-155 . }
48-156 .
48-157 . send_buffer = (U16 *) malloc(size+1);
48-158 . A = B-C;
48-159 . A = B*C;
48-160 . A = (int)B + C;
48-161 . A = B-C;
48-162 . A = B+C;
48-163 . A = B*C;
48-164 . /* LE SV TOC-2521 this is a pwr-06.2.10 req to record*/
48-165 . A = B*C;
48-166 . A = B+C;
48-167 . A = B*C;
48-168 .
48-169 . if (A lt B)
48-170 . {
48-171 . A = B + C;
48-172 . D = E + F;
48-173 . }
48-174 .
48-175 .
48-176 . if (A != B)
48-177 . {
48-178 . A = B + C;
48-179 . D = E + F;
48-180 . }
48-181 .
48-182 . A = B+C;
48-183 .
48-184 . if (A != B)
48-185 . {
48-186 . A = B + C;
48-187 . D = E + F;
48-188 . }
48-189 .
48-190 .
48-191 . if (A > B)
48-192 . {
48-193 . A = B + C;
48-194 . D = E + F;
48-195 . }
48-196 .
48-197 . // max LOC 17
48-198 .
48-199 . }
48-200 .
48-201 .
48-202 . /*
48-203 . -----------------------------------------------------------------------------
48-204 . --| NAME: pwr.6.3
48-205 . --|
48-206 . --| ABSTRACT:
48-207 . --| This function does pwr stuff.
48-208 . --|
48-209 . --| RETURNS:
48-210 . --| NONE.
48-211 . --|
48-212 . ----------------------------------------------------------------------------
48-213 . */
48-214 . static void pwr.6.3(void)
48-215 . {
48-216 . // ??? go see ws
48-217 .
48-218 . switch (pwr stuff)
48-219 . {
48-220 . case one:
48-221 . {
48-222 . run_this;
48-223 . break;
48-224 . }
48-225 . case two:
48-226 . {
48-227 . run_this;
48-228 . break;
48-229 . }
48-230 . default:
48-231 . {
48-232 . SwError;
48-233 . }
48-234 . }
48-235 .
48-236 . A = B*C;
48-237 . /* LE SV TOC-2522 this is a pwr-06.3.3 req to audit*/
48-238 . A = B+C;
48-239 . A = B/C;
48-240 . A = B*C;
48-241 . A = B-C;
48-242 .
48-243 . if (A > = B)
48-244 . {
48-245 . A = B + C;
48-246 . D = E + F;
48-247 . }
48-248 .
48-249 . A = B+C;
48-250 . A = B*C;
48-251 . A = B+C;
48-252 .
48-253 . if (A < = B)
48-254 . {
48-255 . A = B + C;
48-256 . D = E + F;
48-257 . }
48-258 .
48-259 . /* LE SV TOC-2523 this is a pwr-06.3.12 req to enable*/
48-260 . A = B+C;
48-261 . A = B/C;
48-262 . A = B*C;
48-263 . A = B+C;
48-264 .
48-265 . if (A gt B)
48-266 . {
48-267 . A = B + C;
48-268 . D = E + F;
48-269 . }
48-270 .
48-271 . A = B*C;
48-272 . A = B*C;
48-273 . A = B/C;
48-274 . A = B-C;
48-275 . // max LOC 20
48-276 .
48-277 . }
48-278 .
48-279 .
48-280 . /*
48-281 . -----------------------------------------------------------------------------
48-282 . --| NAME: pwr.6.4
48-283 . --|
48-284 . --| ABSTRACT:
48-285 . --| This function does pwr stuff.
48-286 . --|
48-287 . --| RETURNS:
48-288 . --| NONE.
48-289 . --|
48-290 . ----------------------------------------------------------------------------
48-291 . */
48-292 . static void pwr.6.4(void)
48-293 . {
48-294 . A = B-C;
48-295 . A = B/C;
48-296 . A = B/C;
48-297 . A = B-C;
48-298 . A = B/C;
48-299 . A = B*C;
48-300 . /* LE SV TOC-2524 this is a pwr-06.4.7 req to enable*/
48-301 . A = B/C;
48-302 . // (P) this is really improtant
48-303 .
48-304 . if (A > = B)
48-305 . {
48-306 . A = B + C;
48-307 . D = E + F;
48-308 . }
48-309 .
48-310 . A = B+C;
48-311 . A = B*C;
48-312 . A = B*C;
48-313 . A = B*C;
48-314 . A = B-C;
48-315 .
48-316 . if (A lt B)
48-317 . {
48-318 . A = B + C;
48-319 . D = E + F;
48-320 . }
48-321 .
48-322 . A = B/C;
48-323 . A = B/C;
48-324 .
48-325 . if (A < = B)
48-326 . {
48-327 . A = B + C;
48-328 . D = E + F;
48-329 . }
48-330 .
48-331 . A = B-C;
48-332 .
48-333 . if (A eq B)
48-334 . {
48-335 . A = B + C;
48-336 . D = E + F;
48-337 . }
48-338 .
48-339 .
48-340 . if (A gt B)
48-341 . {
48-342 . A = B + C;
48-343 . D = E + F;
48-344 . }
48-345 .
48-346 . A = B+C;
48-347 . A = B/C;
48-348 . A = B*C;
48-349 .
48-350 . if (A ne B)
48-351 . {
48-352 . A = B + C;
48-353 . D = E + F;
48-354 . }
48-355 .
48-356 .
48-357 . if (A ne B)
48-358 . {
48-359 . A = B + C;
48-360 . D = E + F;
48-361 . }
48-362 .
48-363 . A = B-C;
48-364 .
48-365 . if (A ge B)
48-366 . {
48-367 . A = B + C;
48-368 . D = E + F;
48-369 . }
48-370 .
48-371 . A = B/C;
48-372 . A = B*C;
48-373 . A = B-C;
48-374 . A = B-C;
48-375 . A = B/C;
48-376 . A = B-C;
48-377 . A = B/C;
48-378 . A = B+C;
48-379 .
48-380 . if (A le B)
48-381 . {
48-382 . A = B + C;
48-383 . D = E + F;
48-384 . }
48-385 .
48-386 . A = B+C;
48-387 . A = B+C;
48-388 . A = B*C;
48-389 . A = B*C;
48-390 . A = B*C;
48-391 . A = B*C;
48-392 . A = B+C;
48-393 . A = B*C;
48-394 . A = B+C;
48-395 .
48-396 . if (A gt B)
48-397 . {
48-398 . A = B + C;
48-399 . D = E + F;
48-400 . }
48-401 .
48-402 .
48-403 . if (A gt B)
48-404 . {
48-405 . A = B + C;
48-406 . D = E + F;
48-407 . }
48-408 .
48-409 . A = B/C;
48-410 .
48-411 . if (A < B)
48-412 . {
48-413 . A = B + C;
48-414 . D = E + F;
48-415 . }
48-416 .
48-417 . A = B-C;
48-418 . A = B*C;
48-419 . A = B-C;
48-420 .
48-421 . if (A ge B)
48-422 . {
48-423 . A = B + C;
48-424 . D = E + F;
48-425 . }
48-426 .
48-427 . A = B-C;
48-428 .
48-429 . if (A eq B)
48-430 . {
48-431 . A = B + C;
48-432 . D = E + F;
48-433 . }
48-434 .
48-435 . A = B/C;
48-436 . goto error;
48-437 . A = B+C;
48-438 . A = 0x0009;
48-439 .
48-440 . if (A lt B)
48-441 . {
48-442 . A = B + C;
48-443 . D = E + F;
48-444 . }
48-445 .
48-446 . A = B/C;
48-447 . A = B/C;
48-448 . A = B/C;
48-449 .
48-450 . if (A ge B)
48-451 . {
48-452 . A = B + C;
48-453 . D = E + F;
48-454 . }
48-455 .
48-456 . A = B*C;
48-457 . A = B-C;
48-458 . // max LOC 64
48-459 .
48-460 . }
48-461 .
48-462 .
48-463 . /*
48-464 . -----------------------------------------------------------------------------
48-465 . --| NAME: pwr.6.5
48-466 . --|
48-467 . --| ABSTRACT:
48-468 . --| This function does pwr stuff.
48-469 . --|
48-470 . --| RETURNS:
48-471 . --| NONE.
48-472 . --|
48-473 . ----------------------------------------------------------------------------
48-474 . */
48-475 . static void pwr.6.5(void)
48-476 . {
48-477 . A = B-C;
48-478 . /* LE SV TOC-2525 this is a pwr-06.5.2 req to set RTC*/
48-479 .
48-480 . if (A < = B)
48-481 . {
48-482 . A = B + C;
48-483 . D = E + F;
48-484 . }
48-485 .
48-486 . A = B/C;
48-487 . /* LE SV TOC-2526 this is a pwr-06.5.4 req to recover*/
48-488 . A = B-C;
48-489 . A = B/C;
48-490 . A = B*C;
48-491 .
48-492 . if (A gt B)
48-493 . {
48-494 . A = B + C;
48-495 . D = E + F;
48-496 . }
48-497 .
48-498 . A = B*C;
48-499 . A = B+C;
48-500 . A = B-C;
48-501 . A = B/C;
48-502 . A = B+C;
48-503 . A = B+C;
48-504 . A = B-C;
48-505 .
48-506 . if (A < B)
48-507 . {
48-508 . A = B + C;
48-509 . D = E + F;
48-510 . }
48-511 .
48-512 . A = B-C;
48-513 . A = B-C;
48-514 . A = B*C;
48-515 . A = B*C;
48-516 . A = B*C;
48-517 .
48-518 . if (A < = B)
48-519 . {
48-520 . A = B + C;
48-521 . D = E + F;
48-522 . }
48-523 .
48-524 .
48-525 . if (A == B)
48-526 . {
48-527 . A = B + C;
48-528 . D = E + F;
48-529 . }
48-530 .
48-531 . A = B+C;
48-532 . A = B+C;
48-533 . A = B+C;
48-534 . A = B+C;
48-535 . A = B-C;
48-536 .
48-537 . if (A lt B)
48-538 . {
48-539 . A = B + C;
48-540 . D = E + F;
48-541 . }
48-542 .
48-543 . A = B*C;
48-544 . A = B*C;
48-545 . A = B+C;
48-546 . A = B/C;
48-547 . A = B*C;
48-548 . /* dead_code = A * B; */
48-549 .
48-550 . if (A < B)
48-551 . {
48-552 . A = B + C;
48-553 . D = E + F;
48-554 . }
48-555 .
48-556 .
48-557 . #ifdef LAZY
48-558 . // this is not nice
48-559 . A = B + C;
48-560 . A = B + C;
48-561 . #endif
48-562 .
48-563 . A = B*C;
48-564 . A = B*C;
48-565 . A = B*C;
48-566 . A = B-C;
48-567 . A = B*C;
48-568 . A = B*C;
48-569 . A = B-C;
48-570 .
48-571 . if (A != B)
48-572 . {
48-573 . A = B + C;
48-574 . D = E + F;
48-575 . }
48-576 .
48-577 . A = B/C;
48-578 .
48-579 . if (A eq B)
48-580 . {
48-581 . A = B + C;
48-582 . D = E + F;
48-583 . }
48-584 .
48-585 . do forever;
48-586 . A = B/C;
48-587 . A = B*C;
48-588 . A = B+C;
48-589 .
48-590 . if (A > = B)
48-591 . {
48-592 . A = B + C;
48-593 . D = E + F;
48-594 . }
48-595 .
48-596 . A = B*C;
48-597 . A = B+C;
48-598 . A = B+C;
48-599 . A = B-C;
48-600 . A = B*C;
48-601 .
48-602 . switch (pwr stuff)
48-603 . {
48-604 . case one:
48-605 . {
48-606 . run_this;
48-607 . break;
48-608 . }
48-609 . case two:
48-610 . {
48-611 . run_this;
48-612 . break;
48-613 . }
48-614 . default:
48-615 . {
48-616 . SwError;
48-617 . }
48-618 . }
48-619 .
48-620 . A = 0x0003;
48-621 . A = B+C;
48-622 . A = B-C;
48-623 . A = B+C;
48-624 . A = B*C;
48-625 .
48-626 . if (A gt B)
48-627 . {
48-628 . A = B + C;
48-629 . D = E + F;
48-630 . }
48-631 .
48-632 . A = B/C;
48-633 . A = B-C;
48-634 . A = B*C;
48-635 . A = B*C;
48-636 .
48-637 . if (A > = B)
48-638 . {
48-639 . A = B + C;
48-640 . D = E + F;
48-641 . }
48-642 .
48-643 . A = B*C;
48-644 . A = B+C;
48-645 .
48-646 . if (A le B)
48-647 . {
48-648 . A = B + C;
48-649 . D = E + F;
48-650 . }
48-651 .
48-652 . A = (float)B + C;
48-653 . A = B+C;
48-654 .
48-655 . switch (pwr stuff)
48-656 . {
48-657 . case one:
48-658 . {
48-659 . run_this;
48-660 . break;
48-661 . }
48-662 . case two:
48-663 . {
48-664 . run_this;
48-665 . break;
48-666 . }
48-667 . default:
48-668 . {
48-669 . SwError;
48-670 . }
48-671 . }
48-672 .
48-673 .
48-674 . if (A ne B)
48-675 . {
48-676 . A = B + C;
48-677 . D = E + F;
48-678 . }
48-679 .
48-680 . A = B-C;
48-681 .
48-682 . if ($pwr stuff > $otherpwr stuff)
48-683 . /* LE SV TOC-008 we really should log all error calls */
48-684 . {
48-685 . A = B + C;
48-686 . }
48-687 .
48-688 . A = B-C;
48-689 . /* LE SV TOC-2527 this is a pwr-06.5.73 req to validate*/
48-690 . A = B+C;
48-691 . A = 0x0003;
48-692 . A = B+C;
48-693 . A = B*C;
48-694 . A = B+C;
48-695 . A = B+C;
48-696 .
48-697 . if (A ge B)
48-698 . {
48-699 . A = B + C;
48-700 . D = E + F;
48-701 . }
48-702 .
48-703 . rcv_buffer = (U16 *) alloc(size+1);
48-704 . A = B-C;
48-705 . // max LOC 79
48-706 .
48-707 . }
48-708 .
48-709 .
48-710 . /*
48-711 . -----------------------------------------------------------------------------
48-712 . --| NAME: pwr.6.6
48-713 . --|
48-714 . --| ABSTRACT:
48-715 . --| This function does pwr stuff.
48-716 . --|
48-717 . --| RETURNS:
48-718 . --| NONE.
48-719 . --|
48-720 . ----------------------------------------------------------------------------
48-721 . */
48-722 . static void pwr.6.6(void)
48-723 . {
48-724 . A = B/C;
48-725 . A = B*C;
48-726 . A = 0x0008;
48-727 . A = B+C;
48-728 . A = B/C;
48-729 . /* LE SV TOC-2528 this is a pwr-06.6.5 req to compare*/
48-730 . A = B*C;
48-731 . A = B/C;
48-732 .
48-733 . if (A > B)
48-734 . {
48-735 . A = B + C;
48-736 . D = E + F;
48-737 . }
48-738 .
48-739 . A = B-C;
48-740 . A = B-C;
48-741 .
48-742 . if (A le B)
48-743 . {
48-744 . A = B + C;
48-745 . D = E + F;
48-746 . }
48-747 .
48-748 . A = B+C;
48-749 . A = B-C;
48-750 . A = B/C;
48-751 . A = B-C;
48-752 .
48-753 . if (A lt B)
48-754 . {
48-755 . A = B + C;
48-756 . D = E + F;
48-757 . }
48-758 .
48-759 .
48-760 . if (A > B)
48-761 . {
48-762 . A = B + C;
48-763 . D = E + F;
48-764 . }
48-765 .
48-766 .
48-767 . if (A lt B)
48-768 . {
48-769 . A = B + C;
48-770 . D = E + F;
48-771 . }
48-772 .
48-773 .
48-774 . if (A ge B)
48-775 . {
48-776 . A = B + C;
48-777 . D = E + F;
48-778 . }
48-779 .
48-780 . A = B-C;
48-781 . A = B/C;
48-782 . A = B-C;
48-783 . A = B*C;
48-784 . A = B*C;
48-785 .
48-786 . if (A != B)
48-787 . {
48-788 . A = B + C;
48-789 . D = E + F;
48-790 . }
48-791 .
48-792 . FreePtr = HmiStringPtr;
48-793 . A = B/C;
48-794 . A = B-C;
48-795 . A = B-C;
48-796 .
48-797 . switch (pwr stuff)
48-798 . {
48-799 . case one:
48-800 . {
48-801 . run_this;
48-802 . break;
48-803 . }
48-804 . case two:
48-805 . {
48-806 . run_this;
48-807 . break;
48-808 . }
48-809 . default:
48-810 . {
48-811 . SwError;
48-812 . }
48-813 . }
48-814 .
48-815 . A = B*C;
48-816 . A = B+C;
48-817 .
48-818 . if (A ge B)
48-819 . {
48-820 . A = B + C;
48-821 . D = E + F;
48-822 . }
48-823 .
48-824 .
48-825 . if (A gt B)
48-826 . {
48-827 . A = B + C;
48-828 . D = E + F;
48-829 . }
48-830 .
48-831 . A = B*C;
48-832 .
48-833 . if (A < B)
48-834 . {
48-835 . A = B + C;
48-836 . D = E + F;
48-837 . }
48-838 .
48-839 . A = B*C;
48-840 . A = B-C;
48-841 .
48-842 . if (A ge B)
48-843 . {
48-844 . A = B + C;
48-845 . D = E + F;
48-846 . }
48-847 .
48-848 .
48-849 . if (A gt B)
48-850 . {
48-851 . A = B + C;
48-852 . D = E + F;
48-853 . }
48-854 .
48-855 .
48-856 . if (A lt B)
48-857 . {
48-858 . A = B + C;
48-859 . D = E + F;
48-860 . }
48-861 .
48-862 .
48-863 . /*
48-864 . dead_code = B - C;
48-865 . dead_code = D - E;
48-866 . dead_code = F - G;
48-867 . */
48-868 .
48-869 . A = B+C;
48-870 .
48-871 . if (A ge B)
48-872 . {
48-873 . A = B + C;
48-874 . D = E + F;
48-875 . }
48-876 .
48-877 . /* LE SV TOC-2529 this is a pwr-06.6.42 req to check unix*/
48-878 . A = B/C;
48-879 . A = B+C;
48-880 . A = B/C;
48-881 .
48-882 . if (A != B)
48-883 . {
48-884 . A = B + C;
48-885 . D = E + F;
48-886 . }
48-887 .
48-888 . A = B*C;
48-889 . A = B-C;
48-890 . A = B/C;
48-891 .
48-892 . if (A ne B)
48-893 . {
48-894 . A = B + C;
48-895 . D = E + F;
48-896 . }
48-897 .
48-898 . A = B/C;
48-899 . // max LOC 50
48-900 .
48-901 . }
48-902 .
48-903 .
48-904 . /*
48-905 . -----------------------------------------------------------------------------
48-906 . --| NAME: pwr.6.7
48-907 . --|
48-908 . --| ABSTRACT:
48-909 . --| This function does pwr stuff.
48-910 . --|
48-911 . --| RETURNS:
48-912 . --| NONE.
48-913 . --|
48-914 . ----------------------------------------------------------------------------
48-915 . */
48-916 . static void pwr.6.7(void)
48-917 . {
48-918 . A = B/C;
48-919 . A = B-C;
48-920 . A = B-C;
48-921 . /* LE SV TOC-2530 this is a pwr-06.7.4 req to convert*/
48-922 . A = B*C;
48-923 . A = B+C;
48-924 . A = B*C;
48-925 .
48-926 . if (A == B)
48-927 . {
48-928 . A = B + C;
48-929 . D = E + F;
48-930 . }
48-931 .
48-932 . A = B-C;
48-933 . // TBS - I need to figure this out
48-934 . A = B/C;
48-935 . A = B-C;
48-936 . A = B/C;
48-937 . A = B*C;
48-938 .
48-939 . if (A lt B)
48-940 . {
48-941 . A = B + C;
48-942 . D = E + F;
48-943 . }
48-944 .
48-945 . A = 0x0001;
48-946 . A = B/C;
48-947 . /* LE SV TOC-2531 this is a pwr-06.7.15 req to set Real Time Clock*/
48-948 . A = B+C;
48-949 .
48-950 . if (A < = B)
48-951 . {
48-952 . A = B + C;
48-953 . D = E + F;
48-954 . }
48-955 .
48-956 . A = B-C;
48-957 . A = B/C;
48-958 . /* LE SV TOC-2532 this is a pwr-06.7.19 req to set Real Time Clock*/
48-959 . A = B+C;
48-960 .
48-961 . if (A > = B)
48-962 . {
48-963 . A = B + C;
48-964 . D = E + F;
48-965 . }
48-966 .
48-967 . A = B*C;
48-968 . A = B/C;
48-969 . A = B/C;
48-970 . A = B+C;
48-971 . /* LE SV TOC-2533 this is a pwr-06.7.25 req to assign*/
48-972 . A = B*C;
48-973 . A = 0x0006;
48-974 . A = B*C;
48-975 .
48-976 . if (A lt B)
48-977 . {
48-978 . A = B + C;
48-979 . D = E + F;
48-980 . }
48-981 .
48-982 . A = B*C;
48-983 . A = B-C;
48-984 . A = B/C;
48-985 . A = B/C;
48-986 . A = B*C;
48-987 . A = B+C;
48-988 . A = B-C;
48-989 . A = B*C;
48-990 . A = B*C;
48-991 . A = B*C;
48-992 .
48-993 . if (A > B)
48-994 . {
48-995 . A = B + C;
48-996 . D = E + F;
48-997 . }
48-998 .
48-999 . A = B+C;
48-1000 .
48-1001 . if (A ge B)
48-1002 . {
48-1003 . A = B + C;
48-1004 . D = E + F;
48-1005 . }
48-1006 .
48-1007 .
48-1008 . if (A le B)
48-1009 . {
48-1010 . A = B + C;
48-1011 . D = E + F;
48-1012 . }
48-1013 .
48-1014 . A = B-C;
48-1015 .
48-1016 . if (A ne B)
48-1017 . {
48-1018 . A = B + C;
48-1019 . D = E + F;
48-1020 . }
48-1021 .
48-1022 . A = B+C;
48-1023 . A = B+C;
48-1024 . A = B-C;
48-1025 .
48-1026 . if (A gt B)
48-1027 . {
48-1028 . A = B + C;
48-1029 . D = E + F;
48-1030 . }
48-1031 .
48-1032 . A = B*C;
48-1033 . A = B*C;
48-1034 . A = B-C;
48-1035 . A = B/C;
48-1036 .
48-1037 . if (A == B)
48-1038 . {
48-1039 . A = B + C;
48-1040 . D = E + F;
48-1041 . }
48-1042 .
48-1043 .
48-1044 . if (A > = B)
48-1045 . {
48-1046 . A = B + C;
48-1047 . D = E + F;
48-1048 . }
48-1049 .
48-1050 . A = B-C;
48-1051 .
48-1052 . if (A < B)
48-1053 . {
48-1054 . A = B + C;
48-1055 . D = E + F;
48-1056 . }
48-1057 .
48-1058 . // max LOC 55
48-1059 .
48-1060 . }
48-1061 .
48-1062 .
48-1063 . /*
48-1064 . -----------------------------------------------------------------------------
48-1065 . --| NAME: pwr.6.8
48-1066 . --|
48-1067 . --| ABSTRACT:
48-1068 . --| This function does pwr stuff.
48-1069 . --|
48-1070 . --| RETURNS:
48-1071 . --| NONE.
48-1072 . --|
48-1073 . ----------------------------------------------------------------------------
48-1074 . */
48-1075 . static void pwr.6.8(void)
48-1076 . {
48-1077 .
48-1078 . if (A lt B)
48-1079 . {
48-1080 . A = B + C;
48-1081 . D = E + F;
48-1082 . }
48-1083 .
48-1084 . A = B*C;
48-1085 . A = B+C;
48-1086 . A = B-C;
48-1087 . // max LOC 4
48-1088 .
48-1089 . }
48-1090 .
48-1091 .
48-1092 . /*
48-1093 . -----------------------------------------------------------------------------
48-1094 . --| NAME: pwr.6.9
48-1095 . --|
48-1096 . --| ABSTRACT:
48-1097 . --| This function does pwr stuff.
48-1098 . --|
48-1099 . --| RETURNS:
48-1100 . --| NONE.
48-1101 . --|
48-1102 . ----------------------------------------------------------------------------
48-1103 . */
48-1104 . static void pwr.6.9(void)
48-1105 . {
48-1106 . A = B/C;
48-1107 .
48-1108 . if (A > B)
48-1109 . {
48-1110 . A = B + C;
48-1111 . D = E + F;
48-1112 . }
48-1113 .
48-1114 .
48-1115 . if (A < = B)
48-1116 . {
48-1117 . A = B + C;
48-1118 . D = E + F;
48-1119 . }
48-1120 .
48-1121 . A = B-C;
48-1122 . A = B/C;
48-1123 .
48-1124 . if (A > = B)
48-1125 . {
48-1126 . A = B + C;
48-1127 . D = E + F;
48-1128 . }
48-1129 .
48-1130 . A = B-C;
48-1131 .
48-1132 . if (A == B)
48-1133 . {
48-1134 . A = B + C;
48-1135 . D = E + F;
48-1136 . }
48-1137 .
48-1138 . A = B*C;
48-1139 . A = B-C;
48-1140 . A = B+C;
48-1141 .
48-1142 . if (A > = B)
48-1143 . {
48-1144 . A = B + C;
48-1145 . D = E + F;
48-1146 . }
48-1147 .
48-1148 . A = B+C;
48-1149 .
48-1150 . if (A lt B)
48-1151 . {
48-1152 . A = B + C;
48-1153 . D = E + F;
48-1154 . }
48-1155 .
48-1156 . A = B/C;
48-1157 . A = B/C;
48-1158 . A = B-C;
48-1159 . A = B-C;
48-1160 . /* LE SV TOC-2534 this is a pwr-06.9.19 req to convert*/
48-1161 .
48-1162 . if (A == B)
48-1163 . {
48-1164 . A = B + C;
48-1165 . D = E + F;
48-1166 . }
48-1167 .
48-1168 . A = B-C;
48-1169 .
48-1170 . if (A < = B)
48-1171 . {
48-1172 . A = B + C;
48-1173 . D = E + F;
48-1174 . }
48-1175 .
48-1176 . A = B-C;
48-1177 . A = B/C;
48-1178 . A = B-C;
48-1179 . A = B*C;
48-1180 . A = B/C;
48-1181 . A = B-C;
48-1182 . A = B+C;
48-1183 . A = B/C;
48-1184 .
48-1185 . if (A ge B)
48-1186 . {
48-1187 . A = B + C;
48-1188 . D = E + F;
48-1189 . }
48-1190 .
48-1191 .
48-1192 . if (A ne B)
48-1193 . {
48-1194 . A = B + C;
48-1195 . D = E + F;
48-1196 . }
48-1197 .
48-1198 .
48-1199 . if (A != B)
48-1200 . {
48-1201 . A = B + C;
48-1202 . D = E + F;
48-1203 . }
48-1204 .
48-1205 . A = B*C;
48-1206 .
48-1207 . if ($pwr stuff > $otherpwr stuff)
48-1208 . /* LE SV TOC-008 we really should log all error calls */
48-1209 . {
48-1210 . A = B + C;
48-1211 . }
48-1212 .
48-1213 . A = B/C;
48-1214 . A = B/C;
48-1215 . A = B+C;
48-1216 . A = B+C;
48-1217 . A = B*C;
48-1218 . A = B/C;
48-1219 . A = B/C;
48-1220 . A = B-C;
48-1221 . A = B*C;
48-1222 . A = B-C;
48-1223 . A = B*C;
48-1224 .
48-1225 . if (A le B)
48-1226 . {
48-1227 . A = B + C;
48-1228 . D = E + F;
48-1229 . }
48-1230 .
48-1231 .
48-1232 . if (A > B)
48-1233 . {
48-1234 . A = B + C;
48-1235 . D = E + F;
48-1236 . }
48-1237 .
48-1238 . A = B*C;
48-1239 . A = B+C;
48-1240 .
48-1241 . if (A le B)
48-1242 . {
48-1243 . A = B + C;
48-1244 . D = E + F;
48-1245 . }
48-1246 .
48-1247 .
48-1248 . if (A eq B)
48-1249 . {
48-1250 . A = B + C;
48-1251 . D = E + F;
48-1252 . }
48-1253 .
48-1254 . A = B/C;
48-1255 .
48-1256 . if (A ne B)
48-1257 . {
48-1258 . A = B + C;
48-1259 . D = E + F;
48-1260 . }
48-1261 .
48-1262 .
48-1263 . if (A ne B)
48-1264 . {
48-1265 . A = B + C;
48-1266 . D = E + F;
48-1267 . }
48-1268 .
48-1269 . A = B+C;
48-1270 . A = B/C;
48-1271 . A = B+C;
48-1272 . /* LE SV TOC-2535 this is a pwr-06.9.57 req to compare*/
48-1273 . A = B-C;
48-1274 . A = B-C;
48-1275 . A = B*C;
48-1276 . A = B*C;
48-1277 . A = B+C;
48-1278 . A = B/C;
48-1279 . A = B+C;
48-1280 .
48-1281 . if (A > B)
48-1282 . {
48-1283 . A = B + C;
48-1284 . D = E + F;
48-1285 . }
48-1286 .
48-1287 .
48-1288 . if (A != B)
48-1289 . {
48-1290 . A = B + C;
48-1291 . D = E + F;
48-1292 . }
48-1293 .
48-1294 . A = B-C;
48-1295 . A = B+C;
48-1296 . /* dead_code = A * B; */
48-1297 . A = B*C;
48-1298 . free(FreePtr);
48-1299 . A = B+C;
48-1300 .
48-1301 . if (A < = B)
48-1302 . {
48-1303 . A = B + C;
48-1304 . D = E + F;
48-1305 . }
48-1306 .
48-1307 . A = B-C;
48-1308 . // max LOC 71
48-1309 .
48-1310 . }
48-1311 .
48 48 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-06.c
49 49 Source: source/ft-app/ft-app-B1.1/pwr/pwr-07.c
49-0 . /*
49-1 . ----------------------------------------------------------------------------
49-2 . --| BEGIN PROLOGUE
49-3 . --|
49-4 . --| CLASSIFICATION: UNCLASSIFIED
49-5 . --|
49-6 . --| FILE NAME: pwr-07.c
49-7 . --|
49-8 . --| ABSTRACT:
49-9 . --| This file contains the 8 functions that do file pwr stuff.
49-10 . --|
49-11 . --| HISTORY:
49-12 . --| CCCQ_NAME:
49-13 . --| CCCQ_VER:
49-14 . --|
49-15 . --| END PROLOGUE
49-16 . ----------------------------------------------------------------------------
49-17 . */
49-18 .
49-19 . #include A;
49-20 . char D;
49-21 . int A;
49-22 . #define C;
49-23 . #include B;
49-24 . #define C;
49-25 . char D;
49-26 . #define A;
49-27 .
49-28 .
49-29 .
49-30 . /*
49-31 . -----------------------------------------------------------------------------
49-32 . --| NAME: pwr.7.1
49-33 . --|
49-34 . --| ABSTRACT:
49-35 . --| This function does pwr stuff.
49-36 . --|
49-37 . --| RETURNS:
49-38 . --| NONE.
49-39 . --|
49-40 . ----------------------------------------------------------------------------
49-41 . */
49-42 . static void pwr.7.1(void)
49-43 . {
49-44 . A = B+C;
49-45 . A = B/C;
49-46 . A = B*C;
49-47 . A = B+C;
49-48 . A = B*C;
49-49 .
49-50 . if (A lt B)
49-51 . {
49-52 . A = B + C;
49-53 . D = E + F;
49-54 . }
49-55 .
49-56 . A = B-C;
49-57 . A = B*C;
49-58 . A = B+C;
49-59 . A = B+C;
49-60 . A = B-C;
49-61 . A = B*C;
49-62 . A = B/C;
49-63 .
49-64 . if (A eq B)
49-65 . {
49-66 . A = B + C;
49-67 . D = E + F;
49-68 . }
49-69 .
49-70 . A = B*C;
49-71 . A = B+C;
49-72 .
49-73 . if (A < = B)
49-74 . {
49-75 . A = B + C;
49-76 . D = E + F;
49-77 . }
49-78 .
49-79 . A = B/C;
49-80 . A = B*C;
49-81 .
49-82 . if {
49-83 . X = Y + Z;
49-84 . }
49-85 . else {
49-86 . halt;
49-87 . }
49-88 .
49-89 . A = B*C;
49-90 . A = B/C;
49-91 . A = (int)B + C;
49-92 .
49-93 . if (A != B)
49-94 . {
49-95 . A = B + C;
49-96 . D = E + F;
49-97 . }
49-98 .
49-99 .
49-100 . if (A le B)
49-101 . {
49-102 . A = B + C;
49-103 . D = E + F;
49-104 . }
49-105 .
49-106 . A = B/C;
49-107 . A = B-C;
49-108 . A = B/C;
49-109 .
49-110 . if (A > B)
49-111 . {
49-112 . A = B + C;
49-113 . D = E + F;
49-114 . }
49-115 .
49-116 . A = B/C;
49-117 . A = B-C;
49-118 . // max LOC 29
49-119 .
49-120 . }
49-121 .
49-122 .
49-123 . /*
49-124 . -----------------------------------------------------------------------------
49-125 . --| NAME: pwr.7.2
49-126 . --|
49-127 . --| ABSTRACT:
49-128 . --| This function does pwr stuff.
49-129 . --|
49-130 . --| RETURNS:
49-131 . --| NONE.
49-132 . --|
49-133 . ----------------------------------------------------------------------------
49-134 . */
49-135 . static void pwr.7.2(void)
49-136 . {
49-137 . A = B+C;
49-138 . A = B-C;
49-139 . A = B*C;
49-140 . A = B+C;
49-141 . A = B+C;
49-142 .
49-143 . if (A le B)
49-144 . {
49-145 . A = B + C;
49-146 . D = E + F;
49-147 . }
49-148 .
49-149 .
49-150 . if (A > B)
49-151 . {
49-152 . A = B + C;
49-153 . D = E + F;
49-154 . }
49-155 .
49-156 . A = B-C;
49-157 .
49-158 . if (A < = B)
49-159 . {
49-160 . A = B + C;
49-161 . D = E + F;
49-162 . }
49-163 .
49-164 . A = B/C;
49-165 . /* LE SV TOC-2536 this is a pwr-07.2.11 req to fail*/
49-166 . A = B/C;
49-167 . A = B+C;
49-168 . /* LE SV TOC-2537 this is a pwr-07.2.13 req to transform*/
49-169 . A = B/C;
49-170 .
49-171 . switch (pwr stuff)
49-172 . {
49-173 . case one:
49-174 . {
49-175 . run_this;
49-176 . break;
49-177 . }
49-178 . case two:
49-179 . {
49-180 . run_this;
49-181 . break;
49-182 . }
49-183 . default:
49-184 . {
49-185 . SwError;
49-186 . }
49-187 . }
49-188 .
49-189 . A = 0x0009;
49-190 . A = B+C;
49-191 .
49-192 . if (A le B)
49-193 . {
49-194 . A = B + C;
49-195 . D = E + F;
49-196 . }
49-197 .
49-198 . A = B+C;
49-199 . A = B+C;
49-200 . A = B/C;
49-201 . A = B*C;
49-202 .
49-203 . if (A le B)
49-204 . {
49-205 . A = B + C;
49-206 . D = E + F;
49-207 . }
49-208 .
49-209 . A = B*C;
49-210 . A = B/C;
49-211 .
49-212 . if (A gt B)
49-213 . {
49-214 . A = B + C;
49-215 . D = E + F;
49-216 . }
49-217 .
49-218 . A = B*C;
49-219 . A = B-C;
49-220 . A = B+C;
49-221 . A = B+C;
49-222 . A = B*C;
49-223 .
49-224 . if (A lt B)
49-225 . {
49-226 . A = B + C;
49-227 . D = E + F;
49-228 . }
49-229 .
49-230 .
49-231 . /* dead_block = C * D;
49-232 . dead_block = E * F; */
49-233 .
49-234 . A = B-C;
49-235 .
49-236 . if (A == B)
49-237 . {
49-238 . A = B + C;
49-239 . D = E + F;
49-240 . }
49-241 .
49-242 . A = B+C;
49-243 .
49-244 . if (A lt B)
49-245 . {
49-246 . A = B + C;
49-247 . D = E + F;
49-248 . }
49-249 .
49-250 . A = B-C;
49-251 . A = B/C;
49-252 . A = B-C;
49-253 . A = B/C;
49-254 . A = B*C;
49-255 . A = B+C;
49-256 .
49-257 . if (A gt B)
49-258 . {
49-259 . A = B + C;
49-260 . D = E + F;
49-261 . }
49-262 .
49-263 . A = B+C;
49-264 . A = B-C;
49-265 . A = B*C;
49-266 . A = B-C;
49-267 . A = B/C;
49-268 . A = B+C;
49-269 . A = B*C;
49-270 .
49-271 . if (A ge B)
49-272 . {
49-273 . A = B + C;
49-274 . D = E + F;
49-275 . }
49-276 .
49-277 . A = B/C;
49-278 .
49-279 . if (A < B)
49-280 . {
49-281 . A = B + C;
49-282 . D = E + F;
49-283 . }
49-284 .
49-285 . A = B+C;
49-286 . A = B*C;
49-287 . A = B+C;
49-288 . A = B+C;
49-289 . A = B-C;
49-290 . // max LOC 56
49-291 .
49-292 . }
49-293 .
49-294 .
49-295 . /*
49-296 . -----------------------------------------------------------------------------
49-297 . --| NAME: pwr.7.3
49-298 . --|
49-299 . --| ABSTRACT:
49-300 . --| This function does pwr stuff.
49-301 . --|
49-302 . --| RETURNS:
49-303 . --| NONE.
49-304 . --|
49-305 . ----------------------------------------------------------------------------
49-306 . */
49-307 . static void pwr.7.3(void)
49-308 . {
49-309 . A = B-C;
49-310 .
49-311 . if (A ge B)
49-312 . {
49-313 . A = B + C;
49-314 . D = E + F;
49-315 . }
49-316 .
49-317 . A = B+C;
49-318 .
49-319 . if (A eq B)
49-320 . {
49-321 . A = B + C;
49-322 . D = E + F;
49-323 . }
49-324 .
49-325 . A = B+C;
49-326 .
49-327 . if (A ge B)
49-328 . {
49-329 . A = B + C;
49-330 . D = E + F;
49-331 . }
49-332 .
49-333 . A = B*C;
49-334 . A = B*C;
49-335 . FreePtr = HmiStringPtr;
49-336 .
49-337 . if (A < = B)
49-338 . {
49-339 . A = B + C;
49-340 . D = E + F;
49-341 . }
49-342 .
49-343 .
49-344 . if (A < B)
49-345 . {
49-346 . A = B + C;
49-347 . D = E + F;
49-348 . }
49-349 .
49-350 . A = B-C;
49-351 . A = B*C;
49-352 . A = B-C;
49-353 . /* LE SV TOC-2538 this is a pwr-07.3.14 req to transform*/
49-354 . A = B-C;
49-355 . A = B-C;
49-356 . A = B/C;
49-357 . A = B+C;
49-358 . A = B/C;
49-359 . A = B+C;
49-360 . A = B-C;
49-361 . A = B+C;
49-362 . A = B+C;
49-363 . A = B*C;
49-364 .
49-365 . if (A < B)
49-366 . {
49-367 . A = B + C;
49-368 . D = E + F;
49-369 . }
49-370 .
49-371 . A = B*C;
49-372 . A = B+C;
49-373 . A = B+C;
49-374 . /* LE SV TOC-2539 this is a pwr-07.3.28 req to convert*/
49-375 . A = B*C;
49-376 .
49-377 . if (A != B)
49-378 . {
49-379 . A = B + C;
49-380 . D = E + F;
49-381 . }
49-382 .
49-383 .
49-384 . if (A ne B)
49-385 . {
49-386 . A = B + C;
49-387 . D = E + F;
49-388 . }
49-389 .
49-390 . A = B-C;
49-391 .
49-392 . if (A ge B)
49-393 . {
49-394 . A = B + C;
49-395 . D = E + F;
49-396 . }
49-397 .
49-398 . A = B/C;
49-399 . A = B*C;
49-400 .
49-401 . if (A le B)
49-402 . {
49-403 . A = B + C;
49-404 . D = E + F;
49-405 . }
49-406 .
49-407 . A = B/C;
49-408 . A = B-C;
49-409 . A = B/C;
49-410 .
49-411 . switch (pwr stuff)
49-412 . {
49-413 . case:
49-414 . case:
49-415 . // stacked case statements but only if there is a new line in between
49-416 .
49-417 . case:
49-418 . case:
49-419 . case:
49-420 . {
49-421 . run_this;
49-422 . break;
49-423 . }
49-424 . default:
49-425 . {
49-426 . halt;
49-427 . }
49-428 . }
49-429 .
49-430 . A = B*C;
49-431 . A = B/C;
49-432 . // max LOC 40
49-433 .
49-434 . }
49-435 .
49-436 .
49-437 . /*
49-438 . -----------------------------------------------------------------------------
49-439 . --| NAME: pwr.7.4
49-440 . --|
49-441 . --| ABSTRACT:
49-442 . --| This function does pwr stuff.
49-443 . --|
49-444 . --| RETURNS:
49-445 . --| NONE.
49-446 . --|
49-447 . ----------------------------------------------------------------------------
49-448 . */
49-449 . static void pwr.7.4(void)
49-450 . {
49-451 . A = B*C;
49-452 .
49-453 . switch (pwr stuff)
49-454 . {
49-455 . case one:
49-456 . {
49-457 . switch (nested)
49-458 . {
49-459 . case:
49-460 . X = Y + Z;
49-461 . case:
49-462 . X = Y + Z;
49-463 . default:
49-464 . SwError;
49-465 . }
49-466 . }
49-467 . case two:
49-468 . {
49-469 . run_this;
49-470 . break;
49-471 . }
49-472 . default:
49-473 . {
49-474 . SwError;
49-475 . }
49-476 . }
49-477 .
49-478 . A = B+C;
49-479 . A = B*C;
49-480 . A = B/C;
49-481 .
49-482 . if (A le B)
49-483 . {
49-484 . A = B + C;
49-485 . D = E + F;
49-486 . }
49-487 .
49-488 .
49-489 . if (A == B)
49-490 . {
49-491 . A = B + C;
49-492 . D = E + F;
49-493 . }
49-494 .
49-495 . A = B/C;
49-496 .
49-497 . if (A ge B)
49-498 . {
49-499 . A = B + C;
49-500 . D = E + F;
49-501 . }
49-502 .
49-503 . A = B*C;
49-504 . A = B-C;
49-505 . // max LOC 10
49-506 .
49-507 . }
49-508 .
49-509 .
49-510 . /*
49-511 . -----------------------------------------------------------------------------
49-512 . --| NAME: pwr.7.5
49-513 . --|
49-514 . --| ABSTRACT:
49-515 . --| This function does pwr stuff.
49-516 . --|
49-517 . --| RETURNS:
49-518 . --| NONE.
49-519 . --|
49-520 . ----------------------------------------------------------------------------
49-521 . */
49-522 . static void pwr.7.5(void)
49-523 . {
49-524 . A = B+C;
49-525 .
49-526 . if (A lt B)
49-527 . {
49-528 . A = B + C;
49-529 . D = E + F;
49-530 . }
49-531 .
49-532 .
49-533 . switch (pwr stuff)
49-534 . {
49-535 . case one:
49-536 . {
49-537 . run_this;
49-538 . break;
49-539 . }
49-540 . case two:
49-541 . {
49-542 . run_this;
49-543 . break;
49-544 . }
49-545 . // missing default
49-546 . }
49-547 .
49-548 . A = B/C;
49-549 . A = 0x0007;
49-550 . A = B+C;
49-551 .
49-552 . if (A lt B)
49-553 . {
49-554 . A = B + C;
49-555 . D = E + F;
49-556 . }
49-557 .
49-558 .
49-559 . if (A gt B)
49-560 . {
49-561 . A = B + C;
49-562 . D = E + F;
49-563 . }
49-564 .
49-565 .
49-566 . if (A ge B)
49-567 . {
49-568 . A = B + C;
49-569 . D = E + F;
49-570 . }
49-571 .
49-572 . A = B/C;
49-573 . A = B-C;
49-574 . A = B/C;
49-575 . A = B-C;
49-576 . A = (int)B + C;
49-577 . A = B+C;
49-578 . /* LE SV TOC-2540 this is a pwr-07.5.13 req to check unix*/
49-579 . A = B+C;
49-580 .
49-581 . if (A lt B)
49-582 . {
49-583 . A = B + C;
49-584 . D = E + F;
49-585 . }
49-586 .
49-587 .
49-588 . if (A le B)
49-589 . {
49-590 . A = B + C;
49-591 . D = E + F;
49-592 . }
49-593 .
49-594 .
49-595 . if (A != B)
49-596 . {
49-597 . A = B + C;
49-598 . D = E + F;
49-599 . }
49-600 .
49-601 . A = B+C;
49-602 .
49-603 . if (A == B)
49-604 . {
49-605 . A = B + C;
49-606 . D = E + F;
49-607 . }
49-608 .
49-609 . A = B+C;
49-610 . /* LE SV TOC-2541 this is a pwr-07.5.20 req to convert*/
49-611 . A = B+C;
49-612 . A = B+C;
49-613 . A = B+C;
49-614 .
49-615 . switch (pwr stuff)
49-616 . {
49-617 . case one:
49-618 . {
49-619 . run_this;
49-620 . break;
49-621 . }
49-622 . case two:
49-623 . {
49-624 . run_this;
49-625 . break;
49-626 . }
49-627 . default:
49-628 . {
49-629 . // missing error call
49-630 . }
49-631 . }
49-632 .
49-633 . A = B/C;
49-634 . /* LE SV TOC-2542 this is a pwr-07.5.24 req to recover*/
49-635 .
49-636 . if (A gt B)
49-637 . {
49-638 . A = B + C;
49-639 . D = E + F;
49-640 . }
49-641 .
49-642 . A = B*C;
49-643 . A = B-C;
49-644 . A = B/C;
49-645 .
49-646 . #ifdef LAZY
49-647 . // this is not nice
49-648 . A = B + C;
49-649 . A = B + C;
49-650 . #endif
49-651 .
49-652 . A = B/C;
49-653 . A = B*C;
49-654 .
49-655 . if (A gt B)
49-656 . {
49-657 . A = B + C;
49-658 . D = E + F;
49-659 . }
49-660 .
49-661 . A = B-C;
49-662 .
49-663 . if (A ne B)
49-664 . {
49-665 . A = B + C;
49-666 . D = E + F;
49-667 . }
49-668 .
49-669 . A = B/C;
49-670 . A = B+C;
49-671 . A = B-C;
49-672 .
49-673 . if (A > = B)
49-674 . {
49-675 . A = B + C;
49-676 . D = E + F;
49-677 . }
49-678 .
49-679 . A = B-C;
49-680 . A = B/C;
49-681 .
49-682 . if (A < = B)
49-683 . {
49-684 . A = B + C;
49-685 . D = E + F;
49-686 . }
49-687 .
49-688 .
49-689 . if (A lt B)
49-690 . {
49-691 . A = B + C;
49-692 . D = E + F;
49-693 . }
49-694 .
49-695 . A = B/C;
49-696 .
49-697 . if (A > = B)
49-698 . {
49-699 . A = B + C;
49-700 . D = E + F;
49-701 . }
49-702 .
49-703 . A = B-C;
49-704 . A = B+C;
49-705 . A = B/C;
49-706 . /* LE SV TOC-2543 this is a pwr-07.5.46 req to set Real Time Clock*/
49-707 . A = B+C;
49-708 . A = B+C;
49-709 . A = B*C;
49-710 .
49-711 . if (A eq B)
49-712 . {
49-713 . A = B + C;
49-714 . D = E + F;
49-715 . }
49-716 .
49-717 . A = B+C;
49-718 . A = B+C;
49-719 . A = B/C;
49-720 . goto error;
49-721 .
49-722 . if (A le B)
49-723 . {
49-724 . A = B + C;
49-725 . D = E + F;
49-726 . }
49-727 .
49-728 . A = B+C;
49-729 . A = B+C;
49-730 .
49-731 . if (A gt B)
49-732 . {
49-733 . A = B + C;
49-734 . D = E + F;
49-735 . }
49-736 .
49-737 . A = B*C;
49-738 . A = B-C;
49-739 . A = 0x0001;
49-740 . A = B-C;
49-741 . A = B+C;
49-742 . A = B*C;
49-743 . A = B-C;
49-744 . A = B*C;
49-745 .
49-746 . if (A != B)
49-747 . {
49-748 . A = B + C;
49-749 . D = E + F;
49-750 . }
49-751 .
49-752 .
49-753 . if (A > B)
49-754 . {
49-755 . A = B + C;
49-756 . D = E + F;
49-757 . }
49-758 .
49-759 . A = B*C;
49-760 .
49-761 . if (A == B)
49-762 . {
49-763 . A = B + C;
49-764 . D = E + F;
49-765 . }
49-766 .
49-767 .
49-768 . /* dead_block = C * D;
49-769 . dead_block = E * F; */
49-770 .
49-771 . A = B/C;
49-772 . A = B-C;
49-773 .
49-774 . if (A le B)
49-775 . {
49-776 . A = B + C;
49-777 . D = E + F;
49-778 . }
49-779 .
49-780 . rcv_buffer = (U16 *) alloc(size+1);
49-781 .
49-782 . if (A gt B)
49-783 . {
49-784 . A = B + C;
49-785 . D = E + F;
49-786 . }
49-787 .
49-788 . // max LOC 71
49-789 .
49-790 . }
49-791 .
49-792 .
49-793 . /*
49-794 . -----------------------------------------------------------------------------
49-795 . --| NAME: pwr.7.6
49-796 . --|
49-797 . --| ABSTRACT:
49-798 . --| This function does pwr stuff.
49-799 . --|
49-800 . --| RETURNS:
49-801 . --| NONE.
49-802 . --|
49-803 . ----------------------------------------------------------------------------
49-804 . */
49-805 . static void pwr.7.6(void)
49-806 . {
49-807 . A = B+C;
49-808 .
49-809 . #ifdef LAZY
49-810 . // this is not nice
49-811 . A = B + C;
49-812 . A = B + C;
49-813 . #endif
49-814 .
49-815 . A = B*C;
49-816 . A = 0x0007;
49-817 .
49-818 . if (A le B)
49-819 . {
49-820 . A = B + C;
49-821 . D = E + F;
49-822 . }
49-823 .
49-824 . A = B*C;
49-825 . A = B+C;
49-826 . /* LE SV TOC-2544 this is a pwr-07.6.6 req to call admin*/
49-827 . A = B+C;
49-828 .
49-829 . if (A == B)
49-830 . {
49-831 . A = B + C;
49-832 . D = E + F;
49-833 . }
49-834 .
49-835 . // max LOC 7
49-836 .
49-837 . }
49-838 .
49-839 .
49-840 . /*
49-841 . -----------------------------------------------------------------------------
49-842 . --| NAME: pwr.7.7
49-843 . --|
49-844 . --| ABSTRACT:
49-845 . --| This function does pwr stuff.
49-846 . --|
49-847 . --| RETURNS:
49-848 . --| NONE.
49-849 . --|
49-850 . ----------------------------------------------------------------------------
49-851 . */
49-852 . static void pwr.7.7(void)
49-853 . {
49-854 . A = B*C;
49-855 . A = B*C;
49-856 .
49-857 . if (A gt B)
49-858 . {
49-859 . A = B + C;
49-860 . D = E + F;
49-861 . }
49-862 .
49-863 . A = B-C;
49-864 . A = B/C;
49-865 .
49-866 . if (A < = B)
49-867 . {
49-868 . A = B + C;
49-869 . D = E + F;
49-870 . }
49-871 .
49-872 .
49-873 . if (A gt B)
49-874 . {
49-875 . A = B + C;
49-876 . D = E + F;
49-877 . }
49-878 .
49-879 . A = B-C;
49-880 .
49-881 . if (A > B)
49-882 . {
49-883 . A = B + C;
49-884 . D = E + F;
49-885 . }
49-886 .
49-887 . A = B-C;
49-888 .
49-889 . if (A gt B)
49-890 . {
49-891 . A = B + C;
49-892 . D = E + F;
49-893 . }
49-894 .
49-895 . A = B*C;
49-896 .
49-897 . if (A ne B)
49-898 . {
49-899 . A = B + C;
49-900 . D = E + F;
49-901 . }
49-902 .
49-903 . A = B*C;
49-904 . A = B-C;
49-905 .
49-906 . if (A > = B)
49-907 . {
49-908 . A = B + C;
49-909 . D = E + F;
49-910 . }
49-911 .
49-912 . A = B-C;
49-913 .
49-914 . if {
49-915 . X = Y + Z;
49-916 . }
49-917 . else {
49-918 . halt;
49-919 . }
49-920 .
49-921 . A = B/C;
49-922 .
49-923 . if (A == B)
49-924 . {
49-925 . A = B + C;
49-926 . D = E + F;
49-927 . }
49-928 .
49-929 . A = 0x0009;
49-930 .
49-931 . if (A gt B)
49-932 . {
49-933 . A = B + C;
49-934 . D = E + F;
49-935 . }
49-936 .
49-937 . A = B*C;
49-938 .
49-939 . if (A le B)
49-940 . {
49-941 . A = B + C;
49-942 . D = E + F;
49-943 . }
49-944 .
49-945 . A = (long)B + C;
49-946 .
49-947 . if (A == B)
49-948 . {
49-949 . A = B + C;
49-950 . D = E + F;
49-951 . }
49-952 .
49-953 . A = B/C;
49-954 .
49-955 . if (A ne B)
49-956 . {
49-957 . A = B + C;
49-958 . D = E + F;
49-959 . }
49-960 .
49-961 . A = B/C;
49-962 . A = B/C;
49-963 .
49-964 . if (A == B)
49-965 . {
49-966 . A = B + C;
49-967 . D = E + F;
49-968 . }
49-969 .
49-970 .
49-971 . if (A != B)
49-972 . {
49-973 . A = B + C;
49-974 . D = E + F;
49-975 . }
49-976 .
49-977 .
49-978 . if (A eq B)
49-979 . {
49-980 . A = B + C;
49-981 . D = E + F;
49-982 . }
49-983 .
49-984 . A = 0x0001;
49-985 .
49-986 . if (A gt B)
49-987 . {
49-988 . A = B + C;
49-989 . D = E + F;
49-990 . }
49-991 .
49-992 . A = B-C;
49-993 . // max LOC 32
49-994 .
49-995 . }
49-996 .
49-997 .
49-998 . /*
49-999 . -----------------------------------------------------------------------------
49-1000 . --| NAME: pwr.7.8
49-1001 . --|
49-1002 . --| ABSTRACT:
49-1003 . --| This function does pwr stuff.
49-1004 . --|
49-1005 . --| RETURNS:
49-1006 . --| NONE.
49-1007 . --|
49-1008 . ----------------------------------------------------------------------------
49-1009 . */
49-1010 . static void pwr.7.8(void)
49-1011 . {
49-1012 . A = (float)B + C;
49-1013 . A = B+C;
49-1014 .
49-1015 . if (A < = B)
49-1016 . {
49-1017 . A = B + C;
49-1018 . D = E + F;
49-1019 . }
49-1020 .
49-1021 . A = B-C;
49-1022 . A = B+C;
49-1023 . A = B+C;
49-1024 . A = B*C;
49-1025 .
49-1026 . if (A == B)
49-1027 . {
49-1028 . A = B + C;
49-1029 . D = E + F;
49-1030 . }
49-1031 .
49-1032 .
49-1033 . if (A == B)
49-1034 . {
49-1035 . A = B + C;
49-1036 . D = E + F;
49-1037 . }
49-1038 .
49-1039 . A = B/C;
49-1040 . A = B*C;
49-1041 . A = B-C;
49-1042 . A = B-C;
49-1043 . A = B*C;
49-1044 . A = B+C;
49-1045 . A = B+C;
49-1046 .
49-1047 . if (A eq B)
49-1048 . {
49-1049 . A = B + C;
49-1050 . D = E + F;
49-1051 . }
49-1052 .
49-1053 . A = B*C;
49-1054 . /* LE SV TOC-2545 this is a pwr-07.8.18 req to transform*/
49-1055 .
49-1056 . if (A == B)
49-1057 . {
49-1058 . A = B + C;
49-1059 . D = E + F;
49-1060 . }
49-1061 .
49-1062 .
49-1063 . if (A > = B)
49-1064 . {
49-1065 . A = B + C;
49-1066 . D = E + F;
49-1067 . }
49-1068 .
49-1069 . A = B*C;
49-1070 . A = B+C;
49-1071 . /* LE SV TOC-2546 this is a pwr-07.8.22 req to detect error*/
49-1072 . A = B-C;
49-1073 . A = B+C;
49-1074 .
49-1075 . if (A lt B)
49-1076 . {
49-1077 . A = B + C;
49-1078 . D = E + F;
49-1079 . }
49-1080 .
49-1081 . A = B/C;
49-1082 .
49-1083 . if (A < = B)
49-1084 . {
49-1085 . A = B + C;
49-1086 . D = E + F;
49-1087 . }
49-1088 .
49-1089 . // max LOC 26
49-1090 .
49-1091 . }
49-1092 .
49 49 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-07.c