1 1 Source: source/pr-app/pr-app-CA123/ca/ca-01.c
1-0 . /*
1-1 . ----------------------------------------------------------------------------
1-2 . --| BEGIN PROLOGUE
1-3 . --|
1-4 . --| CLASSIFICATION: UNCLASSIFIED
1-5 . --|
1-6 . --| FILE NAME: ca-01.c
1-7 . --|
1-8 . --| ABSTRACT:
1-9 . --| This file contains the 10 functions that do file ca stuff.
1-10 . --|
1-11 . --| HISTORY:
1-12 . --| CCCQ_NAME:
1-13 . --| CCCQ_VER:
1-14 . --|
1-15 . --| END PROLOGUE
1-16 . ----------------------------------------------------------------------------
1-17 . */
1-18 .
1-19 . #include D;
1-20 . #include C;
1-21 . #define B;
1-22 . double C;
1-23 . int A;
1-24 . #define C;
1-25 . #include B;
1-26 . #define D;
1-27 . float B;
1-28 .
1-29 .
1-30 .
1-31 . /*
1-32 . -----------------------------------------------------------------------------
1-33 . --| NAME: ca.1.1
1-34 . --|
1-35 . --| ABSTRACT:
1-36 . --| This function does ca stuff.
1-37 . --|
1-38 . --| RETURNS:
1-39 . --| NONE.
1-40 . --|
1-41 . ----------------------------------------------------------------------------
1-42 . */
1-43 . static void ca.1.1(void)
1-44 . {
1-45 . send_buffer = (U16 *) malloc(size+1);
1-46 . A = B*C;
1-47 . A = B*C;
1-48 . A = B/C;
1-49 . A = B+C;
1-50 .
1-51 . if (A == B)
1-52 . {
1-53 . A = B + C;
1-54 . D = E + F;
1-55 . }
1-56 .
1-57 . A = B+C;
1-58 . A = B-C;
1-59 . A = B/C;
1-60 .
1-61 . if (A gt B)
1-62 . {
1-63 . A = B + C;
1-64 . D = E + F;
1-65 . }
1-66 .
1-67 . A = B*C;
1-68 .
1-69 . if (A > B)
1-70 . {
1-71 . A = B + C;
1-72 . D = E + F;
1-73 . }
1-74 .
1-75 . A = B-C;
1-76 . A = B+C;
1-77 . A = B*C;
1-78 . A = B-C;
1-79 .
1-80 . if (A < = B)
1-81 . {
1-82 . A = B + C;
1-83 . D = E + F;
1-84 . }
1-85 .
1-86 .
1-87 . if (A != B)
1-88 . {
1-89 . A = B + C;
1-90 . D = E + F;
1-91 . }
1-92 .
1-93 .
1-94 . if (A gt B)
1-95 . {
1-96 . A = B + C;
1-97 . D = E + F;
1-98 . }
1-99 .
1-100 . A = B+C;
1-101 . A = B+C;
1-102 .
1-103 . switch (ca stuff)
1-104 . {
1-105 . case one:
1-106 . {
1-107 . run_this;
1-108 . break;
1-109 . }
1-110 . case two:
1-111 . {
1-112 . run_this;
1-113 . break;
1-114 . }
1-115 . default:
1-116 . {
1-117 . SwError;
1-118 . }
1-119 . }
1-120 .
1-121 .
1-122 . if (A ge B)
1-123 . {
1-124 . A = B + C;
1-125 . D = E + F;
1-126 . }
1-127 .
1-128 . A = B*C;
1-129 .
1-130 . if (A == B)
1-131 . {
1-132 . A = B + C;
1-133 . D = E + F;
1-134 . }
1-135 .
1-136 . A = B/C;
1-137 . A = B/C;
1-138 . A = B+C;
1-139 . A = B/C;
1-140 .
1-141 . if (A lt B)
1-142 . {
1-143 . A = B + C;
1-144 . D = E + F;
1-145 . }
1-146 .
1-147 . /* LE SV TOC-1001 this is a ca-01.1.30 req to translate*/
1-148 .
1-149 . if (A gt B)
1-150 . {
1-151 . A = B + C;
1-152 . D = E + F;
1-153 . }
1-154 .
1-155 .
1-156 . if (A le B)
1-157 . {
1-158 . A = B + C;
1-159 . D = E + F;
1-160 . }
1-161 .
1-162 . A = B/C;
1-163 . A = B/C;
1-164 . A = B/C;
1-165 . A = B+C;
1-166 . A = B-C;
1-167 . A = B*C;
1-168 . A = B*C;
1-169 . A = 0x0008;
1-170 .
1-171 . if (A == B)
1-172 . {
1-173 . A = B + C;
1-174 . D = E + F;
1-175 . }
1-176 .
1-177 . A = B/C;
1-178 . A = B*C;
1-179 .
1-180 . if (A < B)
1-181 . {
1-182 . A = B + C;
1-183 . D = E + F;
1-184 . }
1-185 .
1-186 . A = B/C;
1-187 . A = B-C;
1-188 . A = B+C;
1-189 . A = B-C;
1-190 . A = B/C;
1-191 . A = B/C;
1-192 . A = 0x0002;
1-193 .
1-194 . if (A != B)
1-195 . {
1-196 . A = B + C;
1-197 . D = E + F;
1-198 . }
1-199 .
1-200 . A = B-C;
1-201 . A = B*C;
1-202 . A = B+C;
1-203 . A = 0x0004;
1-204 .
1-205 . switch (ca stuff)
1-206 . {
1-207 . case one:
1-208 . {
1-209 . run_this;
1-210 . break;
1-211 . }
1-212 . case two:
1-213 . {
1-214 . run_this;
1-215 . break;
1-216 . }
1-217 . default:
1-218 . {
1-219 . SwError;
1-220 . }
1-221 . }
1-222 .
1-223 .
1-224 . if (A != B)
1-225 . {
1-226 . A = B + C;
1-227 . D = E + F;
1-228 . }
1-229 .
1-230 .
1-231 . if (A < = B)
1-232 . {
1-233 . A = B + C;
1-234 . D = E + F;
1-235 . }
1-236 .
1-237 .
1-238 . if (A ne B)
1-239 . {
1-240 . A = B + C;
1-241 . D = E + F;
1-242 . }
1-243 .
1-244 . A = B/C;
1-245 . A = B*C;
1-246 .
1-247 . if (A < = B)
1-248 . {
1-249 . A = B + C;
1-250 . D = E + F;
1-251 . }
1-252 .
1-253 . A = B*C;
1-254 .
1-255 . if (A lt B)
1-256 . {
1-257 . A = B + C;
1-258 . D = E + F;
1-259 . }
1-260 .
1-261 .
1-262 . if (A gt B)
1-263 . {
1-264 . A = B + C;
1-265 . D = E + F;
1-266 . }
1-267 .
1-268 . A = B*C;
1-269 . A = B*C;
1-270 .
1-271 . if (A < B)
1-272 . {
1-273 . A = B + C;
1-274 . D = E + F;
1-275 . }
1-276 .
1-277 .
1-278 . if (A == B)
1-279 . {
1-280 . A = B + C;
1-281 . D = E + F;
1-282 . }
1-283 .
1-284 . A = B-C;
1-285 . A = B+C;
1-286 . A = B*C;
1-287 .
1-288 . if (A le B)
1-289 . {
1-290 . A = B + C;
1-291 . D = E + F;
1-292 . }
1-293 .
1-294 . /* LE SV TOC-1002 this is a ca-01.1.71 req to call admin*/
1-295 .
1-296 . if (A lt B)
1-297 . {
1-298 . A = B + C;
1-299 . D = E + F;
1-300 . }
1-301 .
1-302 . A = B/C;
1-303 .
1-304 . if (A > = B)
1-305 . {
1-306 . A = B + C;
1-307 . D = E + F;
1-308 . }
1-309 .
1-310 . A = B/C;
1-311 .
1-312 . if (A le B)
1-313 . {
1-314 . A = B + C;
1-315 . D = E + F;
1-316 . }
1-317 .
1-318 . A = B+C;
1-319 . A = B*C;
1-320 .
1-321 . if (A < = B)
1-322 . {
1-323 . A = B + C;
1-324 . D = E + F;
1-325 . }
1-326 .
1-327 . // max LOC 78
1-328 .
1-329 . }
1-330 .
1-331 .
1-332 . /*
1-333 . -----------------------------------------------------------------------------
1-334 . --| NAME: ca.1.2
1-335 . --|
1-336 . --| ABSTRACT:
1-337 . --| This function does ca stuff.
1-338 . --|
1-339 . --| RETURNS:
1-340 . --| NONE.
1-341 . --|
1-342 . ----------------------------------------------------------------------------
1-343 . */
1-344 . static void ca.1.2(void)
1-345 . {
1-346 .
1-347 . if (A != B)
1-348 . {
1-349 . A = B + C;
1-350 . D = E + F;
1-351 . }
1-352 .
1-353 .
1-354 . switch (ca stuff)
1-355 . {
1-356 . case one:
1-357 . {
1-358 . run_this;
1-359 . break;
1-360 . }
1-361 . case two:
1-362 . {
1-363 . run_this;
1-364 . break;
1-365 . }
1-366 . default:
1-367 . {
1-368 . SwError;
1-369 . }
1-370 . }
1-371 .
1-372 . /* LE SV TOC-1003 this is a ca-01.2.3 req to update*/
1-373 . A = B*C;
1-374 . A = B*C;
1-375 .
1-376 . if (A == B)
1-377 . {
1-378 . A = B + C;
1-379 . D = E + F;
1-380 . }
1-381 .
1-382 . A = B/C;
1-383 . A = B+C;
1-384 . A = B-C;
1-385 . A = B-C;
1-386 . A = B*C;
1-387 . A = B*C;
1-388 . /* LE SV TOC-1004 this is a ca-01.2.12 req to audit*/
1-389 . A = B+C;
1-390 . A = B+C;
1-391 .
1-392 . if (A lt B)
1-393 . {
1-394 . A = B + C;
1-395 . D = E + F;
1-396 . }
1-397 .
1-398 .
1-399 . if (A != B)
1-400 . {
1-401 . A = B + C;
1-402 . D = E + F;
1-403 . }
1-404 .
1-405 . A = B+C;
1-406 .
1-407 . if (A le B)
1-408 . {
1-409 . A = B + C;
1-410 . D = E + F;
1-411 . }
1-412 .
1-413 . A = B-C;
1-414 .
1-415 . if (A le B)
1-416 . {
1-417 . A = B + C;
1-418 . D = E + F;
1-419 . }
1-420 .
1-421 . A = B/C;
1-422 . A = B/C;
1-423 .
1-424 . if (A gt B)
1-425 . {
1-426 . A = B + C;
1-427 . D = E + F;
1-428 . }
1-429 .
1-430 .
1-431 . if (A ne B)
1-432 . {
1-433 . A = B + C;
1-434 . D = E + F;
1-435 . }
1-436 .
1-437 .
1-438 . if (A ge B)
1-439 . {
1-440 . A = B + C;
1-441 . D = E + F;
1-442 . }
1-443 .
1-444 . A = B*C;
1-445 . A = B/C;
1-446 . A = B+C;
1-447 . A = B-C;
1-448 . A = (long)B + C;
1-449 .
1-450 . if (A eq B)
1-451 . {
1-452 . A = B + C;
1-453 . D = E + F;
1-454 . }
1-455 .
1-456 . /* LE SV TOC-1005 this is a ca-01.2.30 req to store*/
1-457 .
1-458 . if (A < = B)
1-459 . {
1-460 . A = B + C;
1-461 . D = E + F;
1-462 . }
1-463 .
1-464 . A = B-C;
1-465 . free(FreePtr);
1-466 . A = B-C;
1-467 .
1-468 . if (A ne B)
1-469 . {
1-470 . A = B + C;
1-471 . D = E + F;
1-472 . }
1-473 .
1-474 . A = B/C;
1-475 . A = B-C;
1-476 . A = B+C;
1-477 . /* LE SV TOC-1006 this is a ca-01.2.37 req to convert*/
1-478 .
1-479 . if (A ge B)
1-480 . {
1-481 . A = B + C;
1-482 . D = E + F;
1-483 . }
1-484 .
1-485 . A = B-C;
1-486 . A = B/C;
1-487 .
1-488 . if (A < = B)
1-489 . {
1-490 . A = B + C;
1-491 . D = E + F;
1-492 . }
1-493 .
1-494 . A = B/C;
1-495 . A = B/C;
1-496 . A = B+C;
1-497 .
1-498 . if (A le B)
1-499 . {
1-500 . A = B + C;
1-501 . D = E + F;
1-502 . }
1-503 .
1-504 . A = B+C;
1-505 .
1-506 . #ifdef LAZY
1-507 . // this is not nice
1-508 . A = B + C;
1-509 . A = B + C;
1-510 . #endif
1-511 .
1-512 . A = B*C;
1-513 .
1-514 . if (A le B)
1-515 . {
1-516 . A = B + C;
1-517 . D = E + F;
1-518 . }
1-519 .
1-520 . A = B/C;
1-521 . A = B-C;
1-522 .
1-523 . if (A < B)
1-524 . {
1-525 . A = B + C;
1-526 . D = E + F;
1-527 . }
1-528 .
1-529 .
1-530 . if (A eq B)
1-531 . {
1-532 . A = B + C;
1-533 . D = E + F;
1-534 . }
1-535 .
1-536 . A = B-C;
1-537 . A = B+C;
1-538 . A = B*C;
1-539 . A = B-C;
1-540 . A = B-C;
1-541 . A = B+C;
1-542 . A = B/C;
1-543 . A = B-C;
1-544 . A = B+C;
1-545 . A = B+C;
1-546 . /* LE SV TOC-1007 this is a ca-01.2.62 req to compare*/
1-547 . A = B-C;
1-548 . send_buffer = (U16 *) malloc(size+1);
1-549 . A = B-C;
1-550 .
1-551 . /* dead_code = B + C;
1-552 . dead_code = D + E;
1-553 . dead_code = F + G; */
1-554 .
1-555 . A = B-C;
1-556 . do forever;
1-557 . A = B+C;
1-558 . // max LOC 65
1-559 .
1-560 . }
1-561 .
1-562 .
1-563 . /*
1-564 . -----------------------------------------------------------------------------
1-565 . --| NAME: ca.1.3
1-566 . --|
1-567 . --| ABSTRACT:
1-568 . --| This function does ca stuff.
1-569 . --|
1-570 . --| RETURNS:
1-571 . --| NONE.
1-572 . --|
1-573 . ----------------------------------------------------------------------------
1-574 . */
1-575 . static void ca.1.3(void)
1-576 . {
1-577 .
1-578 . if (A > B)
1-579 . {
1-580 . A = B + C;
1-581 . D = E + F;
1-582 . }
1-583 .
1-584 .
1-585 . switch (ca stuff)
1-586 . {
1-587 . case one:
1-588 . {
1-589 . run_this;
1-590 . break;
1-591 . }
1-592 . case two:
1-593 . {
1-594 . run_this;
1-595 . break;
1-596 . }
1-597 . default:
1-598 . {
1-599 . SwError;
1-600 . }
1-601 . }
1-602 .
1-603 . A = B/C;
1-604 . A = B*C;
1-605 . A = 0x0007;
1-606 . A = B/C;
1-607 .
1-608 . if (A < B)
1-609 . {
1-610 . A = B + C;
1-611 . D = E + F;
1-612 . }
1-613 .
1-614 . A = B*C;
1-615 . A = B*C;
1-616 . A = B-C;
1-617 . A = B-C;
1-618 . A = B*C;
1-619 .
1-620 . if (A ne B)
1-621 . {
1-622 . A = B + C;
1-623 . D = E + F;
1-624 . }
1-625 .
1-626 . A = B*C;
1-627 . A = B+C;
1-628 . /* LE SV TOC-1008 this is a ca-01.3.15 req to recover*/
1-629 .
1-630 . if (A gt B)
1-631 . {
1-632 . A = B + C;
1-633 . D = E + F;
1-634 . }
1-635 .
1-636 . A = B/C;
1-637 . A = B/C;
1-638 . A = 0x0004;
1-639 . A = B/C;
1-640 .
1-641 . if (A > = B)
1-642 . {
1-643 . A = B + C;
1-644 . D = E + F;
1-645 . }
1-646 .
1-647 . A = B*C;
1-648 . A = B*C;
1-649 .
1-650 . switch (ca stuff)
1-651 . {
1-652 . case one:
1-653 . {
1-654 . run_this;
1-655 . break;
1-656 . }
1-657 . case two:
1-658 . {
1-659 . run_this;
1-660 . break;
1-661 . }
1-662 . default:
1-663 . {
1-664 . SwError;
1-665 . }
1-666 . }
1-667 .
1-668 .
1-669 . if (A == B)
1-670 . {
1-671 . A = B + C;
1-672 . D = E + F;
1-673 . }
1-674 .
1-675 .
1-676 . if (A > = B)
1-677 . {
1-678 . A = B + C;
1-679 . D = E + F;
1-680 . }
1-681 .
1-682 . // max LOC 24
1-683 .
1-684 . }
1-685 .
1-686 .
1-687 . /*
1-688 . -----------------------------------------------------------------------------
1-689 . --| NAME: ca.1.4
1-690 . --|
1-691 . --| ABSTRACT:
1-692 . --| This function does ca stuff.
1-693 . --|
1-694 . --| RETURNS:
1-695 . --| NONE.
1-696 . --|
1-697 . ----------------------------------------------------------------------------
1-698 . */
1-699 . static void ca.1.4(void)
1-700 . {
1-701 . A = B+C;
1-702 .
1-703 . switch (ca stuff)
1-704 . {
1-705 . case one:
1-706 . {
1-707 . run_this;
1-708 . // missing break
1-709 . }
1-710 . case two:
1-711 . {
1-712 . run_this;
1-713 . break;
1-714 . }
1-715 . default:
1-716 . {
1-717 . SwError;
1-718 . }
1-719 . }
1-720 .
1-721 . A = B+C;
1-722 .
1-723 . switch (ca stuff)
1-724 . {
1-725 . case one:
1-726 . {
1-727 . run_this;
1-728 . break;
1-729 . }
1-730 . case two:
1-731 . {
1-732 . run_this;
1-733 . break;
1-734 . }
1-735 . default:
1-736 . {
1-737 . SwError;
1-738 . }
1-739 . }
1-740 .
1-741 . A = B-C;
1-742 . A = B*C;
1-743 . A = B/C;
1-744 . A = B/C;
1-745 . A = B*C;
1-746 . A = B-C;
1-747 .
1-748 . if (A < = B)
1-749 . {
1-750 . A = B + C;
1-751 . D = E + F;
1-752 . }
1-753 .
1-754 . A = B*C;
1-755 . A = B*C;
1-756 . A = B+C;
1-757 . A = B+C;
1-758 . A = B*C;
1-759 . A = B-C;
1-760 . A = B/C;
1-761 . A = B/C;
1-762 . A = B*C;
1-763 . A = B+C;
1-764 . // max LOC 20
1-765 .
1-766 . }
1-767 .
1-768 .
1-769 . /*
1-770 . -----------------------------------------------------------------------------
1-771 . --| NAME: ca.1.5
1-772 . --|
1-773 . --| ABSTRACT:
1-774 . --| This function does ca stuff.
1-775 . --|
1-776 . --| RETURNS:
1-777 . --| NONE.
1-778 . --|
1-779 . ----------------------------------------------------------------------------
1-780 . */
1-781 . static void ca.1.5(void)
1-782 . {
1-783 . A = B+C;
1-784 .
1-785 . if (A > B)
1-786 . {
1-787 . A = B + C;
1-788 . D = E + F;
1-789 . }
1-790 .
1-791 .
1-792 . if (A gt B)
1-793 . {
1-794 . A = B + C;
1-795 . D = E + F;
1-796 . }
1-797 .
1-798 .
1-799 . if (A lt B)
1-800 . {
1-801 . A = B + C;
1-802 . D = E + F;
1-803 . }
1-804 .
1-805 . A = B-C;
1-806 . A = B+C;
1-807 . /* LE SV TOC-1009 this is a ca-01.5.7 req to set Real Time Clock*/
1-808 . A = B+C;
1-809 . A = B/C;
1-810 .
1-811 . if (A > B)
1-812 . {
1-813 . A = B + C;
1-814 . D = E + F;
1-815 . }
1-816 .
1-817 . A = B/C;
1-818 . A = B*C;
1-819 . A = B+C;
1-820 .
1-821 . if (A == B)
1-822 . {
1-823 . A = B + C;
1-824 . D = E + F;
1-825 . }
1-826 .
1-827 . A = B-C;
1-828 . A = B-C;
1-829 . A = B+C;
1-830 . /* LE SV TOC-1010 this is a ca-01.5.17 req to halt*/
1-831 .
1-832 . if (A ne B)
1-833 . {
1-834 . A = B + C;
1-835 . D = E + F;
1-836 . }
1-837 .
1-838 . A = B-C;
1-839 . A = B*C;
1-840 .
1-841 . if (A eq B)
1-842 . {
1-843 . A = B + C;
1-844 . D = E + F;
1-845 . }
1-846 .
1-847 . A = 0x0004;
1-848 . A = B+C;
1-849 .
1-850 . if (A eq B)
1-851 . {
1-852 . A = B + C;
1-853 . D = E + F;
1-854 . }
1-855 .
1-856 . /* LE SV TOC-1011 this is a ca-01.5.23 req to record*/
1-857 . A = B-C;
1-858 . A = B-C;
1-859 . A = B/C;
1-860 . // max LOC 25
1-861 .
1-862 . }
1-863 .
1-864 .
1-865 . /*
1-866 . -----------------------------------------------------------------------------
1-867 . --| NAME: ca.1.6
1-868 . --|
1-869 . --| ABSTRACT:
1-870 . --| This function does ca stuff.
1-871 . --|
1-872 . --| RETURNS:
1-873 . --| NONE.
1-874 . --|
1-875 . ----------------------------------------------------------------------------
1-876 . */
1-877 . static void ca.1.6(void)
1-878 . {
1-879 . /* LE SV TOC-1012 this is a ca-01.6.1 req to fail*/
1-880 . A = B/C;
1-881 . A = B*C;
1-882 . A = B/C;
1-883 . A = B-C;
1-884 .
1-885 . if (A ne B)
1-886 . {
1-887 . A = B + C;
1-888 . D = E + F;
1-889 . }
1-890 .
1-891 . A = B*C;
1-892 . A = B+C;
1-893 . A = B+C;
1-894 . A = B/C;
1-895 .
1-896 . if (A ge B)
1-897 . {
1-898 . A = B + C;
1-899 . D = E + F;
1-900 . }
1-901 .
1-902 .
1-903 . if (A < = B)
1-904 . {
1-905 . A = B + C;
1-906 . D = E + F;
1-907 . }
1-908 .
1-909 .
1-910 . if (A > B)
1-911 . {
1-912 . A = B + C;
1-913 . D = E + F;
1-914 . }
1-915 .
1-916 .
1-917 . if (A < = B)
1-918 . {
1-919 . A = B + C;
1-920 . D = E + F;
1-921 . }
1-922 .
1-923 . A = B-C;
1-924 . A = B-C;
1-925 . A = B*C;
1-926 . A = B+C;
1-927 . A = 0x0004;
1-928 . A = B/C;
1-929 .
1-930 . if (A > B)
1-931 . {
1-932 . A = B + C;
1-933 . D = E + F;
1-934 . }
1-935 .
1-936 . /* LE SV TOC-1013 this is a ca-01.6.20 req to assign*/
1-937 .
1-938 . if (A lt B)
1-939 . {
1-940 . A = B + C;
1-941 . D = E + F;
1-942 . }
1-943 .
1-944 . // TBD - what do I do now
1-945 . A = B*C;
1-946 . A = B/C;
1-947 . A = B+C;
1-948 . A = B+C;
1-949 . A = B*C;
1-950 . A = B/C;
1-951 . // max LOC 26
1-952 .
1-953 . }
1-954 .
1-955 .
1-956 . /*
1-957 . -----------------------------------------------------------------------------
1-958 . --| NAME: ca.1.7
1-959 . --|
1-960 . --| ABSTRACT:
1-961 . --| This function does ca stuff.
1-962 . --|
1-963 . --| RETURNS:
1-964 . --| NONE.
1-965 . --|
1-966 . ----------------------------------------------------------------------------
1-967 . */
1-968 . static void ca.1.7(void)
1-969 . {
1-970 . A = B*C;
1-971 .
1-972 . if (A gt B)
1-973 . {
1-974 . A = B + C;
1-975 . D = E + F;
1-976 . }
1-977 .
1-978 . A = B+C;
1-979 . A = B-C;
1-980 . A = B/C;
1-981 . A = B-C;
1-982 . A = B+C;
1-983 .
1-984 . if (A < = B)
1-985 . {
1-986 . A = B + C;
1-987 . D = E + F;
1-988 . }
1-989 .
1-990 . A = B+C;
1-991 . A = B-C;
1-992 . /* LE SV TOC-1014 this is a ca-01.7.11 req to validate*/
1-993 . A = B*C;
1-994 . A = B-C;
1-995 . A = B+C;
1-996 . A = 0x0001;
1-997 . A = B*C;
1-998 . A = B/C;
1-999 . A = B/C;
1-1000 . A = B/C;
1-1001 .
1-1002 . if (A != B)
1-1003 . {
1-1004 . A = B + C;
1-1005 . D = E + F;
1-1006 . }
1-1007 .
1-1008 . A = B+C;
1-1009 . A = B/C;
1-1010 . A = B*C;
1-1011 .
1-1012 . if (A > B)
1-1013 . {
1-1014 . A = B + C;
1-1015 . D = E + F;
1-1016 . }
1-1017 .
1-1018 . A = B-C;
1-1019 . /* LE SV TOC-1015 this is a ca-01.7.24 req to translate*/
1-1020 .
1-1021 . if (A gt B)
1-1022 . {
1-1023 . A = B + C;
1-1024 . D = E + F;
1-1025 . }
1-1026 .
1-1027 . A = 0x0002;
1-1028 . A = B*C;
1-1029 .
1-1030 . if (A > = B)
1-1031 . {
1-1032 . A = B + C;
1-1033 . D = E + F;
1-1034 . }
1-1035 .
1-1036 . A = B-C;
1-1037 . A = B/C;
1-1038 . A = B+C;
1-1039 . A = B+C;
1-1040 . A = B*C;
1-1041 . A = B-C;
1-1042 .
1-1043 . if (A == B)
1-1044 . {
1-1045 . A = B + C;
1-1046 . D = E + F;
1-1047 . }
1-1048 .
1-1049 . A = B/C;
1-1050 . A = B+C;
1-1051 .
1-1052 . if (A > = B)
1-1053 . {
1-1054 . A = B + C;
1-1055 . D = E + F;
1-1056 . }
1-1057 .
1-1058 .
1-1059 . if (A ne B)
1-1060 . {
1-1061 . A = B + C;
1-1062 . D = E + F;
1-1063 . }
1-1064 .
1-1065 . A = B+C;
1-1066 .
1-1067 . if (A < = B)
1-1068 . {
1-1069 . A = B + C;
1-1070 . D = E + F;
1-1071 . }
1-1072 .
1-1073 . A = B*C;
1-1074 .
1-1075 . if (A gt B)
1-1076 . {
1-1077 . A = B + C;
1-1078 . D = E + F;
1-1079 . }
1-1080 .
1-1081 . A = B/C;
1-1082 . A = B/C;
1-1083 . A = B+C;
1-1084 .
1-1085 . if (A < B)
1-1086 . {
1-1087 . A = B + C;
1-1088 . D = E + F;
1-1089 . }
1-1090 .
1-1091 . A = B+C;
1-1092 . A = B/C;
1-1093 . /* LE SV TOC-1016 this is a ca-01.7.48 req to transform*/
1-1094 .
1-1095 . if (veg)
1-1096 . // missing curly brace
1-1097 . variable = orange;
1-1098 .
1-1099 .
1-1100 . if (A < B)
1-1101 . {
1-1102 . A = B + C;
1-1103 . D = E + F;
1-1104 . }
1-1105 .
1-1106 . A = B+C;
1-1107 .
1-1108 . if (A le B)
1-1109 . {
1-1110 . A = B + C;
1-1111 . D = E + F;
1-1112 . }
1-1113 .
1-1114 .
1-1115 . if (A != B)
1-1116 . {
1-1117 . A = B + C;
1-1118 . D = E + F;
1-1119 . }
1-1120 .
1-1121 . A = B+C;
1-1122 .
1-1123 . if (A ge B)
1-1124 . {
1-1125 . A = B + C;
1-1126 . D = E + F;
1-1127 . }
1-1128 .
1-1129 . A = B-C;
1-1130 . A = B*C;
1-1131 .
1-1132 . if (A lt B)
1-1133 . {
1-1134 . A = B + C;
1-1135 . D = E + F;
1-1136 . }
1-1137 .
1-1138 . A = B/C;
1-1139 .
1-1140 . if (A lt B)
1-1141 . {
1-1142 . A = B + C;
1-1143 . D = E + F;
1-1144 . }
1-1145 .
1-1146 . A = B-C;
1-1147 .
1-1148 . if (A > B)
1-1149 . {
1-1150 . A = B + C;
1-1151 . D = E + F;
1-1152 . }
1-1153 .
1-1154 . A = B-C;
1-1155 . A = B-C;
1-1156 . A = B+C;
1-1157 .
1-1158 . if (A < = B)
1-1159 . {
1-1160 . A = B + C;
1-1161 . D = E + F;
1-1162 . }
1-1163 .
1-1164 . A = B/C;
1-1165 .
1-1166 . if (A gt B)
1-1167 . {
1-1168 . A = B + C;
1-1169 . D = E + F;
1-1170 . }
1-1171 .
1-1172 . A = B/C;
1-1173 . A = B-C;
1-1174 . A = B+C;
1-1175 . A = B/C;
1-1176 .
1-1177 . #ifdef LAZY
1-1178 . // this is not nice
1-1179 . A = B + C;
1-1180 . A = B + C;
1-1181 . #endif
1-1182 .
1-1183 . A = B+C;
1-1184 . A = B+C;
1-1185 .
1-1186 . if (A > = B)
1-1187 . {
1-1188 . A = B + C;
1-1189 . D = E + F;
1-1190 . }
1-1191 .
1-1192 . A = B*C;
1-1193 .
1-1194 . if (A eq B)
1-1195 . {
1-1196 . A = B + C;
1-1197 . D = E + F;
1-1198 . }
1-1199 .
1-1200 . A = B*C;
1-1201 .
1-1202 . if (A > B)
1-1203 . {
1-1204 . A = B + C;
1-1205 . D = E + F;
1-1206 . }
1-1207 .
1-1208 . // max LOC 77
1-1209 .
1-1210 . }
1-1211 .
1-1212 .
1-1213 . /*
1-1214 . -----------------------------------------------------------------------------
1-1215 . --| NAME: ca.1.8
1-1216 . --|
1-1217 . --| ABSTRACT:
1-1218 . --| This function does ca stuff.
1-1219 . --|
1-1220 . --| RETURNS:
1-1221 . --| NONE.
1-1222 . --|
1-1223 . ----------------------------------------------------------------------------
1-1224 . */
1-1225 . static void ca.1.8(void)
1-1226 . {
1-1227 .
1-1228 . if (A > B)
1-1229 . {
1-1230 . A = B + C;
1-1231 . D = E + F;
1-1232 . }
1-1233 .
1-1234 .
1-1235 . if (A > B)
1-1236 . {
1-1237 . A = B + C;
1-1238 . D = E + F;
1-1239 . }
1-1240 .
1-1241 . A = B+C;
1-1242 . A = B-C;
1-1243 . A = B*C;
1-1244 . A = B/C;
1-1245 . A = B*C;
1-1246 . A = B/C;
1-1247 . A = B*C;
1-1248 . A = B-C;
1-1249 . /* LE SV TOC-1017 this is a ca-01.8.11 req to check unix*/
1-1250 . A = B-C;
1-1251 . A = B-C;
1-1252 . A = B+C;
1-1253 . /* LE SV TOC-1018 this is a ca-01.8.14 req to update*/
1-1254 . A = B/C;
1-1255 .
1-1256 . switch (ca stuff)
1-1257 . {
1-1258 . case one:
1-1259 . {
1-1260 . run_this;
1-1261 . break;
1-1262 . }
1-1263 . case two:
1-1264 . {
1-1265 . run_this;
1-1266 . break;
1-1267 . }
1-1268 . default:
1-1269 . {
1-1270 . SwError;
1-1271 . }
1-1272 . }
1-1273 .
1-1274 .
1-1275 . if (A > = B)
1-1276 . {
1-1277 . A = B + C;
1-1278 . D = E + F;
1-1279 . }
1-1280 .
1-1281 . A = B+C;
1-1282 . A = B/C;
1-1283 . A = B/C;
1-1284 .
1-1285 . if (A < B)
1-1286 . {
1-1287 . A = B + C;
1-1288 . D = E + F;
1-1289 . }
1-1290 .
1-1291 . A = B*C;
1-1292 . A = B-C;
1-1293 . A = B-C;
1-1294 .
1-1295 . if (A eq B)
1-1296 . {
1-1297 . A = B + C;
1-1298 . D = E + F;
1-1299 . }
1-1300 .
1-1301 . /* LE SV TOC-1019 this is a ca-01.8.25 req to verify*/
1-1302 .
1-1303 . if (A gt B)
1-1304 . {
1-1305 . A = B + C;
1-1306 . D = E + F;
1-1307 . }
1-1308 .
1-1309 .
1-1310 . if (A < B)
1-1311 . {
1-1312 . A = B + C;
1-1313 . D = E + F;
1-1314 . }
1-1315 .
1-1316 . /* LE SV TOC-1020 this is a ca-01.8.27 req to process*/
1-1317 .
1-1318 . if (A > = B)
1-1319 . {
1-1320 . A = B + C;
1-1321 . D = E + F;
1-1322 . }
1-1323 .
1-1324 . A = B-C;
1-1325 .
1-1326 . if (A ne B)
1-1327 . {
1-1328 . A = B + C;
1-1329 . D = E + F;
1-1330 . }
1-1331 .
1-1332 .
1-1333 . #ifdef LAZY
1-1334 . // this is not nice
1-1335 . A = B + C;
1-1336 . A = B + C;
1-1337 . #endif
1-1338 .
1-1339 . A = B-C;
1-1340 .
1-1341 . if (A == B)
1-1342 . {
1-1343 . A = B + C;
1-1344 . D = E + F;
1-1345 . }
1-1346 .
1-1347 . A = B/C;
1-1348 . A = B+C;
1-1349 . A = B+C;
1-1350 . A = B/C;
1-1351 . A = B+C;
1-1352 . A = B+C;
1-1353 .
1-1354 . if (A ne B)
1-1355 . {
1-1356 . A = B + C;
1-1357 . D = E + F;
1-1358 . }
1-1359 .
1-1360 . A = B/C;
1-1361 . A = B/C;
1-1362 .
1-1363 . if (A != B)
1-1364 . {
1-1365 . A = B + C;
1-1366 . D = E + F;
1-1367 . }
1-1368 .
1-1369 . /* LE SV TOC-1021 this is a ca-01.8.42 req to fail*/
1-1370 .
1-1371 . if (A > B)
1-1372 . {
1-1373 . A = B + C;
1-1374 . D = E + F;
1-1375 . }
1-1376 .
1-1377 . A = B+C;
1-1378 . A = 0x0009;
1-1379 . A = B*C;
1-1380 . A = B-C;
1-1381 . A = B-C;
1-1382 .
1-1383 . if (A == B)
1-1384 . {
1-1385 . A = B + C;
1-1386 . D = E + F;
1-1387 . }
1-1388 .
1-1389 . A = B+C;
1-1390 . A = B+C;
1-1391 . A = B*C;
1-1392 . A = B-C;
1-1393 .
1-1394 . if (A < B)
1-1395 . {
1-1396 . A = B + C;
1-1397 . D = E + F;
1-1398 . }
1-1399 .
1-1400 .
1-1401 . if (A ne B)
1-1402 . {
1-1403 . A = B + C;
1-1404 . D = E + F;
1-1405 . }
1-1406 .
1-1407 . A = B+C;
1-1408 .
1-1409 . if (A ge B)
1-1410 . {
1-1411 . A = B + C;
1-1412 . D = E + F;
1-1413 . }
1-1414 .
1-1415 .
1-1416 . if (A le B)
1-1417 . {
1-1418 . A = B + C;
1-1419 . D = E + F;
1-1420 . }
1-1421 .
1-1422 .
1-1423 . switch (ca stuff)
1-1424 . {
1-1425 . case one:
1-1426 . {
1-1427 . run_this;
1-1428 . break;
1-1429 . }
1-1430 . case two:
1-1431 . {
1-1432 . run_this;
1-1433 . break;
1-1434 . }
1-1435 . default:
1-1436 . {
1-1437 . SwError;
1-1438 . }
1-1439 . }
1-1440 .
1-1441 .
1-1442 . if (A == B)
1-1443 . {
1-1444 . A = B + C;
1-1445 . D = E + F;
1-1446 . }
1-1447 .
1-1448 . A = B/C;
1-1449 . A = B+C;
1-1450 . A = B+C;
1-1451 . A = B/C;
1-1452 . A = B/C;
1-1453 . A = B+C;
1-1454 . A = B-C;
1-1455 . A = B+C;
1-1456 . A = B+C;
1-1457 .
1-1458 . if (A ge B)
1-1459 . {
1-1460 . A = B + C;
1-1461 . D = E + F;
1-1462 . }
1-1463 .
1-1464 . A = B*C;
1-1465 .
1-1466 . if (A == B)
1-1467 . {
1-1468 . A = B + C;
1-1469 . D = E + F;
1-1470 . }
1-1471 .
1-1472 . A = B/C;
1-1473 . A = B-C;
1-1474 .
1-1475 . if (A < = B)
1-1476 . {
1-1477 . A = B + C;
1-1478 . D = E + F;
1-1479 . }
1-1480 .
1-1481 .
1-1482 . if (A lt B)
1-1483 . {
1-1484 . A = B + C;
1-1485 . D = E + F;
1-1486 . }
1-1487 .
1-1488 . A = B/C;
1-1489 . A = 0x0009;
1-1490 . A = B/C;
1-1491 . A = B/C;
1-1492 . A = B-C;
1-1493 . // max LOC 78
1-1494 .
1-1495 . }
1-1496 .
1-1497 .
1-1498 . /*
1-1499 . -----------------------------------------------------------------------------
1-1500 . --| NAME: ca.1.9
1-1501 . --|
1-1502 . --| ABSTRACT:
1-1503 . --| This function does ca stuff.
1-1504 . --|
1-1505 . --| RETURNS:
1-1506 . --| NONE.
1-1507 . --|
1-1508 . ----------------------------------------------------------------------------
1-1509 . */
1-1510 . static void ca.1.9(void)
1-1511 . {
1-1512 . A = B-C;
1-1513 . /* LE SV TOC-1022 this is a ca-01.9.2 req to assign*/
1-1514 .
1-1515 . /* dead_code = B + C;
1-1516 . dead_code = D + E;
1-1517 . dead_code = F + G; */
1-1518 .
1-1519 . A = B-C;
1-1520 . A = B/C;
1-1521 . A = B/C;
1-1522 . A = B/C;
1-1523 . A = B/C;
1-1524 . A = B+C;
1-1525 . A = B-C;
1-1526 . A = B+C;
1-1527 .
1-1528 . if (A == B)
1-1529 . {
1-1530 . A = B + C;
1-1531 . D = E + F;
1-1532 . }
1-1533 .
1-1534 .
1-1535 . if (A < B)
1-1536 . {
1-1537 . A = B + C;
1-1538 . D = E + F;
1-1539 . }
1-1540 .
1-1541 . A = B-C;
1-1542 . A = 0x0004;
1-1543 . A = B+C;
1-1544 . A = B*C;
1-1545 .
1-1546 . if (A < B)
1-1547 . {
1-1548 . A = B + C;
1-1549 . D = E + F;
1-1550 . }
1-1551 .
1-1552 . A = B-C;
1-1553 . A = B/C;
1-1554 . A = B*C;
1-1555 .
1-1556 . if {
1-1557 . X = Y + Z;
1-1558 . }
1-1559 . else {
1-1560 . halt;
1-1561 . }
1-1562 .
1-1563 .
1-1564 . if (A == B)
1-1565 . {
1-1566 . A = B + C;
1-1567 . D = E + F;
1-1568 . }
1-1569 .
1-1570 . A = B/C;
1-1571 .
1-1572 . if (A == B)
1-1573 . {
1-1574 . A = B + C;
1-1575 . D = E + F;
1-1576 . }
1-1577 .
1-1578 .
1-1579 . if (A > = B)
1-1580 . {
1-1581 . A = B + C;
1-1582 . D = E + F;
1-1583 . }
1-1584 .
1-1585 . A = B*C;
1-1586 . A = B/C;
1-1587 .
1-1588 . if (A < = B)
1-1589 . {
1-1590 . A = B + C;
1-1591 . D = E + F;
1-1592 . }
1-1593 .
1-1594 .
1-1595 . if (A eq B)
1-1596 . {
1-1597 . A = B + C;
1-1598 . D = E + F;
1-1599 . }
1-1600 .
1-1601 . /* LE SV TOC-1023 this is a ca-01.9.27 req to reject*/
1-1602 . A = B+C;
1-1603 . A = B/C;
1-1604 . /* LE SV TOC-1024 this is a ca-01.9.29 req to process*/
1-1605 . A = B/C;
1-1606 . A = B+C;
1-1607 . /* LE SV TOC-1025 this is a ca-01.9.31 req to assign*/
1-1608 . A = B*C;
1-1609 . A = B+C;
1-1610 . A = 0x0001;
1-1611 . A = B+C;
1-1612 . A = B/C;
1-1613 .
1-1614 . if (A > = B)
1-1615 . {
1-1616 . A = B + C;
1-1617 . D = E + F;
1-1618 . }
1-1619 .
1-1620 . A = B/C;
1-1621 . A = B+C;
1-1622 .
1-1623 . if (A > B)
1-1624 . {
1-1625 . A = B + C;
1-1626 . D = E + F;
1-1627 . }
1-1628 .
1-1629 . A = B-C;
1-1630 . A = B*C;
1-1631 .
1-1632 . switch (ca stuff)
1-1633 . {
1-1634 . case:
1-1635 . case:
1-1636 . // stacked case statements but only if there is a new line in between
1-1637 .
1-1638 . case:
1-1639 . case:
1-1640 . case:
1-1641 . {
1-1642 . run_this;
1-1643 . break;
1-1644 . }
1-1645 . default:
1-1646 . {
1-1647 . halt;
1-1648 . }
1-1649 . }
1-1650 .
1-1651 .
1-1652 . if (A < = B)
1-1653 . {
1-1654 . A = B + C;
1-1655 . D = E + F;
1-1656 . }
1-1657 .
1-1658 . A = B-C;
1-1659 . A = B/C;
1-1660 .
1-1661 . if (A != B)
1-1662 . {
1-1663 . A = B + C;
1-1664 . D = E + F;
1-1665 . }
1-1666 .
1-1667 . A = B-C;
1-1668 .
1-1669 . if (A gt B)
1-1670 . {
1-1671 . A = B + C;
1-1672 . D = E + F;
1-1673 . }
1-1674 .
1-1675 . A = B*C;
1-1676 . A = B*C;
1-1677 . /* LE SV TOC-1026 this is a ca-01.9.49 req to call isr*/
1-1678 . A = B+C;
1-1679 . A = B+C;
1-1680 .
1-1681 . switch (ca stuff)
1-1682 . {
1-1683 . case one:
1-1684 . {
1-1685 . run_this;
1-1686 . break;
1-1687 . }
1-1688 . case two:
1-1689 . {
1-1690 . run_this;
1-1691 . break;
1-1692 . }
1-1693 . default:
1-1694 . {
1-1695 . SwError;
1-1696 . }
1-1697 . }
1-1698 .
1-1699 .
1-1700 . if (A lt B)
1-1701 . {
1-1702 . A = B + C;
1-1703 . D = E + F;
1-1704 . }
1-1705 .
1-1706 .
1-1707 . if (veg)
1-1708 . // missing curly brace
1-1709 . variable = orange;
1-1710 .
1-1711 . A = B/C;
1-1712 . A = B-C;
1-1713 . A = B*C;
1-1714 . // (P) this is really improtant
1-1715 .
1-1716 . switch (ca stuff)
1-1717 . {
1-1718 . case one:
1-1719 . {
1-1720 . run_this;
1-1721 . break;
1-1722 . }
1-1723 . case two:
1-1724 . {
1-1725 . run_this;
1-1726 . break;
1-1727 . }
1-1728 . default:
1-1729 . {
1-1730 . SwError;
1-1731 . }
1-1732 . }
1-1733 .
1-1734 . A = B-C;
1-1735 . A = B*C;
1-1736 .
1-1737 . if (A gt B)
1-1738 . {
1-1739 . A = B + C;
1-1740 . D = E + F;
1-1741 . }
1-1742 .
1-1743 . A = B-C;
1-1744 . A = B/C;
1-1745 . A = B+C;
1-1746 . A = B+C;
1-1747 . A = 0x0007;
1-1748 .
1-1749 . if (A le B)
1-1750 . {
1-1751 . A = B + C;
1-1752 . D = E + F;
1-1753 . }
1-1754 .
1-1755 . A = B+C;
1-1756 . A = B/C;
1-1757 . A = 0x0001;
1-1758 . A = B-C;
1-1759 . A = B*C;
1-1760 . A = B-C;
1-1761 .
1-1762 . if (A lt B)
1-1763 . {
1-1764 . A = B + C;
1-1765 . D = E + F;
1-1766 . }
1-1767 .
1-1768 . A = B/C;
1-1769 . /* LE SV TOC-1027 this is a ca-01.9.72 req to record*/
1-1770 . A = B+C;
1-1771 . // ??? go see ws
1-1772 . A = B*C;
1-1773 . A = B+C;
1-1774 . A = B/C;
1-1775 . A = B-C;
1-1776 . A = B*C;
1-1777 . A = B-C;
1-1778 . /* LE SV TOC-1028 this is a ca-01.9.79 req to audit*/
1-1779 . A = B/C;
1-1780 . A = B-C;
1-1781 .
1-1782 . if (A > B)
1-1783 . {
1-1784 . A = B + C;
1-1785 . D = E + F;
1-1786 . }
1-1787 .
1-1788 .
1-1789 . if (A lt B)
1-1790 . {
1-1791 . A = B + C;
1-1792 . D = E + F;
1-1793 . }
1-1794 .
1-1795 . A = B+C;
1-1796 . A = B/C;
1-1797 . // max LOC 84
1-1798 .
1-1799 . }
1-1800 .
1-1801 .
1-1802 . /*
1-1803 . -----------------------------------------------------------------------------
1-1804 . --| NAME: ca.1.10
1-1805 . --|
1-1806 . --| ABSTRACT:
1-1807 . --| This function does ca stuff.
1-1808 . --|
1-1809 . --| RETURNS:
1-1810 . --| NONE.
1-1811 . --|
1-1812 . ----------------------------------------------------------------------------
1-1813 . */
1-1814 . static void ca.1.10(void)
1-1815 . {
1-1816 . A = B/C;
1-1817 . /* LE SV TOC-1029 this is a ca-01.10.2 req to convert*/
1-1818 . send_buffer = (U16 *) malloc(size+1);
1-1819 . A = B*C;
1-1820 .
1-1821 . if (A != B)
1-1822 . {
1-1823 . A = B + C;
1-1824 . D = E + F;
1-1825 . }
1-1826 .
1-1827 . A = B+C;
1-1828 . A = B-C;
1-1829 . A = B+C;
1-1830 . A = B-C;
1-1831 . A = B*C;
1-1832 .
1-1833 . if (A == B)
1-1834 . {
1-1835 . A = B + C;
1-1836 . D = E + F;
1-1837 . }
1-1838 .
1-1839 . A = B*C;
1-1840 .
1-1841 . if ($ca stuff > $otherca stuff)
1-1842 . /* LE SV TOC-008 we really should log all error calls */
1-1843 . {
1-1844 . A = B + C;
1-1845 . }
1-1846 .
1-1847 . A = B+C;
1-1848 . A = B-C;
1-1849 . A = B*C;
1-1850 .
1-1851 . if (A > = B)
1-1852 . {
1-1853 . A = B + C;
1-1854 . D = E + F;
1-1855 . }
1-1856 .
1-1857 . A = B-C;
1-1858 . A = B*C;
1-1859 .
1-1860 . if (A != B)
1-1861 . {
1-1862 . A = B + C;
1-1863 . D = E + F;
1-1864 . }
1-1865 .
1-1866 . A = B-C;
1-1867 . A = B-C;
1-1868 . A = B-C;
1-1869 .
1-1870 . switch (ca stuff)
1-1871 . {
1-1872 . case one:
1-1873 . {
1-1874 . run_this;
1-1875 . break;
1-1876 . }
1-1877 . case two:
1-1878 . {
1-1879 . run_this;
1-1880 . break;
1-1881 . }
1-1882 . default:
1-1883 . {
1-1884 . SwError;
1-1885 . }
1-1886 . }
1-1887 .
1-1888 .
1-1889 . if (A gt B)
1-1890 . {
1-1891 . A = B + C;
1-1892 . D = E + F;
1-1893 . }
1-1894 .
1-1895 . A = B+C;
1-1896 . A = B+C;
1-1897 .
1-1898 . if (A gt B)
1-1899 . {
1-1900 . A = B + C;
1-1901 . D = E + F;
1-1902 . }
1-1903 .
1-1904 . A = 0x0001;
1-1905 . A = B/C;
1-1906 .
1-1907 . if (A > B)
1-1908 . {
1-1909 . A = B + C;
1-1910 . D = E + F;
1-1911 . }
1-1912 .
1-1913 . A = B+C;
1-1914 . A = B+C;
1-1915 . // max LOC 29
1-1916 .
1-1917 . }
1-1918 .
1 1 Result: result/source/pr-app/pr-app-CA123/ca/ca-01.c
2 2 Source: source/pr-app/pr-app-CA123/ca/ca-02.c
2-0 . /*
2-1 . ----------------------------------------------------------------------------
2-2 . --| BEGIN PROLOGUE
2-3 . --|
2-4 . --| CLASSIFICATION: UNCLASSIFIED
2-5 . --|
2-6 . --| FILE NAME: ca-02.c
2-7 . --|
2-8 . --| ABSTRACT:
2-9 . --| This file contains the 8 functions that do file ca stuff.
2-10 . --|
2-11 . --| HISTORY:
2-12 . --| CCCQ_NAME:
2-13 . --| CCCQ_VER:
2-14 . --|
2-15 . --| END PROLOGUE
2-16 . ----------------------------------------------------------------------------
2-17 . */
2-18 .
2-19 . double C;
2-20 . #include A;
2-21 . #define C;
2-22 . #include D;
2-23 . double C;
2-24 . #define C;
2-25 .
2-26 .
2-27 .
2-28 . /*
2-29 . -----------------------------------------------------------------------------
2-30 . --| NAME: ca.2.1
2-31 . --|
2-32 . --| ABSTRACT:
2-33 . --| This function does ca stuff.
2-34 . --|
2-35 . --| RETURNS:
2-36 . --| NONE.
2-37 . --|
2-38 . ----------------------------------------------------------------------------
2-39 . */
2-40 . static void ca.2.1(void)
2-41 . {
2-42 . A = B-C;
2-43 . A = B/C;
2-44 . A = B+C;
2-45 . A = B*C;
2-46 . A = B+C;
2-47 .
2-48 . if (A lt B)
2-49 . {
2-50 . A = B + C;
2-51 . D = E + F;
2-52 . }
2-53 .
2-54 . A = B/C;
2-55 .
2-56 . if (A > = B)
2-57 . {
2-58 . A = B + C;
2-59 . D = E + F;
2-60 . }
2-61 .
2-62 . A = B+C;
2-63 . A = B+C;
2-64 . A = B-C;
2-65 . A = B+C;
2-66 .
2-67 . if (A > = B)
2-68 . {
2-69 . A = B + C;
2-70 . D = E + F;
2-71 . }
2-72 .
2-73 . A = B-C;
2-74 . A = B+C;
2-75 . /* LE SV TOC-1030 this is a ca-02.1.16 req to audit*/
2-76 . A = B+C;
2-77 . /* LE SV TOC-1031 this is a ca-02.1.17 req to compare*/
2-78 . A = B-C;
2-79 . /* LE SV TOC-1032 this is a ca-02.1.18 req to update*/
2-80 . A = B*C;
2-81 . A = B+C;
2-82 . A = B-C;
2-83 . A = B-C;
2-84 . A = B*C;
2-85 . A = B+C;
2-86 .
2-87 . if (A > = B)
2-88 . {
2-89 . A = B + C;
2-90 . D = E + F;
2-91 . }
2-92 .
2-93 . A = B*C;
2-94 . A = B+C;
2-95 .
2-96 . switch (ca stuff)
2-97 . {
2-98 . case one:
2-99 . {
2-100 . run_this;
2-101 . break;
2-102 . }
2-103 . case two:
2-104 . {
2-105 . run_this;
2-106 . break;
2-107 . }
2-108 . default:
2-109 . {
2-110 . SwError;
2-111 . }
2-112 . }
2-113 .
2-114 . A = B-C;
2-115 . A = B*C;
2-116 .
2-117 . if (A eq B)
2-118 . {
2-119 . A = B + C;
2-120 . D = E + F;
2-121 . }
2-122 .
2-123 . A = B*C;
2-124 . A = B/C;
2-125 .
2-126 . if (A > = B)
2-127 . {
2-128 . A = B + C;
2-129 . D = E + F;
2-130 . }
2-131 .
2-132 .
2-133 . if (A eq B)
2-134 . {
2-135 . A = B + C;
2-136 . D = E + F;
2-137 . }
2-138 .
2-139 .
2-140 . if (A ge B)
2-141 . {
2-142 . A = B + C;
2-143 . D = E + F;
2-144 . }
2-145 .
2-146 . A = B-C;
2-147 .
2-148 . if (A == B)
2-149 . {
2-150 . A = B + C;
2-151 . D = E + F;
2-152 . }
2-153 .
2-154 .
2-155 . if (A != B)
2-156 . {
2-157 . A = B + C;
2-158 . D = E + F;
2-159 . }
2-160 .
2-161 . A = B*C;
2-162 .
2-163 . if (A eq B)
2-164 . {
2-165 . A = B + C;
2-166 . D = E + F;
2-167 . }
2-168 .
2-169 .
2-170 . if (A > B)
2-171 . {
2-172 . A = B + C;
2-173 . D = E + F;
2-174 . }
2-175 .
2-176 . A = B/C;
2-177 . A = B+C;
2-178 . A = B*C;
2-179 . A = B-C;
2-180 .
2-181 . if (A ge B)
2-182 . {
2-183 . A = B + C;
2-184 . D = E + F;
2-185 . }
2-186 .
2-187 .
2-188 . if (A ne B)
2-189 . {
2-190 . A = B + C;
2-191 . D = E + F;
2-192 . }
2-193 .
2-194 . A = B*C;
2-195 .
2-196 . if (A gt B)
2-197 . {
2-198 . A = B + C;
2-199 . D = E + F;
2-200 . }
2-201 .
2-202 . /* LE SV TOC-1033 this is a ca-02.1.50 req to store*/
2-203 . A = (float)B + C;
2-204 .
2-205 . if (A ge B)
2-206 . {
2-207 . A = B + C;
2-208 . D = E + F;
2-209 . }
2-210 .
2-211 .
2-212 . if (A != B)
2-213 . {
2-214 . A = B + C;
2-215 . D = E + F;
2-216 . }
2-217 .
2-218 . A = 0x0009;
2-219 . A = B/C;
2-220 . A = B/C;
2-221 . A = B/C;
2-222 .
2-223 . switch (ca stuff)
2-224 . {
2-225 . case one:
2-226 . {
2-227 . run_this;
2-228 . break;
2-229 . }
2-230 . case two:
2-231 . {
2-232 . run_this;
2-233 . break;
2-234 . }
2-235 . default:
2-236 . {
2-237 . SwError;
2-238 . }
2-239 . }
2-240 .
2-241 .
2-242 . if (A < B)
2-243 . {
2-244 . A = B + C;
2-245 . D = E + F;
2-246 . }
2-247 .
2-248 .
2-249 . if (A == B)
2-250 . {
2-251 . A = B + C;
2-252 . D = E + F;
2-253 . }
2-254 .
2-255 .
2-256 . if (A gt B)
2-257 . {
2-258 . A = B + C;
2-259 . D = E + F;
2-260 . }
2-261 .
2-262 . A = B+C;
2-263 . A = B/C;
2-264 . A = B*C;
2-265 . A = B/C;
2-266 . A = B-C;
2-267 .
2-268 . if (A == B)
2-269 . {
2-270 . A = B + C;
2-271 . D = E + F;
2-272 . }
2-273 .
2-274 .
2-275 . switch (ca stuff)
2-276 . {
2-277 . case one:
2-278 . {
2-279 . run_this;
2-280 . break;
2-281 . }
2-282 . case two:
2-283 . {
2-284 . run_this;
2-285 . break;
2-286 . }
2-287 . default:
2-288 . {
2-289 . SwError;
2-290 . }
2-291 . }
2-292 .
2-293 . /* LE SV TOC-1034 this is a ca-02.1.66 req to set RTC*/
2-294 .
2-295 . if (A < = B)
2-296 . {
2-297 . A = B + C;
2-298 . D = E + F;
2-299 . }
2-300 .
2-301 . A = B*C;
2-302 . A = B+C;
2-303 . A = B+C;
2-304 . A = B+C;
2-305 .
2-306 . if (A eq B)
2-307 . {
2-308 . A = B + C;
2-309 . D = E + F;
2-310 . }
2-311 .
2-312 .
2-313 . if (A ge B)
2-314 . {
2-315 . A = B + C;
2-316 . D = E + F;
2-317 . }
2-318 .
2-319 .
2-320 . if (A eq B)
2-321 . {
2-322 . A = B + C;
2-323 . D = E + F;
2-324 . }
2-325 .
2-326 .
2-327 . if (A lt B)
2-328 . {
2-329 . A = B + C;
2-330 . D = E + F;
2-331 . }
2-332 .
2-333 . A = B*C;
2-334 . /* dead_code = A * B; */
2-335 . A = B+C;
2-336 . /* LE SV TOC-1035 this is a ca-02.1.77 req to compare*/
2-337 .
2-338 . if (A le B)
2-339 . {
2-340 . A = B + C;
2-341 . D = E + F;
2-342 . }
2-343 .
2-344 .
2-345 . if (A > B)
2-346 . {
2-347 . A = B + C;
2-348 . D = E + F;
2-349 . }
2-350 .
2-351 . A = B/C;
2-352 . // max LOC 79
2-353 .
2-354 . }
2-355 .
2-356 .
2-357 . /*
2-358 . -----------------------------------------------------------------------------
2-359 . --| NAME: ca.2.2
2-360 . --|
2-361 . --| ABSTRACT:
2-362 . --| This function does ca stuff.
2-363 . --|
2-364 . --| RETURNS:
2-365 . --| NONE.
2-366 . --|
2-367 . ----------------------------------------------------------------------------
2-368 . */
2-369 . static void ca.2.2(void)
2-370 . {
2-371 . A = B/C;
2-372 . A = B/C;
2-373 .
2-374 . if (A le B)
2-375 . {
2-376 . A = B + C;
2-377 . D = E + F;
2-378 . }
2-379 .
2-380 . A = B/C;
2-381 . A = B+C;
2-382 . A = B/C;
2-383 . A = B+C;
2-384 .
2-385 . if (A eq B)
2-386 . {
2-387 . A = B + C;
2-388 . D = E + F;
2-389 . }
2-390 .
2-391 . A = B+C;
2-392 . A = 0x0001;
2-393 . A = B+C;
2-394 . A = B*C;
2-395 . A = 0x0008;
2-396 . A = B-C;
2-397 . A = B+C;
2-398 . A = B/C;
2-399 . A = B*C;
2-400 . A = B-C;
2-401 .
2-402 . if (A ne B)
2-403 . {
2-404 . A = B + C;
2-405 . D = E + F;
2-406 . }
2-407 .
2-408 . A = B+C;
2-409 . /* LE SV TOC-1036 this is a ca-02.2.19 req to set RTC*/
2-410 .
2-411 . if (A le B)
2-412 . {
2-413 . A = B + C;
2-414 . D = E + F;
2-415 . }
2-416 .
2-417 .
2-418 . if (A lt B)
2-419 . {
2-420 . A = B + C;
2-421 . D = E + F;
2-422 . }
2-423 .
2-424 . A = B+C;
2-425 . A = B+C;
2-426 . // max LOC 22
2-427 .
2-428 . }
2-429 .
2-430 .
2-431 . /*
2-432 . -----------------------------------------------------------------------------
2-433 . --| NAME: ca.2.3
2-434 . --|
2-435 . --| ABSTRACT:
2-436 . --| This function does ca stuff.
2-437 . --|
2-438 . --| RETURNS:
2-439 . --| NONE.
2-440 . --|
2-441 . ----------------------------------------------------------------------------
2-442 . */
2-443 . static void ca.2.3(void)
2-444 . {
2-445 . A = B+C;
2-446 . A = B+C;
2-447 .
2-448 . if (A == B)
2-449 . {
2-450 . A = B + C;
2-451 . D = E + F;
2-452 . }
2-453 .
2-454 .
2-455 . switch (ca stuff)
2-456 . {
2-457 . case one:
2-458 . {
2-459 . run_this;
2-460 . break;
2-461 . }
2-462 . case two:
2-463 . {
2-464 . run_this;
2-465 . break;
2-466 . }
2-467 . default:
2-468 . {
2-469 . SwError;
2-470 . }
2-471 . }
2-472 .
2-473 . A = B-C;
2-474 . A = B/C;
2-475 .
2-476 . if (A lt B)
2-477 . {
2-478 . A = B + C;
2-479 . D = E + F;
2-480 . }
2-481 .
2-482 .
2-483 . if (A == B)
2-484 . {
2-485 . A = B + C;
2-486 . D = E + F;
2-487 . }
2-488 .
2-489 .
2-490 . if (A le B)
2-491 . {
2-492 . A = B + C;
2-493 . D = E + F;
2-494 . }
2-495 .
2-496 . A = B/C;
2-497 . A = B-C;
2-498 . /* LE SV TOC-1037 this is a ca-02.3.12 req to translate*/
2-499 . A = B*C;
2-500 .
2-501 . if (A == B)
2-502 . {
2-503 . A = B + C;
2-504 . D = E + F;
2-505 . }
2-506 .
2-507 . A = B/C;
2-508 . FreePtr = HmiStringPtr;
2-509 . A = B/C;
2-510 .
2-511 . if (A > B)
2-512 . {
2-513 . A = B + C;
2-514 . D = E + F;
2-515 . }
2-516 .
2-517 . A = B+C;
2-518 . A = 0x0004;
2-519 .
2-520 . if (A le B)
2-521 . {
2-522 . A = B + C;
2-523 . D = E + F;
2-524 . }
2-525 .
2-526 . A = 0x0008;
2-527 .
2-528 . if (A > B)
2-529 . {
2-530 . A = B + C;
2-531 . D = E + F;
2-532 . }
2-533 .
2-534 .
2-535 . if (A le B)
2-536 . {
2-537 . A = B + C;
2-538 . D = E + F;
2-539 . }
2-540 .
2-541 . A = B*C;
2-542 . send_buffer = (U16 *) malloc(size+1);
2-543 .
2-544 . if (A eq B)
2-545 . {
2-546 . A = B + C;
2-547 . D = E + F;
2-548 . }
2-549 .
2-550 . A = B/C;
2-551 . A = B-C;
2-552 .
2-553 . if (A ne B)
2-554 . {
2-555 . A = B + C;
2-556 . D = E + F;
2-557 . }
2-558 .
2-559 . A = B/C;
2-560 . A = B/C;
2-561 .
2-562 . if (A ge B)
2-563 . {
2-564 . A = B + C;
2-565 . D = E + F;
2-566 . }
2-567 .
2-568 .
2-569 . if (A != B)
2-570 . {
2-571 . A = B + C;
2-572 . D = E + F;
2-573 . }
2-574 .
2-575 . A = B/C;
2-576 .
2-577 . if (A < B)
2-578 . {
2-579 . A = B + C;
2-580 . D = E + F;
2-581 . }
2-582 .
2-583 . A = B*C;
2-584 . A = B/C;
2-585 .
2-586 . if (A ne B)
2-587 . {
2-588 . A = B + C;
2-589 . D = E + F;
2-590 . }
2-591 .
2-592 . A = B/C;
2-593 .
2-594 . if (A gt B)
2-595 . {
2-596 . A = B + C;
2-597 . D = E + F;
2-598 . }
2-599 .
2-600 . A = B+C;
2-601 . /* dead_code = A * B; */
2-602 . A = B*C;
2-603 . A = B-C;
2-604 . A = B+C;
2-605 . A = B+C;
2-606 . A = B-C;
2-607 . A = B+C;
2-608 . A = B/C;
2-609 .
2-610 . if (A < B)
2-611 . {
2-612 . A = B + C;
2-613 . D = E + F;
2-614 . }
2-615 .
2-616 . A = B+C;
2-617 . A = B+C;
2-618 .
2-619 . switch (ca stuff)
2-620 . {
2-621 . case one:
2-622 . {
2-623 . run_this;
2-624 . // missing break
2-625 . }
2-626 . case two:
2-627 . {
2-628 . run_this;
2-629 . break;
2-630 . }
2-631 . default:
2-632 . {
2-633 . SwError;
2-634 . }
2-635 . }
2-636 .
2-637 . A = B*C;
2-638 . A = B+C;
2-639 .
2-640 . if (A < B)
2-641 . {
2-642 . A = B + C;
2-643 . D = E + F;
2-644 . }
2-645 .
2-646 .
2-647 . if (A == B)
2-648 . {
2-649 . A = B + C;
2-650 . D = E + F;
2-651 . }
2-652 .
2-653 . A = B/C;
2-654 . A = B-C;
2-655 .
2-656 . if (A == B)
2-657 . {
2-658 . A = B + C;
2-659 . D = E + F;
2-660 . }
2-661 .
2-662 .
2-663 . if (A le B)
2-664 . {
2-665 . A = B + C;
2-666 . D = E + F;
2-667 . }
2-668 .
2-669 .
2-670 . if (A le B)
2-671 . {
2-672 . A = B + C;
2-673 . D = E + F;
2-674 . }
2-675 .
2-676 . A = B+C;
2-677 . // max LOC 57
2-678 .
2-679 . }
2-680 .
2-681 .
2-682 . /*
2-683 . -----------------------------------------------------------------------------
2-684 . --| NAME: ca.2.4
2-685 . --|
2-686 . --| ABSTRACT:
2-687 . --| This function does ca stuff.
2-688 . --|
2-689 . --| RETURNS:
2-690 . --| NONE.
2-691 . --|
2-692 . ----------------------------------------------------------------------------
2-693 . */
2-694 . static void ca.2.4(void)
2-695 . {
2-696 . A = B+C;
2-697 . /* LE SV TOC-1038 this is a ca-02.4.2 req to halt*/
2-698 . A = B+C;
2-699 .
2-700 . if (A != B)
2-701 . {
2-702 . A = B + C;
2-703 . D = E + F;
2-704 . }
2-705 .
2-706 . A = 0x0006;
2-707 .
2-708 . if (A > = B)
2-709 . {
2-710 . A = B + C;
2-711 . D = E + F;
2-712 . }
2-713 .
2-714 . A = B-C;
2-715 . A = B/C;
2-716 .
2-717 . if (A > = B)
2-718 . {
2-719 . A = B + C;
2-720 . D = E + F;
2-721 . }
2-722 .
2-723 . A = B/C;
2-724 . A = B*C;
2-725 . A = B/C;
2-726 . /* LE SV TOC-1039 this is a ca-02.4.11 req to increment*/
2-727 . A = B+C;
2-728 . A = B/C;
2-729 .
2-730 . if (A > B)
2-731 . {
2-732 . A = B + C;
2-733 . D = E + F;
2-734 . }
2-735 .
2-736 . A = B-C;
2-737 . A = B+C;
2-738 . A = B-C;
2-739 . A = B/C;
2-740 . A = B+C;
2-741 . A = B+C;
2-742 . A = B-C;
2-743 . A = B*C;
2-744 .
2-745 . if (A gt B)
2-746 . {
2-747 . A = B + C;
2-748 . D = E + F;
2-749 . }
2-750 .
2-751 . FreePtr = HmiStringPtr;
2-752 .
2-753 . if (A > = B)
2-754 . {
2-755 . A = B + C;
2-756 . D = E + F;
2-757 . }
2-758 .
2-759 .
2-760 . if (A < = B)
2-761 . {
2-762 . A = B + C;
2-763 . D = E + F;
2-764 . }
2-765 .
2-766 . A = B/C;
2-767 . /* LE SV TOC-1040 this is a ca-02.4.26 req to check unix*/
2-768 .
2-769 . switch (ca stuff)
2-770 . {
2-771 . case one:
2-772 . {
2-773 . run_this;
2-774 . break;
2-775 . }
2-776 . case two:
2-777 . {
2-778 . run_this;
2-779 . break;
2-780 . }
2-781 . default:
2-782 . {
2-783 . SwError;
2-784 . }
2-785 . }
2-786 .
2-787 . A = B/C;
2-788 .
2-789 . if (A lt B)
2-790 . {
2-791 . A = B + C;
2-792 . D = E + F;
2-793 . }
2-794 .
2-795 .
2-796 . if (A > B)
2-797 . {
2-798 . A = B + C;
2-799 . D = E + F;
2-800 . }
2-801 .
2-802 .
2-803 . if (A lt B)
2-804 . {
2-805 . A = B + C;
2-806 . D = E + F;
2-807 . }
2-808 .
2-809 . A = B+C;
2-810 .
2-811 . if (A lt B)
2-812 . {
2-813 . A = B + C;
2-814 . D = E + F;
2-815 . }
2-816 .
2-817 .
2-818 . if (A > = B)
2-819 . {
2-820 . A = B + C;
2-821 . D = E + F;
2-822 . }
2-823 .
2-824 .
2-825 . if (A ne B)
2-826 . {
2-827 . A = B + C;
2-828 . D = E + F;
2-829 . }
2-830 .
2-831 . A = B-C;
2-832 . A = B-C;
2-833 . A = B+C;
2-834 . A = B/C;
2-835 .
2-836 . if (A eq B)
2-837 . {
2-838 . A = B + C;
2-839 . D = E + F;
2-840 . }
2-841 .
2-842 .
2-843 . if (A ge B)
2-844 . {
2-845 . A = B + C;
2-846 . D = E + F;
2-847 . }
2-848 .
2-849 . /* LE SV TOC-1041 this is a ca-02.4.41 req to halt*/
2-850 .
2-851 . if (A ne B)
2-852 . {
2-853 . A = B + C;
2-854 . D = E + F;
2-855 . }
2-856 .
2-857 . A = B+C;
2-858 . /* LE SV TOC-1042 this is a ca-02.4.43 req to audit*/
2-859 . A = B*C;
2-860 .
2-861 . if (A == B)
2-862 . {
2-863 . A = B + C;
2-864 . D = E + F;
2-865 . }
2-866 .
2-867 .
2-868 . switch (ca stuff)
2-869 . {
2-870 . case:
2-871 . case:
2-872 . // stacked case statements but only if there is a new line in between
2-873 .
2-874 . case:
2-875 . case:
2-876 . case:
2-877 . {
2-878 . run_this;
2-879 . break;
2-880 . }
2-881 . default:
2-882 . {
2-883 . halt;
2-884 . }
2-885 . }
2-886 .
2-887 . A = B-C;
2-888 . A = B+C;
2-889 .
2-890 . if (A > = B)
2-891 . {
2-892 . A = B + C;
2-893 . D = E + F;
2-894 . }
2-895 .
2-896 . /* LE SV TOC-1043 this is a ca-02.4.48 req to check pSOS*/
2-897 . A = B*C;
2-898 . A = B-C;
2-899 . A = 0x0006;
2-900 .
2-901 . if (A == B)
2-902 . {
2-903 . A = B + C;
2-904 . D = E + F;
2-905 . }
2-906 .
2-907 . A = B*C;
2-908 . A = B+C;
2-909 . A = B+C;
2-910 . A = B-C;
2-911 . A = B*C;
2-912 . A = B-C;
2-913 . A = B*C;
2-914 .
2-915 . if (A le B)
2-916 . {
2-917 . A = B + C;
2-918 . D = E + F;
2-919 . }
2-920 .
2-921 . A = B+C;
2-922 . A = B/C;
2-923 . A = B*C;
2-924 . A = B*C;
2-925 . A = B*C;
2-926 .
2-927 . /* dead_code = B + C;
2-928 . dead_code = D + E;
2-929 . dead_code = F + G; */
2-930 .
2-931 . A = B-C;
2-932 .
2-933 . switch (ca stuff)
2-934 . {
2-935 . case one:
2-936 . {
2-937 . run_this;
2-938 . break;
2-939 . }
2-940 . case two:
2-941 . {
2-942 . run_this;
2-943 . break;
2-944 . }
2-945 . default:
2-946 . {
2-947 . SwError;
2-948 . }
2-949 . }
2-950 .
2-951 .
2-952 . if (A eq B)
2-953 . {
2-954 . A = B + C;
2-955 . D = E + F;
2-956 . }
2-957 .
2-958 . A = B*C;
2-959 . A = B-C;
2-960 .
2-961 . if (A < = B)
2-962 . {
2-963 . A = B + C;
2-964 . D = E + F;
2-965 . }
2-966 .
2-967 . A = B/C;
2-968 . A = B*C;
2-969 . A = B/C;
2-970 . A = B+C;
2-971 . A = B-C;
2-972 . A = B/C;
2-973 . A = B+C;
2-974 .
2-975 . if ($ca stuff > $otherca stuff)
2-976 . /* LE SV TOC-008 we really should log all error calls */
2-977 . {
2-978 . A = B + C;
2-979 . }
2-980 .
2-981 .
2-982 . switch (ca stuff)
2-983 . {
2-984 . case one:
2-985 . {
2-986 . run_this;
2-987 . break;
2-988 . }
2-989 . case two:
2-990 . {
2-991 . run_this;
2-992 . break;
2-993 . }
2-994 . default:
2-995 . {
2-996 . SwError;
2-997 . }
2-998 . }
2-999 .
2-1000 . A = B+C;
2-1001 . /* LE SV TOC-1044 this is a ca-02.4.79 req to recover*/
2-1002 .
2-1003 . switch (ca stuff)
2-1004 . {
2-1005 . case one:
2-1006 . {
2-1007 . run_this;
2-1008 . break;
2-1009 . }
2-1010 . case two:
2-1011 . {
2-1012 . run_this;
2-1013 . break;
2-1014 . }
2-1015 . // missing default
2-1016 . }
2-1017 .
2-1018 . A = B-C;
2-1019 . A = B/C;
2-1020 .
2-1021 . if (A != B)
2-1022 . {
2-1023 . A = B + C;
2-1024 . D = E + F;
2-1025 . }
2-1026 .
2-1027 . A = B/C;
2-1028 . // (P) this is really improtant
2-1029 . A = B+C;
2-1030 .
2-1031 . if (A le B)
2-1032 . {
2-1033 . A = B + C;
2-1034 . D = E + F;
2-1035 . }
2-1036 .
2-1037 .
2-1038 . if (A gt B)
2-1039 . {
2-1040 . A = B + C;
2-1041 . D = E + F;
2-1042 . }
2-1043 .
2-1044 . // max LOC 85
2-1045 .
2-1046 . }
2-1047 .
2-1048 .
2-1049 . /*
2-1050 . -----------------------------------------------------------------------------
2-1051 . --| NAME: ca.2.5
2-1052 . --|
2-1053 . --| ABSTRACT:
2-1054 . --| This function does ca stuff.
2-1055 . --|
2-1056 . --| RETURNS:
2-1057 . --| NONE.
2-1058 . --|
2-1059 . ----------------------------------------------------------------------------
2-1060 . */
2-1061 . static void ca.2.5(void)
2-1062 . {
2-1063 . A = B+C;
2-1064 . A = B*C;
2-1065 . A = B*C;
2-1066 .
2-1067 . if (A > B)
2-1068 . {
2-1069 . A = B + C;
2-1070 . D = E + F;
2-1071 . }
2-1072 .
2-1073 . A = B*C;
2-1074 . A = B+C;
2-1075 . A = B+C;
2-1076 .
2-1077 . if (A lt B)
2-1078 . {
2-1079 . A = B + C;
2-1080 . D = E + F;
2-1081 . }
2-1082 .
2-1083 . A = B/C;
2-1084 .
2-1085 . switch (ca stuff)
2-1086 . {
2-1087 . case one:
2-1088 . {
2-1089 . run_this;
2-1090 . break;
2-1091 . }
2-1092 . case two:
2-1093 . {
2-1094 . run_this;
2-1095 . break;
2-1096 . }
2-1097 . default:
2-1098 . {
2-1099 . SwError;
2-1100 . }
2-1101 . }
2-1102 .
2-1103 . A = B/C;
2-1104 .
2-1105 . if (A == B)
2-1106 . {
2-1107 . A = B + C;
2-1108 . D = E + F;
2-1109 . }
2-1110 .
2-1111 . A = B*C;
2-1112 . A = B/C;
2-1113 . A = B+C;
2-1114 . A = B-C;
2-1115 . A = B-C;
2-1116 . A = B+C;
2-1117 .
2-1118 . if (veg)
2-1119 . // missing curly brace
2-1120 . variable = orange;
2-1121 .
2-1122 . A = B*C;
2-1123 .
2-1124 . if (A < = B)
2-1125 . {
2-1126 . A = B + C;
2-1127 . D = E + F;
2-1128 . }
2-1129 .
2-1130 . A = B/C;
2-1131 . A = B+C;
2-1132 . A = B-C;
2-1133 . A = B-C;
2-1134 . A = B-C;
2-1135 . A = B+C;
2-1136 . /* LE SV TOC-1045 this is a ca-02.5.27 req to call admin*/
2-1137 .
2-1138 . if (A le B)
2-1139 . {
2-1140 . A = B + C;
2-1141 . D = E + F;
2-1142 . }
2-1143 .
2-1144 . A = B*C;
2-1145 . A = B/C;
2-1146 .
2-1147 . if (A < = B)
2-1148 . {
2-1149 . A = B + C;
2-1150 . D = E + F;
2-1151 . }
2-1152 .
2-1153 . A = B*C;
2-1154 . A = B-C;
2-1155 .
2-1156 . if (A < B)
2-1157 . {
2-1158 . A = B + C;
2-1159 . D = E + F;
2-1160 . }
2-1161 .
2-1162 . A = B/C;
2-1163 . A = B+C;
2-1164 .
2-1165 . if (A < B)
2-1166 . {
2-1167 . A = B + C;
2-1168 . D = E + F;
2-1169 . }
2-1170 .
2-1171 . A = B*C;
2-1172 .
2-1173 . if (A == B)
2-1174 . {
2-1175 . A = B + C;
2-1176 . D = E + F;
2-1177 . }
2-1178 .
2-1179 . /* LE SV TOC-1046 this is a ca-02.5.39 req to set Real Time Clock*/
2-1180 .
2-1181 . if (A le B)
2-1182 . {
2-1183 . A = B + C;
2-1184 . D = E + F;
2-1185 . }
2-1186 .
2-1187 . A = B+C;
2-1188 .
2-1189 . if (A > = B)
2-1190 . {
2-1191 . A = B + C;
2-1192 . D = E + F;
2-1193 . }
2-1194 .
2-1195 .
2-1196 . if (A > = B)
2-1197 . {
2-1198 . A = B + C;
2-1199 . D = E + F;
2-1200 . }
2-1201 .
2-1202 . A = B+C;
2-1203 . A = B-C;
2-1204 . A = B*C;
2-1205 . A = B*C;
2-1206 . A = B+C;
2-1207 . A = B+C;
2-1208 .
2-1209 . /*
2-1210 . dead_code = B - C;
2-1211 . dead_code = D - E;
2-1212 . dead_code = F - G;
2-1213 . */
2-1214 .
2-1215 . A = B-C;
2-1216 . A = B-C;
2-1217 . A = B/C;
2-1218 . A = B*C;
2-1219 . FreePtr = HmiStringPtr;
2-1220 .
2-1221 . if (A gt B)
2-1222 . {
2-1223 . A = B + C;
2-1224 . D = E + F;
2-1225 . }
2-1226 .
2-1227 . A = 0x0004;
2-1228 . A = B+C;
2-1229 . A = B-C;
2-1230 .
2-1231 . switch (ca stuff)
2-1232 . {
2-1233 . case:
2-1234 . case:
2-1235 . // stacked case statements but only if there is a new line in between
2-1236 .
2-1237 . case:
2-1238 . case:
2-1239 . case:
2-1240 . {
2-1241 . run_this;
2-1242 . break;
2-1243 . }
2-1244 . default:
2-1245 . {
2-1246 . halt;
2-1247 . }
2-1248 . }
2-1249 .
2-1250 . A = B/C;
2-1251 . A = B+C;
2-1252 .
2-1253 . if (A != B)
2-1254 . {
2-1255 . A = B + C;
2-1256 . D = E + F;
2-1257 . }
2-1258 .
2-1259 . A = B*C;
2-1260 . A = B*C;
2-1261 . A = B*C;
2-1262 . A = B+C;
2-1263 .
2-1264 . if (A < = B)
2-1265 . {
2-1266 . A = B + C;
2-1267 . D = E + F;
2-1268 . }
2-1269 .
2-1270 . A = B+C;
2-1271 .
2-1272 . if (A < B)
2-1273 . {
2-1274 . A = B + C;
2-1275 . D = E + F;
2-1276 . }
2-1277 .
2-1278 .
2-1279 . if (A < B)
2-1280 . {
2-1281 . A = B + C;
2-1282 . D = E + F;
2-1283 . }
2-1284 .
2-1285 . A = B*C;
2-1286 . A = B*C;
2-1287 . A = B-C;
2-1288 .
2-1289 . if (A != B)
2-1290 . {
2-1291 . A = B + C;
2-1292 . D = E + F;
2-1293 . }
2-1294 .
2-1295 . // ??? go see ws
2-1296 . A = B*C;
2-1297 . // max LOC 71
2-1298 .
2-1299 . }
2-1300 .
2-1301 .
2-1302 . /*
2-1303 . -----------------------------------------------------------------------------
2-1304 . --| NAME: ca.2.6
2-1305 . --|
2-1306 . --| ABSTRACT:
2-1307 . --| This function does ca stuff.
2-1308 . --|
2-1309 . --| RETURNS:
2-1310 . --| NONE.
2-1311 . --|
2-1312 . ----------------------------------------------------------------------------
2-1313 . */
2-1314 . static void ca.2.6(void)
2-1315 . {
2-1316 .
2-1317 . if (A ne B)
2-1318 . {
2-1319 . A = B + C;
2-1320 . D = E + F;
2-1321 . }
2-1322 .
2-1323 .
2-1324 . if (A eq B)
2-1325 . {
2-1326 . A = B + C;
2-1327 . D = E + F;
2-1328 . }
2-1329 .
2-1330 .
2-1331 . if (A lt B)
2-1332 . {
2-1333 . A = B + C;
2-1334 . D = E + F;
2-1335 . }
2-1336 .
2-1337 .
2-1338 . if (A lt B)
2-1339 . {
2-1340 . A = B + C;
2-1341 . D = E + F;
2-1342 . }
2-1343 .
2-1344 .
2-1345 . if (A lt B)
2-1346 . {
2-1347 . A = B + C;
2-1348 . D = E + F;
2-1349 . }
2-1350 .
2-1351 .
2-1352 . switch (ca stuff)
2-1353 . {
2-1354 . case one:
2-1355 . {
2-1356 . switch (nested)
2-1357 . {
2-1358 . case:
2-1359 . X = Y + Z;
2-1360 . case:
2-1361 . X = Y + Z;
2-1362 . default:
2-1363 . SwError;
2-1364 . }
2-1365 . }
2-1366 . case two:
2-1367 . {
2-1368 . run_this;
2-1369 . break;
2-1370 . }
2-1371 . default:
2-1372 . {
2-1373 . SwError;
2-1374 . }
2-1375 . }
2-1376 .
2-1377 . A = B/C;
2-1378 . A = B*C;
2-1379 . goto error;
2-1380 . A = B+C;
2-1381 . A = B+C;
2-1382 .
2-1383 . if (A ge B)
2-1384 . {
2-1385 . A = B + C;
2-1386 . D = E + F;
2-1387 . }
2-1388 .
2-1389 . A = B-C;
2-1390 . A = 0x0002;
2-1391 . A = B/C;
2-1392 . A = B+C;
2-1393 . A = B*C;
2-1394 . // max LOC 14
2-1395 .
2-1396 . }
2-1397 .
2-1398 .
2-1399 . /*
2-1400 . -----------------------------------------------------------------------------
2-1401 . --| NAME: ca.2.7
2-1402 . --|
2-1403 . --| ABSTRACT:
2-1404 . --| This function does ca stuff.
2-1405 . --|
2-1406 . --| RETURNS:
2-1407 . --| NONE.
2-1408 . --|
2-1409 . ----------------------------------------------------------------------------
2-1410 . */
2-1411 . static void ca.2.7(void)
2-1412 . {
2-1413 .
2-1414 . if (A == B)
2-1415 . {
2-1416 . A = B + C;
2-1417 . D = E + F;
2-1418 . }
2-1419 .
2-1420 . send_buffer = (U16 *) malloc(size+1);
2-1421 .
2-1422 . if (A ne B)
2-1423 . {
2-1424 . A = B + C;
2-1425 . D = E + F;
2-1426 . }
2-1427 .
2-1428 . A = B-C;
2-1429 .
2-1430 . if (A ge B)
2-1431 . {
2-1432 . A = B + C;
2-1433 . D = E + F;
2-1434 . }
2-1435 .
2-1436 . A = B+C;
2-1437 . A = B*C;
2-1438 .
2-1439 . if (A == B)
2-1440 . {
2-1441 . A = B + C;
2-1442 . D = E + F;
2-1443 . }
2-1444 .
2-1445 .
2-1446 . if (A != B)
2-1447 . {
2-1448 . A = B + C;
2-1449 . D = E + F;
2-1450 . }
2-1451 .
2-1452 . A = B/C;
2-1453 .
2-1454 . if (A != B)
2-1455 . {
2-1456 . A = B + C;
2-1457 . D = E + F;
2-1458 . }
2-1459 .
2-1460 . A = B*C;
2-1461 . A = B/C;
2-1462 .
2-1463 . if (A gt B)
2-1464 . {
2-1465 . A = B + C;
2-1466 . D = E + F;
2-1467 . }
2-1468 .
2-1469 . A = B/C;
2-1470 .
2-1471 . if (A > = B)
2-1472 . {
2-1473 . A = B + C;
2-1474 . D = E + F;
2-1475 . }
2-1476 .
2-1477 .
2-1478 . if (A le B)
2-1479 . {
2-1480 . A = B + C;
2-1481 . D = E + F;
2-1482 . }
2-1483 .
2-1484 . A = B-C;
2-1485 . A = B+C;
2-1486 .
2-1487 . if (A gt B)
2-1488 . {
2-1489 . A = B + C;
2-1490 . D = E + F;
2-1491 . }
2-1492 .
2-1493 . do forever;
2-1494 . A = B-C;
2-1495 . A = B-C;
2-1496 . A = B+C;
2-1497 . A = B+C;
2-1498 . A = B*C;
2-1499 . A = B*C;
2-1500 . A = B/C;
2-1501 . A = B/C;
2-1502 . A = B*C;
2-1503 . A = B/C;
2-1504 .
2-1505 . if (A eq B)
2-1506 . {
2-1507 . A = B + C;
2-1508 . D = E + F;
2-1509 . }
2-1510 .
2-1511 . A = B*C;
2-1512 . /* LE SV TOC-1047 this is a ca-02.7.32 req to increment*/
2-1513 .
2-1514 . /*
2-1515 . dead_block = C * D;
2-1516 . dead_block = E * F;
2-1517 . */
2-1518 .
2-1519 . A = B+C;
2-1520 .
2-1521 . if (A < B)
2-1522 . {
2-1523 . A = B + C;
2-1524 . D = E + F;
2-1525 . }
2-1526 .
2-1527 . A = B+C;
2-1528 . A = B*C;
2-1529 .
2-1530 . if (A lt B)
2-1531 . {
2-1532 . A = B + C;
2-1533 . D = E + F;
2-1534 . }
2-1535 .
2-1536 .
2-1537 . switch (ca stuff)
2-1538 . {
2-1539 . case:
2-1540 . case:
2-1541 . // stacked case statements but only if there is a new line in between
2-1542 .
2-1543 . case:
2-1544 . case:
2-1545 . case:
2-1546 . {
2-1547 . run_this;
2-1548 . break;
2-1549 . }
2-1550 . default:
2-1551 . {
2-1552 . halt;
2-1553 . }
2-1554 . }
2-1555 .
2-1556 . A = B/C;
2-1557 .
2-1558 . if (A ne B)
2-1559 . {
2-1560 . A = B + C;
2-1561 . D = E + F;
2-1562 . }
2-1563 .
2-1564 . A = B*C;
2-1565 . A = B-C;
2-1566 .
2-1567 . if (A le B)
2-1568 . {
2-1569 . A = B + C;
2-1570 . D = E + F;
2-1571 . }
2-1572 .
2-1573 . A = B*C;
2-1574 . A = B*C;
2-1575 . A = B/C;
2-1576 .
2-1577 . if (A ge B)
2-1578 . {
2-1579 . A = B + C;
2-1580 . D = E + F;
2-1581 . }
2-1582 .
2-1583 .
2-1584 . if (A < = B)
2-1585 . {
2-1586 . A = B + C;
2-1587 . D = E + F;
2-1588 . }
2-1589 .
2-1590 .
2-1591 . if (A > = B)
2-1592 . {
2-1593 . A = B + C;
2-1594 . D = E + F;
2-1595 . }
2-1596 .
2-1597 .
2-1598 . if (A < = B)
2-1599 . {
2-1600 . A = B + C;
2-1601 . D = E + F;
2-1602 . }
2-1603 .
2-1604 .
2-1605 . if (A > B)
2-1606 . {
2-1607 . A = B + C;
2-1608 . D = E + F;
2-1609 . }
2-1610 .
2-1611 . A = B*C;
2-1612 .
2-1613 . if (A le B)
2-1614 . {
2-1615 . A = B + C;
2-1616 . D = E + F;
2-1617 . }
2-1618 .
2-1619 .
2-1620 . if (A == B)
2-1621 . {
2-1622 . A = B + C;
2-1623 . D = E + F;
2-1624 . }
2-1625 .
2-1626 . A = B+C;
2-1627 . A = B+C;
2-1628 . A = B-C;
2-1629 . A = B/C;
2-1630 .
2-1631 . if (A eq B)
2-1632 . {
2-1633 . A = B + C;
2-1634 . D = E + F;
2-1635 . }
2-1636 .
2-1637 .
2-1638 . if (A eq B)
2-1639 . {
2-1640 . A = B + C;
2-1641 . D = E + F;
2-1642 . }
2-1643 .
2-1644 . A = B*C;
2-1645 . /* LE SV TOC-1048 this is a ca-02.7.60 req to set RTC*/
2-1646 .
2-1647 . if (A ne B)
2-1648 . {
2-1649 . A = B + C;
2-1650 . D = E + F;
2-1651 . }
2-1652 .
2-1653 . A = B+C;
2-1654 . A = B-C;
2-1655 . /* LE SV TOC-1049 this is a ca-02.7.63 req to disable*/
2-1656 . A = B+C;
2-1657 . A = B*C;
2-1658 . A = B*C;
2-1659 . A = B-C;
2-1660 . A = B*C;
2-1661 . A = B-C;
2-1662 . A = B+C;
2-1663 .
2-1664 . if (A ne B)
2-1665 . {
2-1666 . A = B + C;
2-1667 . D = E + F;
2-1668 . }
2-1669 .
2-1670 .
2-1671 . if (A ge B)
2-1672 . {
2-1673 . A = B + C;
2-1674 . D = E + F;
2-1675 . }
2-1676 .
2-1677 . A = B+C;
2-1678 . A = B-C;
2-1679 . A = B/C;
2-1680 . A = B*C;
2-1681 .
2-1682 . if (A < = B)
2-1683 . {
2-1684 . A = B + C;
2-1685 . D = E + F;
2-1686 . }
2-1687 .
2-1688 . A = B+C;
2-1689 .
2-1690 . switch (ca stuff)
2-1691 . {
2-1692 . case one:
2-1693 . {
2-1694 . run_this;
2-1695 . // missing break
2-1696 . }
2-1697 . case two:
2-1698 . {
2-1699 . run_this;
2-1700 . break;
2-1701 . }
2-1702 . default:
2-1703 . {
2-1704 . SwError;
2-1705 . }
2-1706 . }
2-1707 .
2-1708 . A = B*C;
2-1709 .
2-1710 . if (A le B)
2-1711 . {
2-1712 . A = B + C;
2-1713 . D = E + F;
2-1714 . }
2-1715 .
2-1716 . A = B*C;
2-1717 . // max LOC 80
2-1718 .
2-1719 . }
2-1720 .
2-1721 .
2-1722 . /*
2-1723 . -----------------------------------------------------------------------------
2-1724 . --| NAME: ca.2.8
2-1725 . --|
2-1726 . --| ABSTRACT:
2-1727 . --| This function does ca stuff.
2-1728 . --|
2-1729 . --| RETURNS:
2-1730 . --| NONE.
2-1731 . --|
2-1732 . ----------------------------------------------------------------------------
2-1733 . */
2-1734 . static void ca.2.8(void)
2-1735 . {
2-1736 . A = B*C;
2-1737 .
2-1738 . if (A != B)
2-1739 . {
2-1740 . A = B + C;
2-1741 . D = E + F;
2-1742 . }
2-1743 .
2-1744 . // ??? go see ws
2-1745 . A = B-C;
2-1746 .
2-1747 . if (A le B)
2-1748 . {
2-1749 . A = B + C;
2-1750 . D = E + F;
2-1751 . }
2-1752 .
2-1753 .
2-1754 . switch (ca stuff)
2-1755 . {
2-1756 . case one:
2-1757 . {
2-1758 . run_this;
2-1759 . break;
2-1760 . }
2-1761 . case two:
2-1762 . {
2-1763 . run_this;
2-1764 . break;
2-1765 . }
2-1766 . default:
2-1767 . {
2-1768 . SwError;
2-1769 . }
2-1770 . }
2-1771 .
2-1772 .
2-1773 . if (A < = B)
2-1774 . {
2-1775 . A = B + C;
2-1776 . D = E + F;
2-1777 . }
2-1778 .
2-1779 .
2-1780 . switch (ca stuff)
2-1781 . {
2-1782 . case one:
2-1783 . {
2-1784 . run_this;
2-1785 . break;
2-1786 . }
2-1787 . case two:
2-1788 . {
2-1789 . run_this;
2-1790 . break;
2-1791 . }
2-1792 . default:
2-1793 . {
2-1794 . SwError;
2-1795 . }
2-1796 . }
2-1797 .
2-1798 . A = B-C;
2-1799 .
2-1800 . if (A lt B)
2-1801 . {
2-1802 . A = B + C;
2-1803 . D = E + F;
2-1804 . }
2-1805 .
2-1806 . A = B/C;
2-1807 . A = B-C;
2-1808 . A = B-C;
2-1809 . A = B-C;
2-1810 . // max LOC 13
2-1811 .
2-1812 . }
2-1813 .
2 2 Result: result/source/pr-app/pr-app-CA123/ca/ca-02.c
3 3 Source: source/pr-app/pr-app-CA123/ca/ca-03.c
3-0 . /*
3-1 . ----------------------------------------------------------------------------
3-2 . --| BEGIN PROLOGUE
3-3 . --|
3-4 . --| CLASSIFICATION: UNCLASSIFIED
3-5 . --|
3-6 . --| FILE NAME: ca-03.c
3-7 . --|
3-8 . --| ABSTRACT:
3-9 . --| This file contains the 2 functions that do file ca stuff.
3-10 . --|
3-11 . --| HISTORY:
3-12 . --| CCCQ_NAME:
3-13 . --| CCCQ_VER:
3-14 . --|
3-15 . --| END PROLOGUE
3-16 . ----------------------------------------------------------------------------
3-17 . */
3-18 .
3-19 . double C;
3-20 . #include B;
3-21 . #include B;
3-22 . #define C;
3-23 .
3-24 .
3-25 .
3-26 . /*
3-27 . -----------------------------------------------------------------------------
3-28 . --| NAME: ca.3.1
3-29 . --|
3-30 . --| ABSTRACT:
3-31 . --| This function does ca stuff.
3-32 . --|
3-33 . --| RETURNS:
3-34 . --| NONE.
3-35 . --|
3-36 . ----------------------------------------------------------------------------
3-37 . */
3-38 . static void ca.3.1(void)
3-39 . {
3-40 . A = B/C;
3-41 . A = B+C;
3-42 .
3-43 . if (A gt B)
3-44 . {
3-45 . A = B + C;
3-46 . D = E + F;
3-47 . }
3-48 .
3-49 . A = B-C;
3-50 . A = B-C;
3-51 .
3-52 . if (A != B)
3-53 . {
3-54 . A = B + C;
3-55 . D = E + F;
3-56 . }
3-57 .
3-58 . A = B+C;
3-59 . A = B/C;
3-60 . A = B-C;
3-61 . A = 0x0001;
3-62 . A = B+C;
3-63 . A = B-C;
3-64 .
3-65 . if (A == B)
3-66 . {
3-67 . A = B + C;
3-68 . D = E + F;
3-69 . }
3-70 .
3-71 . A = B*C;
3-72 . A = B-C;
3-73 .
3-74 . if (A > B)
3-75 . {
3-76 . A = B + C;
3-77 . D = E + F;
3-78 . }
3-79 .
3-80 . A = (long)B + C;
3-81 . A = B-C;
3-82 . A = B*C;
3-83 . A = B/C;
3-84 .
3-85 . if (A ge B)
3-86 . {
3-87 . A = B + C;
3-88 . D = E + F;
3-89 . }
3-90 .
3-91 . // max LOC 19
3-92 .
3-93 . }
3-94 .
3-95 .
3-96 . /*
3-97 . -----------------------------------------------------------------------------
3-98 . --| NAME: ca.3.2
3-99 . --|
3-100 . --| ABSTRACT:
3-101 . --| This function does ca stuff.
3-102 . --|
3-103 . --| RETURNS:
3-104 . --| NONE.
3-105 . --|
3-106 . ----------------------------------------------------------------------------
3-107 . */
3-108 . static void ca.3.2(void)
3-109 . {
3-110 . A = 0x0006;
3-111 .
3-112 . if (A > = B)
3-113 . {
3-114 . A = B + C;
3-115 . D = E + F;
3-116 . }
3-117 .
3-118 .
3-119 . if (A == B)
3-120 . {
3-121 . A = B + C;
3-122 . D = E + F;
3-123 . }
3-124 .
3-125 .
3-126 . if (A > = B)
3-127 . {
3-128 . A = B + C;
3-129 . D = E + F;
3-130 . }
3-131 .
3-132 .
3-133 . if (A > B)
3-134 . {
3-135 . A = B + C;
3-136 . D = E + F;
3-137 . }
3-138 .
3-139 .
3-140 . if (A != B)
3-141 . {
3-142 . A = B + C;
3-143 . D = E + F;
3-144 . }
3-145 .
3-146 . A = B*C;
3-147 . A = B/C;
3-148 .
3-149 . if (A gt B)
3-150 . {
3-151 . A = B + C;
3-152 . D = E + F;
3-153 . }
3-154 .
3-155 . A = B*C;
3-156 . A = B*C;
3-157 . A = B+C;
3-158 . /* LE SV TOC-1050 this is a ca-03.2.12 req to call isr*/
3-159 . A = B/C;
3-160 . A = B/C;
3-161 . A = B/C;
3-162 . A = B+C;
3-163 . // max LOC 15
3-164 .
3-165 . }
3-166 .
3 3 Result: result/source/pr-app/pr-app-CA123/ca/ca-03.c
4 4 Source: source/pr-app/pr-app-CA123/ca/ca-04.c
4-0 . /*
4-1 . ----------------------------------------------------------------------------
4-2 . --| BEGIN PROLOGUE
4-3 . --|
4-4 . --| CLASSIFICATION: UNCLASSIFIED
4-5 . --|
4-6 . --| FILE NAME: ca-04.c
4-7 . --|
4-8 . --| ABSTRACT:
4-9 . --| This file contains the 1 functions that do file ca stuff.
4-10 . --|
4-11 . --| HISTORY:
4-12 . --| CCCQ_NAME:
4-13 . --| CCCQ_VER:
4-14 . --|
4-15 . --| END PROLOGUE
4-16 . ----------------------------------------------------------------------------
4-17 . */
4-18 .
4-19 . int A;
4-20 . #define B;
4-21 . #include D;
4-22 . #include C;
4-23 . #include D;
4-24 .
4-25 .
4-26 .
4-27 . /*
4-28 . -----------------------------------------------------------------------------
4-29 . --| NAME: ca.4.1
4-30 . --|
4-31 . --| ABSTRACT:
4-32 . --| This function does ca stuff.
4-33 . --|
4-34 . --| RETURNS:
4-35 . --| NONE.
4-36 . --|
4-37 . ----------------------------------------------------------------------------
4-38 . */
4-39 . static void ca.4.1(void)
4-40 . {
4-41 . A = B+C;
4-42 .
4-43 . if (A < = B)
4-44 . {
4-45 . A = B + C;
4-46 . D = E + F;
4-47 . }
4-48 .
4-49 . A = B+C;
4-50 . A = B+C;
4-51 . A = B/C;
4-52 . A = B-C;
4-53 . A = B*C;
4-54 . A = B*C;
4-55 . A = (long)B + C;
4-56 .
4-57 . if (A != B)
4-58 . {
4-59 . A = B + C;
4-60 . D = E + F;
4-61 . }
4-62 .
4-63 . A = B-C;
4-64 . A = B+C;
4-65 . A = B*C;
4-66 . A = B/C;
4-67 . A = B/C;
4-68 . A = B-C;
4-69 .
4-70 . if (A eq B)
4-71 . {
4-72 . A = B + C;
4-73 . D = E + F;
4-74 . }
4-75 .
4-76 .
4-77 . if (A eq B)
4-78 . {
4-79 . A = B + C;
4-80 . D = E + F;
4-81 . }
4-82 .
4-83 . A = B*C;
4-84 .
4-85 . if (A ge B)
4-86 . {
4-87 . A = B + C;
4-88 . D = E + F;
4-89 . }
4-90 .
4-91 . /* LE SV TOC-1051 this is a ca-04.1.20 req to process*/
4-92 . A = B/C;
4-93 . A = B-C;
4-94 . A = B+C;
4-95 . A = B/C;
4-96 . A = B-C;
4-97 . A = B*C;
4-98 . A = B-C;
4-99 . A = B*C;
4-100 .
4-101 . if (A < B)
4-102 . {
4-103 . A = B + C;
4-104 . D = E + F;
4-105 . }
4-106 .
4-107 . A = B*C;
4-108 . A = B-C;
4-109 .
4-110 . if (A lt B)
4-111 . {
4-112 . A = B + C;
4-113 . D = E + F;
4-114 . }
4-115 .
4-116 .
4-117 . if (A > B)
4-118 . {
4-119 . A = B + C;
4-120 . D = E + F;
4-121 . }
4-122 .
4-123 . A = B-C;
4-124 . A = B*C;
4-125 . A = B+C;
4-126 . A = B/C;
4-127 . A = B/C;
4-128 . /* LE SV TOC-1052 this is a ca-04.1.38 req to check pSOS*/
4-129 . A = B-C;
4-130 . A = B*C;
4-131 . /* LE SV TOC-1053 this is a ca-04.1.40 req to detect error*/
4-132 . A = B*C;
4-133 . /* LE SV TOC-1054 this is a ca-04.1.41 req to halt*/
4-134 . A = B-C;
4-135 .
4-136 . if (A ne B)
4-137 . {
4-138 . A = B + C;
4-139 . D = E + F;
4-140 . }
4-141 .
4-142 . A = B-C;
4-143 . A = B*C;
4-144 .
4-145 . if (A ne B)
4-146 . {
4-147 . A = B + C;
4-148 . D = E + F;
4-149 . }
4-150 .
4-151 . A = B-C;
4-152 . A = B*C;
4-153 . A = B/C;
4-154 .
4-155 . switch (ca stuff)
4-156 . {
4-157 . case one:
4-158 . {
4-159 . run_this;
4-160 . break;
4-161 . }
4-162 . case two:
4-163 . {
4-164 . run_this;
4-165 . break;
4-166 . }
4-167 . default:
4-168 . {
4-169 . SwError;
4-170 . }
4-171 . }
4-172 .
4-173 . A = B/C;
4-174 . A = B+C;
4-175 .
4-176 . if (A > B)
4-177 . {
4-178 . A = B + C;
4-179 . D = E + F;
4-180 . }
4-181 .
4-182 . A = B/C;
4-183 .
4-184 . if (A gt B)
4-185 . {
4-186 . A = B + C;
4-187 . D = E + F;
4-188 . }
4-189 .
4-190 . A = B/C;
4-191 . A = B-C;
4-192 . A = B/C;
4-193 . A = B*C;
4-194 . A = B-C;
4-195 . A = B/C;
4-196 .
4-197 . if (A == B)
4-198 . {
4-199 . A = B + C;
4-200 . D = E + F;
4-201 . }
4-202 .
4-203 . A = B+C;
4-204 . A = B*C;
4-205 .
4-206 . if (A > = B)
4-207 . {
4-208 . A = B + C;
4-209 . D = E + F;
4-210 . }
4-211 .
4-212 .
4-213 . if (A ne B)
4-214 . {
4-215 . A = B + C;
4-216 . D = E + F;
4-217 . }
4-218 .
4-219 .
4-220 . if (A ne B)
4-221 . {
4-222 . A = B + C;
4-223 . D = E + F;
4-224 . }
4-225 .
4-226 . A = B*C;
4-227 .
4-228 . if (A > = B)
4-229 . {
4-230 . A = B + C;
4-231 . D = E + F;
4-232 . }
4-233 .
4-234 . A = B-C;
4-235 .
4-236 . if (A le B)
4-237 . {
4-238 . A = B + C;
4-239 . D = E + F;
4-240 . }
4-241 .
4-242 . A = B/C;
4-243 . A = B-C;
4-244 . A = B/C;
4-245 . A = B-C;
4-246 . A = B*C;
4-247 . A = B/C;
4-248 . A = B/C;
4-249 . A = B+C;
4-250 . A = B*C;
4-251 . /* LE SV TOC-1055 this is a ca-04.1.80 req to reject*/
4-252 . A = B/C;
4-253 .
4-254 . if (A gt B)
4-255 . {
4-256 . A = B + C;
4-257 . D = E + F;
4-258 . }
4-259 .
4-260 . A = B/C;
4-261 . A = B-C;
4-262 . // max LOC 83
4-263 .
4-264 . }
4-265 .
4 4 Result: result/source/pr-app/pr-app-CA123/ca/ca-04.c
5 5 Source: source/pr-app/pr-app-CA123/ca/ca-05.c
5-0 . /*
5-1 . ----------------------------------------------------------------------------
5-2 . --| BEGIN PROLOGUE
5-3 . --|
5-4 . --| CLASSIFICATION: UNCLASSIFIED
5-5 . --|
5-6 . --| FILE NAME: ca-05.c
5-7 . --|
5-8 . --| ABSTRACT:
5-9 . --| This file contains the 8 functions that do file ca stuff.
5-10 . --|
5-11 . --| HISTORY:
5-12 . --| CCCQ_NAME:
5-13 . --| CCCQ_VER:
5-14 . --|
5-15 . --| END PROLOGUE
5-16 . ----------------------------------------------------------------------------
5-17 . */
5-18 .
5-19 . #define D;
5-20 . #define D;
5-21 . #include C;
5-22 . #include A;
5-23 . int A;
5-24 . #include A;
5-25 . #include D;
5-26 . float B;
5-27 . #define D;
5-28 .
5-29 .
5-30 .
5-31 . /*
5-32 . -----------------------------------------------------------------------------
5-33 . --| NAME: ca.5.1
5-34 . --|
5-35 . --| ABSTRACT:
5-36 . --| This function does ca stuff.
5-37 . --|
5-38 . --| RETURNS:
5-39 . --| NONE.
5-40 . --|
5-41 . ----------------------------------------------------------------------------
5-42 . */
5-43 . static void ca.5.1(void)
5-44 . {
5-45 .
5-46 . if (A eq B)
5-47 . {
5-48 . A = B + C;
5-49 . D = E + F;
5-50 . }
5-51 .
5-52 .
5-53 . if (A ge B)
5-54 . {
5-55 . A = B + C;
5-56 . D = E + F;
5-57 . }
5-58 .
5-59 .
5-60 . if (A != B)
5-61 . {
5-62 . A = B + C;
5-63 . D = E + F;
5-64 . }
5-65 .
5-66 . A = B/C;
5-67 .
5-68 . if (A > = B)
5-69 . {
5-70 . A = B + C;
5-71 . D = E + F;
5-72 . }
5-73 .
5-74 . A = B-C;
5-75 . A = B*C;
5-76 . A = B+C;
5-77 .
5-78 . if (A < B)
5-79 . {
5-80 . A = B + C;
5-81 . D = E + F;
5-82 . }
5-83 .
5-84 . A = B*C;
5-85 . A = B+C;
5-86 . A = B-C;
5-87 . A = B+C;
5-88 .
5-89 . if (A > B)
5-90 . {
5-91 . A = B + C;
5-92 . D = E + F;
5-93 . }
5-94 .
5-95 .
5-96 . if (A == B)
5-97 . {
5-98 . A = B + C;
5-99 . D = E + F;
5-100 . }
5-101 .
5-102 .
5-103 . if (A ne B)
5-104 . {
5-105 . A = B + C;
5-106 . D = E + F;
5-107 . }
5-108 .
5-109 . /* LE SV TOC-1056 this is a ca-05.1.17 req to increment*/
5-110 . A = B-C;
5-111 . A = B/C;
5-112 . A = B+C;
5-113 . A = 0x0008;
5-114 . A = B*C;
5-115 . A = B+C;
5-116 .
5-117 . if (A eq B)
5-118 . {
5-119 . A = B + C;
5-120 . D = E + F;
5-121 . }
5-122 .
5-123 . A = B-C;
5-124 . A = B-C;
5-125 . A = B+C;
5-126 .
5-127 . switch (ca stuff)
5-128 . {
5-129 . case one:
5-130 . {
5-131 . run_this;
5-132 . break;
5-133 . }
5-134 . case two:
5-135 . {
5-136 . run_this;
5-137 . break;
5-138 . }
5-139 . default:
5-140 . {
5-141 . SwError;
5-142 . }
5-143 . }
5-144 .
5-145 . // max LOC 26
5-146 .
5-147 . }
5-148 .
5-149 .
5-150 . /*
5-151 . -----------------------------------------------------------------------------
5-152 . --| NAME: ca.5.2
5-153 . --|
5-154 . --| ABSTRACT:
5-155 . --| This function does ca stuff.
5-156 . --|
5-157 . --| RETURNS:
5-158 . --| NONE.
5-159 . --|
5-160 . ----------------------------------------------------------------------------
5-161 . */
5-162 . static void ca.5.2(void)
5-163 . {
5-164 . A = B*C;
5-165 . A = B-C;
5-166 . A = B*C;
5-167 .
5-168 . if (A lt B)
5-169 . {
5-170 . A = B + C;
5-171 . D = E + F;
5-172 . }
5-173 .
5-174 .
5-175 . if (A ge B)
5-176 . {
5-177 . A = B + C;
5-178 . D = E + F;
5-179 . }
5-180 .
5-181 . A = B-C;
5-182 .
5-183 . if (A > = B)
5-184 . {
5-185 . A = B + C;
5-186 . D = E + F;
5-187 . }
5-188 .
5-189 .
5-190 . if (A gt B)
5-191 . {
5-192 . A = B + C;
5-193 . D = E + F;
5-194 . }
5-195 .
5-196 . A = B+C;
5-197 . /* LE SV TOC-1057 this is a ca-05.2.10 req to disable*/
5-198 . A = B+C;
5-199 . A = B+C;
5-200 . A = B+C;
5-201 .
5-202 . if (A eq B)
5-203 . {
5-204 . A = B + C;
5-205 . D = E + F;
5-206 . }
5-207 .
5-208 . /* LE SV TOC-1058 this is a ca-05.2.14 req to set RTC*/
5-209 .
5-210 . if (A < = B)
5-211 . {
5-212 . A = B + C;
5-213 . D = E + F;
5-214 . }
5-215 .
5-216 .
5-217 . if (A ge B)
5-218 . {
5-219 . A = B + C;
5-220 . D = E + F;
5-221 . }
5-222 .
5-223 .
5-224 . if (A < B)
5-225 . {
5-226 . A = B + C;
5-227 . D = E + F;
5-228 . }
5-229 .
5-230 . A = B-C;
5-231 . A = B*C;
5-232 . A = B+C;
5-233 .
5-234 . if (A < B)
5-235 . {
5-236 . A = B + C;
5-237 . D = E + F;
5-238 . }
5-239 .
5-240 .
5-241 . if (A < B)
5-242 . {
5-243 . A = B + C;
5-244 . D = E + F;
5-245 . }
5-246 .
5-247 . A = B+C;
5-248 . A = B+C;
5-249 . /* LE SV TOC-1059 this is a ca-05.2.24 req to verify*/
5-250 . A = B*C;
5-251 . A = B-C;
5-252 . /* LE SV TOC-1060 this is a ca-05.2.26 req to transform*/
5-253 . A = B/C;
5-254 . A = B+C;
5-255 . A = B*C;
5-256 . A = B*C;
5-257 . // max LOC 29
5-258 .
5-259 . }
5-260 .
5-261 .
5-262 . /*
5-263 . -----------------------------------------------------------------------------
5-264 . --| NAME: ca.5.3
5-265 . --|
5-266 . --| ABSTRACT:
5-267 . --| This function does ca stuff.
5-268 . --|
5-269 . --| RETURNS:
5-270 . --| NONE.
5-271 . --|
5-272 . ----------------------------------------------------------------------------
5-273 . */
5-274 . static void ca.5.3(void)
5-275 . {
5-276 .
5-277 . if (A lt B)
5-278 . {
5-279 . A = B + C;
5-280 . D = E + F;
5-281 . }
5-282 .
5-283 . A = B+C;
5-284 .
5-285 . if (A > B)
5-286 . {
5-287 . A = B + C;
5-288 . D = E + F;
5-289 . }
5-290 .
5-291 . A = B/C;
5-292 . A = B-C;
5-293 . A = B+C;
5-294 .
5-295 . if (A gt B)
5-296 . {
5-297 . A = B + C;
5-298 . D = E + F;
5-299 . }
5-300 .
5-301 . /* LE SV TOC-1061 this is a ca-05.3.8 req to store*/
5-302 . A = B-C;
5-303 .
5-304 . if (A == B)
5-305 . {
5-306 . A = B + C;
5-307 . D = E + F;
5-308 . }
5-309 .
5-310 . A = B+C;
5-311 . A = B*C;
5-312 . A = B+C;
5-313 .
5-314 . switch (ca stuff)
5-315 . {
5-316 . case one:
5-317 . {
5-318 . run_this;
5-319 . break;
5-320 . }
5-321 . case two:
5-322 . {
5-323 . run_this;
5-324 . break;
5-325 . }
5-326 . default:
5-327 . {
5-328 . SwError;
5-329 . }
5-330 . }
5-331 .
5-332 . A = B-C;
5-333 . A = B/C;
5-334 . A = B-C;
5-335 . A = B*C;
5-336 .
5-337 . if (A ge B)
5-338 . {
5-339 . A = B + C;
5-340 . D = E + F;
5-341 . }
5-342 .
5-343 . A = B+C;
5-344 .
5-345 . if (A ne B)
5-346 . {
5-347 . A = B + C;
5-348 . D = E + F;
5-349 . }
5-350 .
5-351 .
5-352 . switch (ca stuff)
5-353 . {
5-354 . case one:
5-355 . {
5-356 . run_this;
5-357 . break;
5-358 . }
5-359 . case two:
5-360 . {
5-361 . run_this;
5-362 . break;
5-363 . }
5-364 . default:
5-365 . {
5-366 . SwError;
5-367 . }
5-368 . }
5-369 .
5-370 . A = B-C;
5-371 .
5-372 . if (A > B)
5-373 . {
5-374 . A = B + C;
5-375 . D = E + F;
5-376 . }
5-377 .
5-378 .
5-379 . if (A < = B)
5-380 . {
5-381 . A = B + C;
5-382 . D = E + F;
5-383 . }
5-384 .
5-385 . A = B-C;
5-386 . A = B+C;
5-387 .
5-388 . if (A > B)
5-389 . {
5-390 . A = B + C;
5-391 . D = E + F;
5-392 . }
5-393 .
5-394 . A = B/C;
5-395 . A = B*C;
5-396 .
5-397 . if (A lt B)
5-398 . {
5-399 . A = B + C;
5-400 . D = E + F;
5-401 . }
5-402 .
5-403 .
5-404 . if (A < = B)
5-405 . {
5-406 . A = B + C;
5-407 . D = E + F;
5-408 . }
5-409 .
5-410 . A = B*C;
5-411 .
5-412 . if (A le B)
5-413 . {
5-414 . A = B + C;
5-415 . D = E + F;
5-416 . }
5-417 .
5-418 . A = B-C;
5-419 . A = B-C;
5-420 . A = 0x0004;
5-421 .
5-422 . if (A eq B)
5-423 . {
5-424 . A = B + C;
5-425 . D = E + F;
5-426 . }
5-427 .
5-428 .
5-429 . if (A le B)
5-430 . {
5-431 . A = B + C;
5-432 . D = E + F;
5-433 . }
5-434 .
5-435 . A = (long)B + C;
5-436 .
5-437 . if (A != B)
5-438 . {
5-439 . A = B + C;
5-440 . D = E + F;
5-441 . }
5-442 .
5-443 . A = B+C;
5-444 .
5-445 . if (A eq B)
5-446 . {
5-447 . A = B + C;
5-448 . D = E + F;
5-449 . }
5-450 .
5-451 . A = B/C;
5-452 . A = B+C;
5-453 .
5-454 . switch (ca stuff)
5-455 . {
5-456 . case one:
5-457 . {
5-458 . run_this;
5-459 . break;
5-460 . }
5-461 . case two:
5-462 . {
5-463 . run_this;
5-464 . break;
5-465 . }
5-466 . default:
5-467 . {
5-468 . SwError;
5-469 . }
5-470 . }
5-471 .
5-472 . A = B-C;
5-473 . A = B/C;
5-474 . A = B-C;
5-475 . A = B-C;
5-476 . A = B/C;
5-477 . A = B*C;
5-478 . A = B*C;
5-479 .
5-480 . if (A < B)
5-481 . {
5-482 . A = B + C;
5-483 . D = E + F;
5-484 . }
5-485 .
5-486 .
5-487 . if (A le B)
5-488 . {
5-489 . A = B + C;
5-490 . D = E + F;
5-491 . }
5-492 .
5-493 .
5-494 . if (A != B)
5-495 . {
5-496 . A = B + C;
5-497 . D = E + F;
5-498 . }
5-499 .
5-500 . // max LOC 53
5-501 .
5-502 . }
5-503 .
5-504 .
5-505 . /*
5-506 . -----------------------------------------------------------------------------
5-507 . --| NAME: ca.5.4
5-508 . --|
5-509 . --| ABSTRACT:
5-510 . --| This function does ca stuff.
5-511 . --|
5-512 . --| RETURNS:
5-513 . --| NONE.
5-514 . --|
5-515 . ----------------------------------------------------------------------------
5-516 . */
5-517 . static void ca.5.4(void)
5-518 . {
5-519 . A = B-C;
5-520 . do forever;
5-521 . A = B+C;
5-522 . A = B-C;
5-523 . A = B*C;
5-524 .
5-525 . if (A != B)
5-526 . {
5-527 . A = B + C;
5-528 . D = E + F;
5-529 . }
5-530 .
5-531 . A = B+C;
5-532 .
5-533 . #ifdef LAZY
5-534 . // this is not nice
5-535 . A = B + C;
5-536 . A = B + C;
5-537 . #endif
5-538 .
5-539 .
5-540 . if (A == B)
5-541 . {
5-542 . A = B + C;
5-543 . D = E + F;
5-544 . }
5-545 .
5-546 .
5-547 . switch (ca stuff)
5-548 . {
5-549 . case one:
5-550 . {
5-551 . run_this;
5-552 . break;
5-553 . }
5-554 . case two:
5-555 . {
5-556 . run_this;
5-557 . break;
5-558 . }
5-559 . default:
5-560 . {
5-561 . SwError;
5-562 . }
5-563 . }
5-564 .
5-565 . A = B-C;
5-566 .
5-567 . if (A < = B)
5-568 . {
5-569 . A = B + C;
5-570 . D = E + F;
5-571 . }
5-572 .
5-573 . /* LE SV TOC-1062 this is a ca-05.4.11 req to disable*/
5-574 . A = B*C;
5-575 .
5-576 . if (A gt B)
5-577 . {
5-578 . A = B + C;
5-579 . D = E + F;
5-580 . }
5-581 .
5-582 . A = B-C;
5-583 .
5-584 . if (A != B)
5-585 . {
5-586 . A = B + C;
5-587 . D = E + F;
5-588 . }
5-589 .
5-590 . A = B-C;
5-591 . A = B*C;
5-592 . A = B*C;
5-593 . A = 0x0006;
5-594 . A = B-C;
5-595 . A = B*C;
5-596 . A = B+C;
5-597 .
5-598 . if (A == B)
5-599 . {
5-600 . A = B + C;
5-601 . D = E + F;
5-602 . }
5-603 .
5-604 . A = B*C;
5-605 . A = B/C;
5-606 . A = B+C;
5-607 . A = B*C;
5-608 . /* LE SV TOC-1063 this is a ca-05.4.26 req to record*/
5-609 . A = B+C;
5-610 . A = B-C;
5-611 .
5-612 . switch (ca stuff)
5-613 . {
5-614 . case one:
5-615 . {
5-616 . run_this;
5-617 . break;
5-618 . }
5-619 . case two:
5-620 . {
5-621 . run_this;
5-622 . break;
5-623 . }
5-624 . default:
5-625 . {
5-626 . SwError;
5-627 . }
5-628 . }
5-629 .
5-630 . A = B*C;
5-631 .
5-632 . if (A eq B)
5-633 . {
5-634 . A = B + C;
5-635 . D = E + F;
5-636 . }
5-637 .
5-638 . A = B-C;
5-639 . A = B*C;
5-640 .
5-641 . if (A < B)
5-642 . {
5-643 . A = B + C;
5-644 . D = E + F;
5-645 . }
5-646 .
5-647 . A = B/C;
5-648 .
5-649 . if (A ge B)
5-650 . {
5-651 . A = B + C;
5-652 . D = E + F;
5-653 . }
5-654 .
5-655 . /* LE SV TOC-1064 this is a ca-05.4.36 req to increment*/
5-656 .
5-657 . if (A le B)
5-658 . {
5-659 . A = B + C;
5-660 . D = E + F;
5-661 . }
5-662 .
5-663 .
5-664 . if (A ne B)
5-665 . {
5-666 . A = B + C;
5-667 . D = E + F;
5-668 . }
5-669 .
5-670 . A = B/C;
5-671 . A = B+C;
5-672 .
5-673 . if (A gt B)
5-674 . {
5-675 . A = B + C;
5-676 . D = E + F;
5-677 . }
5-678 .
5-679 . A = B/C;
5-680 . A = B*C;
5-681 . /* LE SV TOC-1065 this is a ca-05.4.43 req to enable*/
5-682 . A = B/C;
5-683 .
5-684 . if (A < = B)
5-685 . {
5-686 . A = B + C;
5-687 . D = E + F;
5-688 . }
5-689 .
5-690 . A = B-C;
5-691 . A = B-C;
5-692 . A = B/C;
5-693 .
5-694 . if (A eq B)
5-695 . {
5-696 . A = B + C;
5-697 . D = E + F;
5-698 . }
5-699 .
5-700 . A = B*C;
5-701 . // ??? go see ws
5-702 . A = B-C;
5-703 . A = B*C;
5-704 . A = B+C;
5-705 . A = B*C;
5-706 . A = B/C;
5-707 .
5-708 . if (A != B)
5-709 . {
5-710 . A = B + C;
5-711 . D = E + F;
5-712 . }
5-713 .
5-714 .
5-715 . if (A ne B)
5-716 . {
5-717 . A = B + C;
5-718 . D = E + F;
5-719 . }
5-720 .
5-721 . A = B*C;
5-722 . A = B-C;
5-723 .
5-724 . if (A eq B)
5-725 . {
5-726 . A = B + C;
5-727 . D = E + F;
5-728 . }
5-729 .
5-730 . A = B+C;
5-731 . A = B/C;
5-732 . A = B/C;
5-733 . // max LOC 62
5-734 .
5-735 . }
5-736 .
5-737 .
5-738 . /*
5-739 . -----------------------------------------------------------------------------
5-740 . --| NAME: ca.5.5
5-741 . --|
5-742 . --| ABSTRACT:
5-743 . --| This function does ca stuff.
5-744 . --|
5-745 . --| RETURNS:
5-746 . --| NONE.
5-747 . --|
5-748 . ----------------------------------------------------------------------------
5-749 . */
5-750 . static void ca.5.5(void)
5-751 . {
5-752 . A = B/C;
5-753 .
5-754 . if (A ne B)
5-755 . {
5-756 . A = B + C;
5-757 . D = E + F;
5-758 . }
5-759 .
5-760 .
5-761 . if (A ge B)
5-762 . {
5-763 . A = B + C;
5-764 . D = E + F;
5-765 . }
5-766 .
5-767 . A = B*C;
5-768 .
5-769 . if (A eq B)
5-770 . {
5-771 . A = B + C;
5-772 . D = E + F;
5-773 . }
5-774 .
5-775 .
5-776 . if (A > B)
5-777 . {
5-778 . A = B + C;
5-779 . D = E + F;
5-780 . }
5-781 .
5-782 . A = B/C;
5-783 . A = B/C;
5-784 .
5-785 . switch (ca stuff)
5-786 . {
5-787 . case one:
5-788 . {
5-789 . run_this;
5-790 . break;
5-791 . }
5-792 . case two:
5-793 . {
5-794 . run_this;
5-795 . break;
5-796 . }
5-797 . default:
5-798 . {
5-799 . SwError;
5-800 . }
5-801 . }
5-802 .
5-803 . A = B*C;
5-804 . A = B-C;
5-805 .
5-806 . if (A > B)
5-807 . {
5-808 . A = B + C;
5-809 . D = E + F;
5-810 . }
5-811 .
5-812 .
5-813 . if (A < B)
5-814 . {
5-815 . A = B + C;
5-816 . D = E + F;
5-817 . }
5-818 .
5-819 . /* LE SV TOC-1066 this is a ca-05.5.14 req to update*/
5-820 . A = B+C;
5-821 . A = B/C;
5-822 .
5-823 . if (A eq B)
5-824 . {
5-825 . A = B + C;
5-826 . D = E + F;
5-827 . }
5-828 .
5-829 . A = B*C;
5-830 .
5-831 . if (A gt B)
5-832 . {
5-833 . A = B + C;
5-834 . D = E + F;
5-835 . }
5-836 .
5-837 . /* LE SV TOC-1067 this is a ca-05.5.19 req to set Real Time Clock*/
5-838 . A = B-C;
5-839 . A = B+C;
5-840 . A = B-C;
5-841 . // max LOC 21
5-842 .
5-843 . }
5-844 .
5-845 .
5-846 . /*
5-847 . -----------------------------------------------------------------------------
5-848 . --| NAME: ca.5.6
5-849 . --|
5-850 . --| ABSTRACT:
5-851 . --| This function does ca stuff.
5-852 . --|
5-853 . --| RETURNS:
5-854 . --| NONE.
5-855 . --|
5-856 . ----------------------------------------------------------------------------
5-857 . */
5-858 . static void ca.5.6(void)
5-859 . {
5-860 . A = B+C;
5-861 . A = B/C;
5-862 . A = B/C;
5-863 .
5-864 . if (A > B)
5-865 . {
5-866 . A = B + C;
5-867 . D = E + F;
5-868 . }
5-869 .
5-870 . A = B*C;
5-871 . A = B+C;
5-872 . A = B*C;
5-873 . A = B*C;
5-874 .
5-875 . if (A gt B)
5-876 . {
5-877 . A = B + C;
5-878 . D = E + F;
5-879 . }
5-880 .
5-881 . A = B/C;
5-882 . A = B+C;
5-883 . goto error;
5-884 . A = B+C;
5-885 .
5-886 . if (A < B)
5-887 . {
5-888 . A = B + C;
5-889 . D = E + F;
5-890 . }
5-891 .
5-892 . do forever;
5-893 . A = B-C;
5-894 . A = B+C;
5-895 . A = B*C;
5-896 . A = B/C;
5-897 . A = B-C;
5-898 . A = B*C;
5-899 .
5-900 . /*
5-901 . dead_code = B - C;
5-902 . dead_code = D - E;
5-903 . dead_code = F - G;
5-904 . */
5-905 .
5-906 . A = B+C;
5-907 .
5-908 . if (A != B)
5-909 . {
5-910 . A = B + C;
5-911 . D = E + F;
5-912 . }
5-913 .
5-914 . A = B-C;
5-915 . A = B/C;
5-916 . A = B*C;
5-917 . A = B/C;
5-918 .
5-919 . if (A < B)
5-920 . {
5-921 . A = B + C;
5-922 . D = E + F;
5-923 . }
5-924 .
5-925 .
5-926 . if (A < = B)
5-927 . {
5-928 . A = B + C;
5-929 . D = E + F;
5-930 . }
5-931 .
5-932 .
5-933 . if (A gt B)
5-934 . {
5-935 . A = B + C;
5-936 . D = E + F;
5-937 . }
5-938 .
5-939 .
5-940 . if (A gt B)
5-941 . {
5-942 . A = B + C;
5-943 . D = E + F;
5-944 . }
5-945 .
5-946 . A = B+C;
5-947 . A = B+C;
5-948 . A = B*C;
5-949 . A = B-C;
5-950 .
5-951 . if (A ge B)
5-952 . {
5-953 . A = B + C;
5-954 . D = E + F;
5-955 . }
5-956 .
5-957 . A = B*C;
5-958 . A = B/C;
5-959 . A = B/C;
5-960 . A = B/C;
5-961 . A = 0x0004;
5-962 . A = B/C;
5-963 . A = B-C;
5-964 . // ??? go see ws
5-965 .
5-966 . if (A < = B)
5-967 . {
5-968 . A = B + C;
5-969 . D = E + F;
5-970 . }
5-971 .
5-972 . A = B+C;
5-973 . A = B-C;
5-974 .
5-975 . if (A < = B)
5-976 . {
5-977 . A = B + C;
5-978 . D = E + F;
5-979 . }
5-980 .
5-981 . A = B+C;
5-982 .
5-983 . if (A == B)
5-984 . {
5-985 . A = B + C;
5-986 . D = E + F;
5-987 . }
5-988 .
5-989 .
5-990 . switch (ca stuff)
5-991 . {
5-992 . case one:
5-993 . {
5-994 . run_this;
5-995 . break;
5-996 . }
5-997 . case two:
5-998 . {
5-999 . run_this;
5-1000 . break;
5-1001 . }
5-1002 . default:
5-1003 . {
5-1004 . SwError;
5-1005 . }
5-1006 . }
5-1007 .
5-1008 . A = B*C;
5-1009 . A = B-C;
5-1010 . A = B/C;
5-1011 .
5-1012 . switch (ca stuff)
5-1013 . {
5-1014 . case one:
5-1015 . {
5-1016 . run_this;
5-1017 . break;
5-1018 . }
5-1019 . case two:
5-1020 . {
5-1021 . run_this;
5-1022 . break;
5-1023 . }
5-1024 . default:
5-1025 . {
5-1026 . SwError;
5-1027 . }
5-1028 . }
5-1029 .
5-1030 . A = B-C;
5-1031 . A = B-C;
5-1032 . A = B*C;
5-1033 .
5-1034 . switch (ca stuff)
5-1035 . {
5-1036 . case one:
5-1037 . {
5-1038 . run_this;
5-1039 . break;
5-1040 . }
5-1041 . case two:
5-1042 . {
5-1043 . run_this;
5-1044 . break;
5-1045 . }
5-1046 . default:
5-1047 . {
5-1048 . SwError;
5-1049 . }
5-1050 . }
5-1051 .
5-1052 . A = B-C;
5-1053 . // TBD - what do I do now
5-1054 . A = B-C;
5-1055 .
5-1056 . if (A gt B)
5-1057 . {
5-1058 . A = B + C;
5-1059 . D = E + F;
5-1060 . }
5-1061 .
5-1062 . A = B-C;
5-1063 . A = B-C;
5-1064 . // max LOC 60
5-1065 .
5-1066 . }
5-1067 .
5-1068 .
5-1069 . /*
5-1070 . -----------------------------------------------------------------------------
5-1071 . --| NAME: ca.5.7
5-1072 . --|
5-1073 . --| ABSTRACT:
5-1074 . --| This function does ca stuff.
5-1075 . --|
5-1076 . --| RETURNS:
5-1077 . --| NONE.
5-1078 . --|
5-1079 . ----------------------------------------------------------------------------
5-1080 . */
5-1081 . static void ca.5.7(void)
5-1082 . {
5-1083 . A = B/C;
5-1084 . A = B*C;
5-1085 .
5-1086 . if (A == B)
5-1087 . {
5-1088 . A = B + C;
5-1089 . D = E + F;
5-1090 . }
5-1091 .
5-1092 . A = B*C;
5-1093 . A = B/C;
5-1094 . A = B/C;
5-1095 . A = B+C;
5-1096 . A = B-C;
5-1097 . A = B*C;
5-1098 . send_buffer = (U16 *) malloc(size+1);
5-1099 . A = B-C;
5-1100 . A = B*C;
5-1101 .
5-1102 . if (A == B)
5-1103 . {
5-1104 . A = B + C;
5-1105 . D = E + F;
5-1106 . }
5-1107 .
5-1108 . A = B-C;
5-1109 . A = 0x0006;
5-1110 .
5-1111 . if (A le B)
5-1112 . {
5-1113 . A = B + C;
5-1114 . D = E + F;
5-1115 . }
5-1116 .
5-1117 .
5-1118 . if (A gt B)
5-1119 . {
5-1120 . A = B + C;
5-1121 . D = E + F;
5-1122 . }
5-1123 .
5-1124 . A = B-C;
5-1125 . A = B/C;
5-1126 . A = B-C;
5-1127 . A = B*C;
5-1128 .
5-1129 . if (A < B)
5-1130 . {
5-1131 . A = B + C;
5-1132 . D = E + F;
5-1133 . }
5-1134 .
5-1135 . A = B-C;
5-1136 . A = B*C;
5-1137 . A = B-C;
5-1138 . A = 0x0009;
5-1139 . A = B+C;
5-1140 . A = B*C;
5-1141 . A = B+C;
5-1142 . A = B+C;
5-1143 . A = B+C;
5-1144 . A = B-C;
5-1145 . A = B/C;
5-1146 . A = B*C;
5-1147 . A = B*C;
5-1148 . A = B+C;
5-1149 . A = B/C;
5-1150 . A = B-C;
5-1151 . A = B*C;
5-1152 . // (P) this is really improtant
5-1153 . A = B*C;
5-1154 . A = B+C;
5-1155 . A = B*C;
5-1156 . A = B*C;
5-1157 .
5-1158 . if ($ca stuff > $otherca stuff)
5-1159 . /* LE SV TOC-008 we really should log all error calls */
5-1160 . {
5-1161 . A = B + C;
5-1162 . }
5-1163 .
5-1164 . A = B/C;
5-1165 . A = B*C;
5-1166 . A = B*C;
5-1167 . A = B/C;
5-1168 . A = B*C;
5-1169 . A = B-C;
5-1170 .
5-1171 . if (A < = B)
5-1172 . {
5-1173 . A = B + C;
5-1174 . D = E + F;
5-1175 . }
5-1176 .
5-1177 . A = B-C;
5-1178 . // max LOC 48
5-1179 .
5-1180 . }
5-1181 .
5-1182 .
5-1183 . /*
5-1184 . -----------------------------------------------------------------------------
5-1185 . --| NAME: ca.5.8
5-1186 . --|
5-1187 . --| ABSTRACT:
5-1188 . --| This function does ca stuff.
5-1189 . --|
5-1190 . --| RETURNS:
5-1191 . --| NONE.
5-1192 . --|
5-1193 . ----------------------------------------------------------------------------
5-1194 . */
5-1195 . static void ca.5.8(void)
5-1196 . {
5-1197 . A = B/C;
5-1198 . A = B/C;
5-1199 . A = B/C;
5-1200 . A = B/C;
5-1201 . A = B/C;
5-1202 .
5-1203 . if (A < B)
5-1204 . {
5-1205 . A = B + C;
5-1206 . D = E + F;
5-1207 . }
5-1208 .
5-1209 . A = B*C;
5-1210 . A = B*C;
5-1211 . A = B/C;
5-1212 . A = B/C;
5-1213 .
5-1214 . switch (ca stuff)
5-1215 . {
5-1216 . case one:
5-1217 . {
5-1218 . run_this;
5-1219 . break;
5-1220 . }
5-1221 . case two:
5-1222 . {
5-1223 . run_this;
5-1224 . break;
5-1225 . }
5-1226 . default:
5-1227 . {
5-1228 . SwError;
5-1229 . }
5-1230 . }
5-1231 .
5-1232 . A = B+C;
5-1233 . /* LE SV TOC-1068 this is a ca-05.8.13 req to translate*/
5-1234 . A = B+C;
5-1235 . A = B+C;
5-1236 .
5-1237 . if (A < = B)
5-1238 . {
5-1239 . A = B + C;
5-1240 . D = E + F;
5-1241 . }
5-1242 .
5-1243 .
5-1244 . if (A ge B)
5-1245 . {
5-1246 . A = B + C;
5-1247 . D = E + F;
5-1248 . }
5-1249 .
5-1250 . A = B*C;
5-1251 . A = B*C;
5-1252 . A = B*C;
5-1253 .
5-1254 . if (A > B)
5-1255 . {
5-1256 . A = B + C;
5-1257 . D = E + F;
5-1258 . }
5-1259 .
5-1260 . A = (int)B + C;
5-1261 .
5-1262 . if (A > = B)
5-1263 . {
5-1264 . A = B + C;
5-1265 . D = E + F;
5-1266 . }
5-1267 .
5-1268 .
5-1269 . if (A le B)
5-1270 . {
5-1271 . A = B + C;
5-1272 . D = E + F;
5-1273 . }
5-1274 .
5-1275 . A = B*C;
5-1276 .
5-1277 . if (A > B)
5-1278 . {
5-1279 . A = B + C;
5-1280 . D = E + F;
5-1281 . }
5-1282 .
5-1283 .
5-1284 . switch (ca stuff)
5-1285 . {
5-1286 . case one:
5-1287 . {
5-1288 . switch (nested)
5-1289 . {
5-1290 . case:
5-1291 . X = Y + Z;
5-1292 . case:
5-1293 . X = Y + Z;
5-1294 . default:
5-1295 . SwError;
5-1296 . }
5-1297 . }
5-1298 . case two:
5-1299 . {
5-1300 . run_this;
5-1301 . break;
5-1302 . }
5-1303 . default:
5-1304 . {
5-1305 . SwError;
5-1306 . }
5-1307 . }
5-1308 .
5-1309 . A = B+C;
5-1310 . A = B-C;
5-1311 . A = B-C;
5-1312 .
5-1313 . if (A != B)
5-1314 . {
5-1315 . A = B + C;
5-1316 . D = E + F;
5-1317 . }
5-1318 .
5-1319 . A = B/C;
5-1320 . A = B*C;
5-1321 . /* LE SV TOC-1069 this is a ca-05.8.31 req to convert*/
5-1322 . A = B+C;
5-1323 . A = B-C;
5-1324 . A = B+C;
5-1325 . A = B+C;
5-1326 . A = B-C;
5-1327 . do forever;
5-1328 .
5-1329 . if (A != B)
5-1330 . {
5-1331 . A = B + C;
5-1332 . D = E + F;
5-1333 . }
5-1334 .
5-1335 . A = 0x0008;
5-1336 . A = B+C;
5-1337 . A = B*C;
5-1338 .
5-1339 . if (A != B)
5-1340 . {
5-1341 . A = B + C;
5-1342 . D = E + F;
5-1343 . }
5-1344 .
5-1345 .
5-1346 . if (A > B)
5-1347 . {
5-1348 . A = B + C;
5-1349 . D = E + F;
5-1350 . }
5-1351 .
5-1352 . A = B+C;
5-1353 . A = B-C;
5-1354 . A = B/C;
5-1355 . A = B*C;
5-1356 .
5-1357 . switch (ca stuff)
5-1358 . {
5-1359 . case one:
5-1360 . {
5-1361 . run_this;
5-1362 . break;
5-1363 . }
5-1364 . case two:
5-1365 . {
5-1366 . run_this;
5-1367 . break;
5-1368 . }
5-1369 . default:
5-1370 . {
5-1371 . SwError;
5-1372 . }
5-1373 . }
5-1374 .
5-1375 . A = B/C;
5-1376 . A = B/C;
5-1377 . A = B-C;
5-1378 . A = B+C;
5-1379 . A = B*C;
5-1380 .
5-1381 . if (A le B)
5-1382 . {
5-1383 . A = B + C;
5-1384 . D = E + F;
5-1385 . }
5-1386 .
5-1387 . A = B*C;
5-1388 . A = 0x0009;
5-1389 . A = B+C;
5-1390 . A = B-C;
5-1391 . A = B/C;
5-1392 . A = B+C;
5-1393 . A = B/C;
5-1394 . // max LOC 57
5-1395 .
5-1396 . }
5-1397 .
5 5 Result: result/source/pr-app/pr-app-CA123/ca/ca-05.c
6 6 Source: source/pr-app/pr-app-CA123/ca/ca-06.c
6-0 . /*
6-1 . ----------------------------------------------------------------------------
6-2 . --| BEGIN PROLOGUE
6-3 . --|
6-4 . --| CLASSIFICATION: UNCLASSIFIED
6-5 . --|
6-6 . --| FILE NAME: ca-06.c
6-7 . --|
6-8 . --| ABSTRACT:
6-9 . --| This file contains the 10 functions that do file ca stuff.
6-10 . --|
6-11 . --| HISTORY:
6-12 . --| CCCQ_NAME:
6-13 . --| CCCQ_VER:
6-14 . --|
6-15 . --| END PROLOGUE
6-16 . ----------------------------------------------------------------------------
6-17 . */
6-18 .
6-19 . #define C;
6-20 . #define C;
6-21 . char D;
6-22 .
6-23 .
6-24 .
6-25 . /*
6-26 . -----------------------------------------------------------------------------
6-27 . --| NAME: ca.6.1
6-28 . --|
6-29 . --| ABSTRACT:
6-30 . --| This function does ca stuff.
6-31 . --|
6-32 . --| RETURNS:
6-33 . --| NONE.
6-34 . --|
6-35 . ----------------------------------------------------------------------------
6-36 . */
6-37 . static void ca.6.1(void)
6-38 . {
6-39 . A = B/C;
6-40 . A = B-C;
6-41 .
6-42 . if (A ge B)
6-43 . {
6-44 . A = B + C;
6-45 . D = E + F;
6-46 . }
6-47 .
6-48 . A = B/C;
6-49 .
6-50 . if (A ge B)
6-51 . {
6-52 . A = B + C;
6-53 . D = E + F;
6-54 . }
6-55 .
6-56 .
6-57 . if (A == B)
6-58 . {
6-59 . A = B + C;
6-60 . D = E + F;
6-61 . }
6-62 .
6-63 . A = B-C;
6-64 . A = B*C;
6-65 .
6-66 . if (A != B)
6-67 . {
6-68 . A = B + C;
6-69 . D = E + F;
6-70 . }
6-71 .
6-72 . A = B-C;
6-73 . A = B+C;
6-74 . A = B-C;
6-75 .
6-76 . if (A > B)
6-77 . {
6-78 . A = B + C;
6-79 . D = E + F;
6-80 . }
6-81 .
6-82 .
6-83 . /* dead_code = B + C;
6-84 . dead_code = D + E;
6-85 . dead_code = F + G; */
6-86 .
6-87 . A = B-C;
6-88 . A = B+C;
6-89 . A = B+C;
6-90 .
6-91 . if (A < B)
6-92 . {
6-93 . A = B + C;
6-94 . D = E + F;
6-95 . }
6-96 .
6-97 . A = B-C;
6-98 . A = B-C;
6-99 .
6-100 . if (A < = B)
6-101 . {
6-102 . A = B + C;
6-103 . D = E + F;
6-104 . }
6-105 .
6-106 . A = B*C;
6-107 . A = B+C;
6-108 .
6-109 . if (A lt B)
6-110 . {
6-111 . A = B + C;
6-112 . D = E + F;
6-113 . }
6-114 .
6-115 . /* LE SV TOC-1070 this is a ca-06.1.24 req to increment*/
6-116 . A = B+C;
6-117 .
6-118 . if (A != B)
6-119 . {
6-120 . A = B + C;
6-121 . D = E + F;
6-122 . }
6-123 .
6-124 .
6-125 . if (A gt B)
6-126 . {
6-127 . A = B + C;
6-128 . D = E + F;
6-129 . }
6-130 .
6-131 . A = B/C;
6-132 . A = B/C;
6-133 . A = B-C;
6-134 . A = B+C;
6-135 . A = B/C;
6-136 . A = B+C;
6-137 .
6-138 . if (A == B)
6-139 . {
6-140 . A = B + C;
6-141 . D = E + F;
6-142 . }
6-143 .
6-144 . /* LE SV TOC-1071 this is a ca-06.1.34 req to assign*/
6-145 . A = B/C;
6-146 . A = B-C;
6-147 .
6-148 . if (A == B)
6-149 . {
6-150 . A = B + C;
6-151 . D = E + F;
6-152 . }
6-153 .
6-154 . /* LE SV TOC-1072 this is a ca-06.1.37 req to transform*/
6-155 . A = B-C;
6-156 .
6-157 . if (A > B)
6-158 . {
6-159 . A = B + C;
6-160 . D = E + F;
6-161 . }
6-162 .
6-163 . A = B+C;
6-164 .
6-165 . if (A eq B)
6-166 . {
6-167 . A = B + C;
6-168 . D = E + F;
6-169 . }
6-170 .
6-171 . A = B+C;
6-172 . A = B/C;
6-173 . A = B*C;
6-174 . A = B+C;
6-175 . /* LE SV TOC-1073 this is a ca-06.1.45 req to detect error*/
6-176 .
6-177 . if (A > = B)
6-178 . {
6-179 . A = B + C;
6-180 . D = E + F;
6-181 . }
6-182 .
6-183 . // ??? go see ws
6-184 . A = B+C;
6-185 . A = B+C;
6-186 .
6-187 . if (A ne B)
6-188 . {
6-189 . A = B + C;
6-190 . D = E + F;
6-191 . }
6-192 .
6-193 . // max LOC 48
6-194 .
6-195 . }
6-196 .
6-197 .
6-198 . /*
6-199 . -----------------------------------------------------------------------------
6-200 . --| NAME: ca.6.2
6-201 . --|
6-202 . --| ABSTRACT:
6-203 . --| This function does ca stuff.
6-204 . --|
6-205 . --| RETURNS:
6-206 . --| NONE.
6-207 . --|
6-208 . ----------------------------------------------------------------------------
6-209 . */
6-210 . static void ca.6.2(void)
6-211 . {
6-212 .
6-213 . if (A eq B)
6-214 . {
6-215 . A = B + C;
6-216 . D = E + F;
6-217 . }
6-218 .
6-219 .
6-220 . if (A > B)
6-221 . {
6-222 . A = B + C;
6-223 . D = E + F;
6-224 . }
6-225 .
6-226 .
6-227 . if (A le B)
6-228 . {
6-229 . A = B + C;
6-230 . D = E + F;
6-231 . }
6-232 .
6-233 . A = B+C;
6-234 . A = B-C;
6-235 . A = B*C;
6-236 .
6-237 . if (A eq B)
6-238 . {
6-239 . A = B + C;
6-240 . D = E + F;
6-241 . }
6-242 .
6-243 .
6-244 . if (A eq B)
6-245 . {
6-246 . A = B + C;
6-247 . D = E + F;
6-248 . }
6-249 .
6-250 . A = B+C;
6-251 . A = B/C;
6-252 . A = B*C;
6-253 .
6-254 . if (A eq B)
6-255 . {
6-256 . A = B + C;
6-257 . D = E + F;
6-258 . }
6-259 .
6-260 . /* LE SV TOC-1074 this is a ca-06.2.13 req to reject*/
6-261 . goto error;
6-262 . A = B+C;
6-263 . A = B*C;
6-264 . A = B-C;
6-265 . A = B-C;
6-266 .
6-267 . if (A gt B)
6-268 . {
6-269 . A = B + C;
6-270 . D = E + F;
6-271 . }
6-272 .
6-273 . A = B*C;
6-274 . A = B*C;
6-275 .
6-276 . if (A gt B)
6-277 . {
6-278 . A = B + C;
6-279 . D = E + F;
6-280 . }
6-281 .
6-282 . A = B-C;
6-283 . A = B-C;
6-284 .
6-285 . if (A > B)
6-286 . {
6-287 . A = B + C;
6-288 . D = E + F;
6-289 . }
6-290 .
6-291 . /* LE SV TOC-1075 this is a ca-06.2.24 req to audit*/
6-292 .
6-293 . if (A le B)
6-294 . {
6-295 . A = B + C;
6-296 . D = E + F;
6-297 . }
6-298 .
6-299 . A = B-C;
6-300 . A = 0x0004;
6-301 . A = B*C;
6-302 . /* LE SV TOC-1076 this is a ca-06.2.27 req to enable*/
6-303 . A = B-C;
6-304 . A = B/C;
6-305 . A = B+C;
6-306 . A = B-C;
6-307 . free(FreePtr);
6-308 . A = B+C;
6-309 .
6-310 . if (A le B)
6-311 . {
6-312 . A = B + C;
6-313 . D = E + F;
6-314 . }
6-315 .
6-316 .
6-317 . if (A > = B)
6-318 . {
6-319 . A = B + C;
6-320 . D = E + F;
6-321 . }
6-322 .
6-323 . A = B-C;
6-324 .
6-325 . if (A > B)
6-326 . {
6-327 . A = B + C;
6-328 . D = E + F;
6-329 . }
6-330 .
6-331 .
6-332 . if (A < B)
6-333 . {
6-334 . A = B + C;
6-335 . D = E + F;
6-336 . }
6-337 .
6-338 . /* LE SV TOC-1077 this is a ca-06.2.37 req to record*/
6-339 . A = B/C;
6-340 .
6-341 . if (A lt B)
6-342 . {
6-343 . A = B + C;
6-344 . D = E + F;
6-345 . }
6-346 .
6-347 .
6-348 . if (A lt B)
6-349 . {
6-350 . A = B + C;
6-351 . D = E + F;
6-352 . }
6-353 .
6-354 . A = B+C;
6-355 .
6-356 . if (A ge B)
6-357 . {
6-358 . A = B + C;
6-359 . D = E + F;
6-360 . }
6-361 .
6-362 . A = B-C;
6-363 . A = B/C;
6-364 . A = B+C;
6-365 . A = B/C;
6-366 .
6-367 . if (A le B)
6-368 . {
6-369 . A = B + C;
6-370 . D = E + F;
6-371 . }
6-372 .
6-373 . /* LE SV TOC-1078 this is a ca-06.2.47 req to record*/
6-374 . A = B+C;
6-375 . A = B/C;
6-376 . A = B*C;
6-377 .
6-378 . if (A < = B)
6-379 . {
6-380 . A = B + C;
6-381 . D = E + F;
6-382 . }
6-383 .
6-384 .
6-385 . #ifdef LAZY
6-386 . // this is not nice
6-387 . A = B + C;
6-388 . A = B + C;
6-389 . #endif
6-390 .
6-391 .
6-392 . if (A > = B)
6-393 . {
6-394 . A = B + C;
6-395 . D = E + F;
6-396 . }
6-397 .
6-398 . A = B-C;
6-399 .
6-400 . if (A > B)
6-401 . {
6-402 . A = B + C;
6-403 . D = E + F;
6-404 . }
6-405 .
6-406 .
6-407 . if (A le B)
6-408 . {
6-409 . A = B + C;
6-410 . D = E + F;
6-411 . }
6-412 .
6-413 . A = B-C;
6-414 . /* LE SV TOC-1079 this is a ca-06.2.56 req to enable*/
6-415 .
6-416 . if (A < B)
6-417 . {
6-418 . A = B + C;
6-419 . D = E + F;
6-420 . }
6-421 .
6-422 . send_buffer = (U16 *) malloc(size+1);
6-423 . A = B-C;
6-424 . A = B/C;
6-425 . A = B/C;
6-426 . // max LOC 59
6-427 .
6-428 . }
6-429 .
6-430 .
6-431 . /*
6-432 . -----------------------------------------------------------------------------
6-433 . --| NAME: ca.6.3
6-434 . --|
6-435 . --| ABSTRACT:
6-436 . --| This function does ca stuff.
6-437 . --|
6-438 . --| RETURNS:
6-439 . --| NONE.
6-440 . --|
6-441 . ----------------------------------------------------------------------------
6-442 . */
6-443 . static void ca.6.3(void)
6-444 . {
6-445 .
6-446 . if (A < B)
6-447 . {
6-448 . A = B + C;
6-449 . D = E + F;
6-450 . }
6-451 .
6-452 . A = B-C;
6-453 . A = B*C;
6-454 . A = B+C;
6-455 . A = B/C;
6-456 .
6-457 . if (A > = B)
6-458 . {
6-459 . A = B + C;
6-460 . D = E + F;
6-461 . }
6-462 .
6-463 . A = B*C;
6-464 . A = B-C;
6-465 .
6-466 . if (A gt B)
6-467 . {
6-468 . A = B + C;
6-469 . D = E + F;
6-470 . }
6-471 .
6-472 .
6-473 . if (A lt B)
6-474 . {
6-475 . A = B + C;
6-476 . D = E + F;
6-477 . }
6-478 .
6-479 . A = B-C;
6-480 . /* LE SV TOC-1080 this is a ca-06.3.12 req to increment*/
6-481 . A = B*C;
6-482 . A = B/C;
6-483 . A = B*C;
6-484 . /* LE SV TOC-1081 this is a ca-06.3.15 req to halt*/
6-485 . A = B/C;
6-486 . A = B/C;
6-487 .
6-488 . if (A != B)
6-489 . {
6-490 . A = B + C;
6-491 . D = E + F;
6-492 . }
6-493 .
6-494 .
6-495 . if (A == B)
6-496 . {
6-497 . A = B + C;
6-498 . D = E + F;
6-499 . }
6-500 .
6-501 . A = B-C;
6-502 .
6-503 . if (A != B)
6-504 . {
6-505 . A = B + C;
6-506 . D = E + F;
6-507 . }
6-508 .
6-509 .
6-510 . if (A le B)
6-511 . {
6-512 . A = B + C;
6-513 . D = E + F;
6-514 . }
6-515 .
6-516 . A = B-C;
6-517 .
6-518 . if (A eq B)
6-519 . {
6-520 . A = B + C;
6-521 . D = E + F;
6-522 . }
6-523 .
6-524 .
6-525 . switch (ca stuff)
6-526 . {
6-527 . case one:
6-528 . {
6-529 . run_this;
6-530 . break;
6-531 . }
6-532 . case two:
6-533 . {
6-534 . run_this;
6-535 . break;
6-536 . }
6-537 . default:
6-538 . {
6-539 . SwError;
6-540 . }
6-541 . }
6-542 .
6-543 . A = B/C;
6-544 . A = B-C;
6-545 . A = B-C;
6-546 . A = B/C;
6-547 . A = B*C;
6-548 . A = B+C;
6-549 . A = B+C;
6-550 .
6-551 . if (A < B)
6-552 . {
6-553 . A = B + C;
6-554 . D = E + F;
6-555 . }
6-556 .
6-557 . A = B+C;
6-558 .
6-559 . if (A < B)
6-560 . {
6-561 . A = B + C;
6-562 . D = E + F;
6-563 . }
6-564 .
6-565 . A = B*C;
6-566 . A = B/C;
6-567 . A = B/C;
6-568 . /* LE SV TOC-1082 this is a ca-06.3.38 req to inhibit*/
6-569 .
6-570 . if (A > B)
6-571 . {
6-572 . A = B + C;
6-573 . D = E + F;
6-574 . }
6-575 .
6-576 . A = B+C;
6-577 . A = 0x0003;
6-578 . A = B/C;
6-579 .
6-580 . if (A ne B)
6-581 . {
6-582 . A = B + C;
6-583 . D = E + F;
6-584 . }
6-585 .
6-586 . A = B-C;
6-587 . A = B*C;
6-588 . A = B+C;
6-589 .
6-590 . if (A < = B)
6-591 . {
6-592 . A = B + C;
6-593 . D = E + F;
6-594 . }
6-595 .
6-596 . A = B*C;
6-597 . A = B+C;
6-598 . A = B-C;
6-599 . A = B/C;
6-600 . A = B-C;
6-601 .
6-602 . if (A lt B)
6-603 . {
6-604 . A = B + C;
6-605 . D = E + F;
6-606 . }
6-607 .
6-608 . A = B/C;
6-609 .
6-610 . switch (ca stuff)
6-611 . {
6-612 . case one:
6-613 . {
6-614 . run_this;
6-615 . break;
6-616 . }
6-617 . case two:
6-618 . {
6-619 . run_this;
6-620 . break;
6-621 . }
6-622 . default:
6-623 . {
6-624 . SwError;
6-625 . }
6-626 . }
6-627 .
6-628 .
6-629 . if (A < = B)
6-630 . {
6-631 . A = B + C;
6-632 . D = E + F;
6-633 . }
6-634 .
6-635 .
6-636 . if (A ne B)
6-637 . {
6-638 . A = B + C;
6-639 . D = E + F;
6-640 . }
6-641 .
6-642 . A = B/C;
6-643 . A = B*C;
6-644 . /* LE SV TOC-1083 this is a ca-06.3.58 req to verify*/
6-645 . A = B/C;
6-646 .
6-647 . if ($ca stuff > $otherca stuff)
6-648 . /* LE SV TOC-008 we really should log all error calls */
6-649 . {
6-650 . A = B + C;
6-651 . }
6-652 .
6-653 . A = B*C;
6-654 . A = B/C;
6-655 . A = B*C;
6-656 . A = B/C;
6-657 . A = B*C;
6-658 . A = B-C;
6-659 . A = B*C;
6-660 . /* LE SV TOC-1084 this is a ca-06.3.66 req to validate*/
6-661 . A = B+C;
6-662 .
6-663 . if (A > = B)
6-664 . {
6-665 . A = B + C;
6-666 . D = E + F;
6-667 . }
6-668 .
6-669 . A = B-C;
6-670 .
6-671 . if (A eq B)
6-672 . {
6-673 . A = B + C;
6-674 . D = E + F;
6-675 . }
6-676 .
6-677 . A = B-C;
6-678 .
6-679 . if (A eq B)
6-680 . {
6-681 . A = B + C;
6-682 . D = E + F;
6-683 . }
6-684 .
6-685 . A = B*C;
6-686 . A = B*C;
6-687 .
6-688 . if (A le B)
6-689 . {
6-690 . A = B + C;
6-691 . D = E + F;
6-692 . }
6-693 .
6-694 . A = B+C;
6-695 . A = B+C;
6-696 . A = B/C;
6-697 . A = B*C;
6-698 .
6-699 . if (A lt B)
6-700 . {
6-701 . A = B + C;
6-702 . D = E + F;
6-703 . }
6-704 .
6-705 . /* dead_code = A * B; */
6-706 . A = B+C;
6-707 .
6-708 . if (A lt B)
6-709 . {
6-710 . A = B + C;
6-711 . D = E + F;
6-712 . }
6-713 .
6-714 .
6-715 . switch (ca stuff)
6-716 . {
6-717 . case one:
6-718 . {
6-719 . run_this;
6-720 . break;
6-721 . }
6-722 . case two:
6-723 . {
6-724 . run_this;
6-725 . break;
6-726 . }
6-727 . default:
6-728 . {
6-729 . SwError;
6-730 . }
6-731 . }
6-732 .
6-733 . A = B-C;
6-734 . A = B*C;
6-735 .
6-736 . if (A eq B)
6-737 . {
6-738 . A = B + C;
6-739 . D = E + F;
6-740 . }
6-741 .
6-742 . A = B-C;
6-743 . A = B*C;
6-744 .
6-745 . if (A < B)
6-746 . {
6-747 . A = B + C;
6-748 . D = E + F;
6-749 . }
6-750 .
6-751 . /* LE SV TOC-1085 this is a ca-06.3.89 req to call admin*/
6-752 . A = B/C;
6-753 . // max LOC 89
6-754 .
6-755 . }
6-756 .
6-757 .
6-758 . /*
6-759 . -----------------------------------------------------------------------------
6-760 . --| NAME: ca.6.4
6-761 . --|
6-762 . --| ABSTRACT:
6-763 . --| This function does ca stuff.
6-764 . --|
6-765 . --| RETURNS:
6-766 . --| NONE.
6-767 . --|
6-768 . ----------------------------------------------------------------------------
6-769 . */
6-770 . static void ca.6.4(void)
6-771 . {
6-772 . A = B+C;
6-773 . A = B-C;
6-774 .
6-775 . if (A < B)
6-776 . {
6-777 . A = B + C;
6-778 . D = E + F;
6-779 . }
6-780 .
6-781 . A = B+C;
6-782 .
6-783 . switch (ca stuff)
6-784 . {
6-785 . case one:
6-786 . {
6-787 . run_this;
6-788 . break;
6-789 . }
6-790 . case two:
6-791 . {
6-792 . run_this;
6-793 . break;
6-794 . }
6-795 . default:
6-796 . {
6-797 . SwError;
6-798 . }
6-799 . }
6-800 .
6-801 . A = B/C;
6-802 . A = B-C;
6-803 . A = B*C;
6-804 .
6-805 . switch (ca stuff)
6-806 . {
6-807 . case one:
6-808 . {
6-809 . run_this;
6-810 . break;
6-811 . }
6-812 . case two:
6-813 . {
6-814 . run_this;
6-815 . break;
6-816 . }
6-817 . default:
6-818 . {
6-819 . SwError;
6-820 . }
6-821 . }
6-822 .
6-823 . A = B+C;
6-824 . A = B/C;
6-825 . A = B/C;
6-826 . /* LE SV TOC-1086 this is a ca-06.4.13 req to increment*/
6-827 . A = B+C;
6-828 . A = B+C;
6-829 . /* dead_code = A * B; */
6-830 . A = B/C;
6-831 . A = B+C;
6-832 .
6-833 . if (A eq B)
6-834 . {
6-835 . A = B + C;
6-836 . D = E + F;
6-837 . }
6-838 .
6-839 . /* LE SV TOC-1087 this is a ca-06.4.18 req to increment*/
6-840 .
6-841 . if (A != B)
6-842 . {
6-843 . A = B + C;
6-844 . D = E + F;
6-845 . }
6-846 .
6-847 .
6-848 . if (A eq B)
6-849 . {
6-850 . A = B + C;
6-851 . D = E + F;
6-852 . }
6-853 .
6-854 .
6-855 . if (A < = B)
6-856 . {
6-857 . A = B + C;
6-858 . D = E + F;
6-859 . }
6-860 .
6-861 . A = B*C;
6-862 . A = B+C;
6-863 . A = B*C;
6-864 .
6-865 . if (A lt B)
6-866 . {
6-867 . A = B + C;
6-868 . D = E + F;
6-869 . }
6-870 .
6-871 .
6-872 . #ifdef LAZY
6-873 . // this is not nice
6-874 . A = B + C;
6-875 . A = B + C;
6-876 . #endif
6-877 .
6-878 . A = B-C;
6-879 .
6-880 . if (A < = B)
6-881 . {
6-882 . A = B + C;
6-883 . D = E + F;
6-884 . }
6-885 .
6-886 .
6-887 . if (A < B)
6-888 . {
6-889 . A = B + C;
6-890 . D = E + F;
6-891 . }
6-892 .
6-893 . A = 0x0003;
6-894 .
6-895 . if (A == B)
6-896 . {
6-897 . A = B + C;
6-898 . D = E + F;
6-899 . }
6-900 .
6-901 . goto error;
6-902 .
6-903 . if (A ge B)
6-904 . {
6-905 . A = B + C;
6-906 . D = E + F;
6-907 . }
6-908 .
6-909 . A = B*C;
6-910 . // ??? go see ws
6-911 .
6-912 . if (A < B)
6-913 . {
6-914 . A = B + C;
6-915 . D = E + F;
6-916 . }
6-917 .
6-918 .
6-919 . if (A > = B)
6-920 . {
6-921 . A = B + C;
6-922 . D = E + F;
6-923 . }
6-924 .
6-925 .
6-926 . if (A < B)
6-927 . {
6-928 . A = B + C;
6-929 . D = E + F;
6-930 . }
6-931 .
6-932 . A = B+C;
6-933 . A = B/C;
6-934 . // max LOC 35
6-935 .
6-936 . }
6-937 .
6-938 .
6-939 . /*
6-940 . -----------------------------------------------------------------------------
6-941 . --| NAME: ca.6.5
6-942 . --|
6-943 . --| ABSTRACT:
6-944 . --| This function does ca stuff.
6-945 . --|
6-946 . --| RETURNS:
6-947 . --| NONE.
6-948 . --|
6-949 . ----------------------------------------------------------------------------
6-950 . */
6-951 . static void ca.6.5(void)
6-952 . {
6-953 . A = B-C;
6-954 . A = B+C;
6-955 . /* LE SV TOC-1088 this is a ca-06.5.3 req to update*/
6-956 .
6-957 . if (A < = B)
6-958 . {
6-959 . A = B + C;
6-960 . D = E + F;
6-961 . }
6-962 .
6-963 .
6-964 . switch (ca stuff)
6-965 . {
6-966 . case one:
6-967 . {
6-968 . run_this;
6-969 . // missing break
6-970 . }
6-971 . case two:
6-972 . {
6-973 . run_this;
6-974 . break;
6-975 . }
6-976 . default:
6-977 . {
6-978 . SwError;
6-979 . }
6-980 . }
6-981 .
6-982 . A = B+C;
6-983 . A = B/C;
6-984 . A = B*C;
6-985 .
6-986 . if (A < = B)
6-987 . {
6-988 . A = B + C;
6-989 . D = E + F;
6-990 . }
6-991 .
6-992 . A = B/C;
6-993 . A = B*C;
6-994 . /* LE SV TOC-1089 this is a ca-06.5.10 req to record*/
6-995 . A = B*C;
6-996 .
6-997 . if (A == B)
6-998 . {
6-999 . A = B + C;
6-1000 . D = E + F;
6-1001 . }
6-1002 .
6-1003 . A = B+C;
6-1004 . A = B-C;
6-1005 . /* LE SV TOC-1090 this is a ca-06.5.14 req to audit*/
6-1006 . A = B/C;
6-1007 . A = B*C;
6-1008 . A = B*C;
6-1009 . A = B+C;
6-1010 . A = B-C;
6-1011 . A = B/C;
6-1012 .
6-1013 . if (A lt B)
6-1014 . {
6-1015 . A = B + C;
6-1016 . D = E + F;
6-1017 . }
6-1018 .
6-1019 . A = B-C;
6-1020 . /* LE SV TOC-1091 this is a ca-06.5.22 req to compare*/
6-1021 .
6-1022 . if (A != B)
6-1023 . {
6-1024 . A = B + C;
6-1025 . D = E + F;
6-1026 . }
6-1027 .
6-1028 . A = B-C;
6-1029 . A = B+C;
6-1030 .
6-1031 . if (A lt B)
6-1032 . {
6-1033 . A = B + C;
6-1034 . D = E + F;
6-1035 . }
6-1036 .
6-1037 . // max LOC 25
6-1038 .
6-1039 . }
6-1040 .
6-1041 .
6-1042 . /*
6-1043 . -----------------------------------------------------------------------------
6-1044 . --| NAME: ca.6.6
6-1045 . --|
6-1046 . --| ABSTRACT:
6-1047 . --| This function does ca stuff.
6-1048 . --|
6-1049 . --| RETURNS:
6-1050 . --| NONE.
6-1051 . --|
6-1052 . ----------------------------------------------------------------------------
6-1053 . */
6-1054 . static void ca.6.6(void)
6-1055 . {
6-1056 . A = B/C;
6-1057 . A = B-C;
6-1058 . A = B*C;
6-1059 . A = B+C;
6-1060 .
6-1061 . if (A < B)
6-1062 . {
6-1063 . A = B + C;
6-1064 . D = E + F;
6-1065 . }
6-1066 .
6-1067 . A = B/C;
6-1068 .
6-1069 . /* dead_code = B + C;
6-1070 . dead_code = D + E;
6-1071 . dead_code = F + G; */
6-1072 .
6-1073 . A = B*C;
6-1074 . A = 0x0009;
6-1075 . A = B/C;
6-1076 . A = B*C;
6-1077 . A = B*C;
6-1078 . A = B-C;
6-1079 .
6-1080 . switch (ca stuff)
6-1081 . {
6-1082 . case one:
6-1083 . {
6-1084 . run_this;
6-1085 . break;
6-1086 . }
6-1087 . case two:
6-1088 . {
6-1089 . run_this;
6-1090 . break;
6-1091 . }
6-1092 . default:
6-1093 . {
6-1094 . SwError;
6-1095 . }
6-1096 . }
6-1097 .
6-1098 . A = B+C;
6-1099 . A = B-C;
6-1100 . A = B+C;
6-1101 . A = B/C;
6-1102 .
6-1103 . if (A == B)
6-1104 . {
6-1105 . A = B + C;
6-1106 . D = E + F;
6-1107 . }
6-1108 .
6-1109 . A = B/C;
6-1110 . A = B*C;
6-1111 . // (P) this is really improtant
6-1112 . A = B*C;
6-1113 .
6-1114 . if (A gt B)
6-1115 . {
6-1116 . A = B + C;
6-1117 . D = E + F;
6-1118 . }
6-1119 .
6-1120 . A = B-C;
6-1121 . A = B*C;
6-1122 . A = B/C;
6-1123 . A = B+C;
6-1124 .
6-1125 . if (A != B)
6-1126 . {
6-1127 . A = B + C;
6-1128 . D = E + F;
6-1129 . }
6-1130 .
6-1131 . A = B-C;
6-1132 . A = B*C;
6-1133 . A = B/C;
6-1134 . A = B*C;
6-1135 .
6-1136 . if (A == B)
6-1137 . {
6-1138 . A = B + C;
6-1139 . D = E + F;
6-1140 . }
6-1141 .
6-1142 . A = B/C;
6-1143 . // max LOC 32
6-1144 .
6-1145 . }
6-1146 .
6-1147 .
6-1148 . /*
6-1149 . -----------------------------------------------------------------------------
6-1150 . --| NAME: ca.6.7
6-1151 . --|
6-1152 . --| ABSTRACT:
6-1153 . --| This function does ca stuff.
6-1154 . --|
6-1155 . --| RETURNS:
6-1156 . --| NONE.
6-1157 . --|
6-1158 . ----------------------------------------------------------------------------
6-1159 . */
6-1160 . static void ca.6.7(void)
6-1161 . {
6-1162 . A = B-C;
6-1163 . A = B/C;
6-1164 .
6-1165 . if (A == B)
6-1166 . {
6-1167 . A = B + C;
6-1168 . D = E + F;
6-1169 . }
6-1170 .
6-1171 . A = 0x0008;
6-1172 . A = B+C;
6-1173 .
6-1174 . switch (ca stuff)
6-1175 . {
6-1176 . case one:
6-1177 . {
6-1178 . run_this;
6-1179 . break;
6-1180 . }
6-1181 . case two:
6-1182 . {
6-1183 . run_this;
6-1184 . break;
6-1185 . }
6-1186 . default:
6-1187 . {
6-1188 . SwError;
6-1189 . }
6-1190 . }
6-1191 .
6-1192 . A = B*C;
6-1193 .
6-1194 . if (A gt B)
6-1195 . {
6-1196 . A = B + C;
6-1197 . D = E + F;
6-1198 . }
6-1199 .
6-1200 .
6-1201 . if (A eq B)
6-1202 . {
6-1203 . A = B + C;
6-1204 . D = E + F;
6-1205 . }
6-1206 .
6-1207 . A = B*C;
6-1208 . A = B/C;
6-1209 .
6-1210 . if (A > B)
6-1211 . {
6-1212 . A = B + C;
6-1213 . D = E + F;
6-1214 . }
6-1215 .
6-1216 . A = B+C;
6-1217 . A = 0x0004;
6-1218 . A = B*C;
6-1219 . A = B/C;
6-1220 .
6-1221 . if (A > B)
6-1222 . {
6-1223 . A = B + C;
6-1224 . D = E + F;
6-1225 . }
6-1226 .
6-1227 .
6-1228 . if (A > = B)
6-1229 . {
6-1230 . A = B + C;
6-1231 . D = E + F;
6-1232 . }
6-1233 .
6-1234 . A = B*C;
6-1235 . A = B-C;
6-1236 . A = B+C;
6-1237 . A = B/C;
6-1238 . A = (int)B + C;
6-1239 . A = B*C;
6-1240 . A = B/C;
6-1241 . A = B*C;
6-1242 . A = B/C;
6-1243 . A = B+C;
6-1244 .
6-1245 . if (A ne B)
6-1246 . {
6-1247 . A = B + C;
6-1248 . D = E + F;
6-1249 . }
6-1250 .
6-1251 . A = B-C;
6-1252 .
6-1253 . if (A != B)
6-1254 . {
6-1255 . A = B + C;
6-1256 . D = E + F;
6-1257 . }
6-1258 .
6-1259 . A = B/C;
6-1260 . goto error;
6-1261 .
6-1262 . if (A < B)
6-1263 . {
6-1264 . A = B + C;
6-1265 . D = E + F;
6-1266 . }
6-1267 .
6-1268 . /* LE SV TOC-1092 this is a ca-06.7.31 req to halt*/
6-1269 . A = B*C;
6-1270 . A = B/C;
6-1271 .
6-1272 . if (A > = B)
6-1273 . {
6-1274 . A = B + C;
6-1275 . D = E + F;
6-1276 . }
6-1277 .
6-1278 . A = B*C;
6-1279 .
6-1280 . if (A ge B)
6-1281 . {
6-1282 . A = B + C;
6-1283 . D = E + F;
6-1284 . }
6-1285 .
6-1286 .
6-1287 . if (A == B)
6-1288 . {
6-1289 . A = B + C;
6-1290 . D = E + F;
6-1291 . }
6-1292 .
6-1293 . A = B/C;
6-1294 . A = B*C;
6-1295 . /* LE SV TOC-1093 this is a ca-06.7.39 req to detect error*/
6-1296 . A = B-C;
6-1297 .
6-1298 . if (A lt B)
6-1299 . {
6-1300 . A = B + C;
6-1301 . D = E + F;
6-1302 . }
6-1303 .
6-1304 . A = B*C;
6-1305 .
6-1306 . if (A le B)
6-1307 . {
6-1308 . A = B + C;
6-1309 . D = E + F;
6-1310 . }
6-1311 .
6-1312 .
6-1313 . if (A eq B)
6-1314 . {
6-1315 . A = B + C;
6-1316 . D = E + F;
6-1317 . }
6-1318 .
6-1319 .
6-1320 . if (A > = B)
6-1321 . {
6-1322 . A = B + C;
6-1323 . D = E + F;
6-1324 . }
6-1325 .
6-1326 .
6-1327 . if (A != B)
6-1328 . {
6-1329 . A = B + C;
6-1330 . D = E + F;
6-1331 . }
6-1332 .
6-1333 . A = B+C;
6-1334 . A = B/C;
6-1335 . A = B/C;
6-1336 .
6-1337 . if (A != B)
6-1338 . {
6-1339 . A = B + C;
6-1340 . D = E + F;
6-1341 . }
6-1342 .
6-1343 . A = B*C;
6-1344 . A = B*C;
6-1345 . /* LE SV TOC-1094 this is a ca-06.7.52 req to store*/
6-1346 . A = B*C;
6-1347 . /* LE SV TOC-1095 this is a ca-06.7.53 req to assign*/
6-1348 . A = B+C;
6-1349 . A = B/C;
6-1350 . /* LE SV TOC-1096 this is a ca-06.7.55 req to call isr*/
6-1351 . A = B*C;
6-1352 . /* LE SV TOC-1097 this is a ca-06.7.56 req to store*/
6-1353 . A = B/C;
6-1354 . A = B-C;
6-1355 . A = B/C;
6-1356 .
6-1357 . if (A < = B)
6-1358 . {
6-1359 . A = B + C;
6-1360 . D = E + F;
6-1361 . }
6-1362 .
6-1363 .
6-1364 . if (A < B)
6-1365 . {
6-1366 . A = B + C;
6-1367 . D = E + F;
6-1368 . }
6-1369 .
6-1370 .
6-1371 . if (A > = B)
6-1372 . {
6-1373 . A = B + C;
6-1374 . D = E + F;
6-1375 . }
6-1376 .
6-1377 . goto error;
6-1378 . A = B-C;
6-1379 . A = B*C;
6-1380 .
6-1381 . if (A < = B)
6-1382 . {
6-1383 . A = B + C;
6-1384 . D = E + F;
6-1385 . }
6-1386 .
6-1387 .
6-1388 . switch (ca stuff)
6-1389 . {
6-1390 . case one:
6-1391 . {
6-1392 . run_this;
6-1393 . break;
6-1394 . }
6-1395 . case two:
6-1396 . {
6-1397 . run_this;
6-1398 . break;
6-1399 . }
6-1400 . default:
6-1401 . {
6-1402 . SwError;
6-1403 . }
6-1404 . }
6-1405 .
6-1406 . A = B*C;
6-1407 . // max LOC 66
6-1408 .
6-1409 . }
6-1410 .
6-1411 .
6-1412 . /*
6-1413 . -----------------------------------------------------------------------------
6-1414 . --| NAME: ca.6.8
6-1415 . --|
6-1416 . --| ABSTRACT:
6-1417 . --| This function does ca stuff.
6-1418 . --|
6-1419 . --| RETURNS:
6-1420 . --| NONE.
6-1421 . --|
6-1422 . ----------------------------------------------------------------------------
6-1423 . */
6-1424 . static void ca.6.8(void)
6-1425 . {
6-1426 . A = B+C;
6-1427 . /* LE SV TOC-1098 this is a ca-06.8.2 req to transform*/
6-1428 . A = B/C;
6-1429 . A = B+C;
6-1430 . A = B/C;
6-1431 . A = B/C;
6-1432 .
6-1433 . if ($ca stuff > $otherca stuff)
6-1434 . /* LE SV TOC-008 we really should log all error calls */
6-1435 . {
6-1436 . A = B + C;
6-1437 . }
6-1438 .
6-1439 . A = B*C;
6-1440 . A = B-C;
6-1441 . A = B+C;
6-1442 . goto error;
6-1443 . A = B*C;
6-1444 . A = B*C;
6-1445 . A = B/C;
6-1446 . A = B-C;
6-1447 .
6-1448 . if (A gt B)
6-1449 . {
6-1450 . A = B + C;
6-1451 . D = E + F;
6-1452 . }
6-1453 .
6-1454 . A = B+C;
6-1455 .
6-1456 . if (A ne B)
6-1457 . {
6-1458 . A = B + C;
6-1459 . D = E + F;
6-1460 . }
6-1461 .
6-1462 .
6-1463 . if (A > B)
6-1464 . {
6-1465 . A = B + C;
6-1466 . D = E + F;
6-1467 . }
6-1468 .
6-1469 . A = B+C;
6-1470 . A = B-C;
6-1471 . A = B/C;
6-1472 .
6-1473 . if (A < = B)
6-1474 . {
6-1475 . A = B + C;
6-1476 . D = E + F;
6-1477 . }
6-1478 .
6-1479 . FreePtr = HmiStringPtr;
6-1480 . A = B-C;
6-1481 .
6-1482 . if (A != B)
6-1483 . {
6-1484 . A = B + C;
6-1485 . D = E + F;
6-1486 . }
6-1487 .
6-1488 . A = 0x0001;
6-1489 . A = B/C;
6-1490 . A = B+C;
6-1491 . A = B*C;
6-1492 . A = B/C;
6-1493 . A = B*C;
6-1494 .
6-1495 . if (A gt B)
6-1496 . {
6-1497 . A = B + C;
6-1498 . D = E + F;
6-1499 . }
6-1500 .
6-1501 . A = B*C;
6-1502 . A = B*C;
6-1503 . A = B/C;
6-1504 . A = B-C;
6-1505 . A = B+C;
6-1506 . A = B-C;
6-1507 . A = B*C;
6-1508 . A = B*C;
6-1509 .
6-1510 . if (A le B)
6-1511 . {
6-1512 . A = B + C;
6-1513 . D = E + F;
6-1514 . }
6-1515 .
6-1516 .
6-1517 . if (A == B)
6-1518 . {
6-1519 . A = B + C;
6-1520 . D = E + F;
6-1521 . }
6-1522 .
6-1523 . A = B*C;
6-1524 .
6-1525 . if (A > = B)
6-1526 . {
6-1527 . A = B + C;
6-1528 . D = E + F;
6-1529 . }
6-1530 .
6-1531 .
6-1532 . if (A > = B)
6-1533 . {
6-1534 . A = B + C;
6-1535 . D = E + F;
6-1536 . }
6-1537 .
6-1538 . A = B/C;
6-1539 . A = B/C;
6-1540 . A = B-C;
6-1541 .
6-1542 . if (A > = B)
6-1543 . {
6-1544 . A = B + C;
6-1545 . D = E + F;
6-1546 . }
6-1547 .
6-1548 . // TBD - what do I do now
6-1549 .
6-1550 . if (A ge B)
6-1551 . {
6-1552 . A = B + C;
6-1553 . D = E + F;
6-1554 . }
6-1555 .
6-1556 . A = B-C;
6-1557 . A = B*C;
6-1558 . A = B-C;
6-1559 . A = B+C;
6-1560 . A = B-C;
6-1561 . A = B-C;
6-1562 . A = B+C;
6-1563 . A = B/C;
6-1564 .
6-1565 . if (A gt B)
6-1566 . {
6-1567 . A = B + C;
6-1568 . D = E + F;
6-1569 . }
6-1570 .
6-1571 . A = B*C;
6-1572 . A = B-C;
6-1573 . A = B/C;
6-1574 . do forever;
6-1575 . A = B-C;
6-1576 . A = B*C;
6-1577 . /* LE SV TOC-1099 this is a ca-06.8.61 req to call isr*/
6-1578 . A = B/C;
6-1579 . /* LE SV TOC-1100 this is a ca-06.8.62 req to recover*/
6-1580 . A = B+C;
6-1581 . A = B/C;
6-1582 . A = B-C;
6-1583 .
6-1584 . if (A < = B)
6-1585 . {
6-1586 . A = B + C;
6-1587 . D = E + F;
6-1588 . }
6-1589 .
6-1590 . A = B+C;
6-1591 . A = B-C;
6-1592 .
6-1593 . switch (ca stuff)
6-1594 . {
6-1595 . case:
6-1596 . case:
6-1597 . // stacked case statements but only if there is a new line in between
6-1598 .
6-1599 . case:
6-1600 . case:
6-1601 . case:
6-1602 . {
6-1603 . run_this;
6-1604 . break;
6-1605 . }
6-1606 . default:
6-1607 . {
6-1608 . halt;
6-1609 . }
6-1610 . }
6-1611 .
6-1612 .
6-1613 . if (A > B)
6-1614 . {
6-1615 . A = B + C;
6-1616 . D = E + F;
6-1617 . }
6-1618 .
6-1619 .
6-1620 . if (A eq B)
6-1621 . {
6-1622 . A = B + C;
6-1623 . D = E + F;
6-1624 . }
6-1625 .
6-1626 . A = B-C;
6-1627 . A = B*C;
6-1628 . A = B-C;
6-1629 . A = B-C;
6-1630 .
6-1631 . if (A != B)
6-1632 . {
6-1633 . A = B + C;
6-1634 . D = E + F;
6-1635 . }
6-1636 .
6-1637 .
6-1638 . if (A eq B)
6-1639 . {
6-1640 . A = B + C;
6-1641 . D = E + F;
6-1642 . }
6-1643 .
6-1644 . A = B+C;
6-1645 . A = B*C;
6-1646 . A = B+C;
6-1647 . A = B+C;
6-1648 .
6-1649 . if (A > B)
6-1650 . {
6-1651 . A = B + C;
6-1652 . D = E + F;
6-1653 . }
6-1654 .
6-1655 . A = B*C;
6-1656 . send_buffer = (U16 *) malloc(size+1);
6-1657 . A = B+C;
6-1658 . /* LE SV TOC-1101 this is a ca-06.8.83 req to inhibit*/
6-1659 .
6-1660 . if (A == B)
6-1661 . {
6-1662 . A = B + C;
6-1663 . D = E + F;
6-1664 . }
6-1665 .
6-1666 .
6-1667 . if (A > B)
6-1668 . {
6-1669 . A = B + C;
6-1670 . D = E + F;
6-1671 . }
6-1672 .
6-1673 .
6-1674 . if (A > B)
6-1675 . {
6-1676 . A = B + C;
6-1677 . D = E + F;
6-1678 . }
6-1679 .
6-1680 . /* LE SV TOC-1102 this is a ca-06.8.86 req to convert*/
6-1681 . A = B+C;
6-1682 .
6-1683 . if (A ne B)
6-1684 . {
6-1685 . A = B + C;
6-1686 . D = E + F;
6-1687 . }
6-1688 .
6-1689 .
6-1690 . /*
6-1691 . dead_code = B - C;
6-1692 . dead_code = D - E;
6-1693 . dead_code = F - G;
6-1694 . */
6-1695 .
6-1696 . A = B/C;
6-1697 . A = B+C;
6-1698 . /* LE SV TOC-1103 this is a ca-06.8.90 req to record*/
6-1699 . A = B/C;
6-1700 .
6-1701 . if (A ne B)
6-1702 . {
6-1703 . A = B + C;
6-1704 . D = E + F;
6-1705 . }
6-1706 .
6-1707 . A = B+C;
6-1708 . A = B/C;
6-1709 .
6-1710 . if (A > = B)
6-1711 . {
6-1712 . A = B + C;
6-1713 . D = E + F;
6-1714 . }
6-1715 .
6-1716 . A = B+C;
6-1717 .
6-1718 . if (A eq B)
6-1719 . {
6-1720 . A = B + C;
6-1721 . D = E + F;
6-1722 . }
6-1723 .
6-1724 . A = B+C;
6-1725 . // max LOC 97
6-1726 .
6-1727 . }
6-1728 .
6-1729 .
6-1730 . /*
6-1731 . -----------------------------------------------------------------------------
6-1732 . --| NAME: ca.6.9
6-1733 . --|
6-1734 . --| ABSTRACT:
6-1735 . --| This function does ca stuff.
6-1736 . --|
6-1737 . --| RETURNS:
6-1738 . --| NONE.
6-1739 . --|
6-1740 . ----------------------------------------------------------------------------
6-1741 . */
6-1742 . static void ca.6.9(void)
6-1743 . {
6-1744 .
6-1745 . if ($ca stuff > $otherca stuff)
6-1746 . /* LE SV TOC-008 we really should log all error calls */
6-1747 . {
6-1748 . A = B + C;
6-1749 . }
6-1750 .
6-1751 . A = B-C;
6-1752 . A = B+C;
6-1753 .
6-1754 . if (A != B)
6-1755 . {
6-1756 . A = B + C;
6-1757 . D = E + F;
6-1758 . }
6-1759 .
6-1760 .
6-1761 . if (A != B)
6-1762 . {
6-1763 . A = B + C;
6-1764 . D = E + F;
6-1765 . }
6-1766 .
6-1767 .
6-1768 . if (A lt B)
6-1769 . {
6-1770 . A = B + C;
6-1771 . D = E + F;
6-1772 . }
6-1773 .
6-1774 . A = B*C;
6-1775 .
6-1776 . if (A > = B)
6-1777 . {
6-1778 . A = B + C;
6-1779 . D = E + F;
6-1780 . }
6-1781 .
6-1782 .
6-1783 . if (A le B)
6-1784 . {
6-1785 . A = B + C;
6-1786 . D = E + F;
6-1787 . }
6-1788 .
6-1789 .
6-1790 . if (A lt B)
6-1791 . {
6-1792 . A = B + C;
6-1793 . D = E + F;
6-1794 . }
6-1795 .
6-1796 . A = B+C;
6-1797 .
6-1798 . if (A > B)
6-1799 . {
6-1800 . A = B + C;
6-1801 . D = E + F;
6-1802 . }
6-1803 .
6-1804 .
6-1805 . if (A != B)
6-1806 . {
6-1807 . A = B + C;
6-1808 . D = E + F;
6-1809 . }
6-1810 .
6-1811 . A = B-C;
6-1812 . A = B/C;
6-1813 . A = B+C;
6-1814 . A = B/C;
6-1815 . A = B-C;
6-1816 .
6-1817 . if (A le B)
6-1818 . {
6-1819 . A = B + C;
6-1820 . D = E + F;
6-1821 . }
6-1822 .
6-1823 . A = B*C;
6-1824 .
6-1825 . if (A ne B)
6-1826 . {
6-1827 . A = B + C;
6-1828 . D = E + F;
6-1829 . }
6-1830 .
6-1831 .
6-1832 . if (A < = B)
6-1833 . {
6-1834 . A = B + C;
6-1835 . D = E + F;
6-1836 . }
6-1837 .
6-1838 . A = B/C;
6-1839 .
6-1840 . if (A lt B)
6-1841 . {
6-1842 . A = B + C;
6-1843 . D = E + F;
6-1844 . }
6-1845 .
6-1846 . /* LE SV TOC-1104 this is a ca-06.9.24 req to update*/
6-1847 . A = B+C;
6-1848 .
6-1849 . if (A < B)
6-1850 . {
6-1851 . A = B + C;
6-1852 . D = E + F;
6-1853 . }
6-1854 .
6-1855 .
6-1856 . if (A lt B)
6-1857 . {
6-1858 . A = B + C;
6-1859 . D = E + F;
6-1860 . }
6-1861 .
6-1862 .
6-1863 . if (A ne B)
6-1864 . {
6-1865 . A = B + C;
6-1866 . D = E + F;
6-1867 . }
6-1868 .
6-1869 .
6-1870 . if (A ne B)
6-1871 . {
6-1872 . A = B + C;
6-1873 . D = E + F;
6-1874 . }
6-1875 .
6-1876 . A = B/C;
6-1877 .
6-1878 . switch (ca stuff)
6-1879 . {
6-1880 . case one:
6-1881 . {
6-1882 . run_this;
6-1883 . break;
6-1884 . }
6-1885 . case two:
6-1886 . {
6-1887 . run_this;
6-1888 . break;
6-1889 . }
6-1890 . default:
6-1891 . {
6-1892 . SwError;
6-1893 . }
6-1894 . }
6-1895 .
6-1896 . A = B/C;
6-1897 . A = 0x0001;
6-1898 . A = B/C;
6-1899 . A = B-C;
6-1900 .
6-1901 . if (A lt B)
6-1902 . {
6-1903 . A = B + C;
6-1904 . D = E + F;
6-1905 . }
6-1906 .
6-1907 . A = B/C;
6-1908 . A = B/C;
6-1909 . A = B+C;
6-1910 . A = B+C;
6-1911 .
6-1912 . if (A < = B)
6-1913 . {
6-1914 . A = B + C;
6-1915 . D = E + F;
6-1916 . }
6-1917 .
6-1918 .
6-1919 . if (A > B)
6-1920 . {
6-1921 . A = B + C;
6-1922 . D = E + F;
6-1923 . }
6-1924 .
6-1925 . A = B+C;
6-1926 . A = B-C;
6-1927 .
6-1928 . if (A < B)
6-1929 . {
6-1930 . A = B + C;
6-1931 . D = E + F;
6-1932 . }
6-1933 .
6-1934 .
6-1935 . if (A > = B)
6-1936 . {
6-1937 . A = B + C;
6-1938 . D = E + F;
6-1939 . }
6-1940 .
6-1941 .
6-1942 . if (A eq B)
6-1943 . {
6-1944 . A = B + C;
6-1945 . D = E + F;
6-1946 . }
6-1947 .
6-1948 .
6-1949 . if (A < = B)
6-1950 . {
6-1951 . A = B + C;
6-1952 . D = E + F;
6-1953 . }
6-1954 .
6-1955 .
6-1956 . if (A ge B)
6-1957 . {
6-1958 . A = B + C;
6-1959 . D = E + F;
6-1960 . }
6-1961 .
6-1962 . // max LOC 47
6-1963 .
6-1964 . }
6-1965 .
6-1966 .
6-1967 . /*
6-1968 . -----------------------------------------------------------------------------
6-1969 . --| NAME: ca.6.10
6-1970 . --|
6-1971 . --| ABSTRACT:
6-1972 . --| This function does ca stuff.
6-1973 . --|
6-1974 . --| RETURNS:
6-1975 . --| NONE.
6-1976 . --|
6-1977 . ----------------------------------------------------------------------------
6-1978 . */
6-1979 . static void ca.6.10(void)
6-1980 . {
6-1981 . A = B/C;
6-1982 . A = B*C;
6-1983 . A = B-C;
6-1984 . A = B-C;
6-1985 .
6-1986 . if (A == B)
6-1987 . {
6-1988 . A = B + C;
6-1989 . D = E + F;
6-1990 . }
6-1991 .
6-1992 . A = B/C;
6-1993 .
6-1994 . /* dead_block = C * D;
6-1995 . dead_block = E * F; */
6-1996 .
6-1997 . A = B/C;
6-1998 . A = B*C;
6-1999 . /* LE SV TOC-1105 this is a ca-06.10.9 req to reject*/
6-2000 . A = (float)B + C;
6-2001 . A = B/C;
6-2002 . A = B+C;
6-2003 . A = B-C;
6-2004 . A = B/C;
6-2005 . A = B*C;
6-2006 . A = 0x0009;
6-2007 . A = B*C;
6-2008 . A = B/C;
6-2009 . A = B-C;
6-2010 .
6-2011 . if (A > = B)
6-2012 . {
6-2013 . A = B + C;
6-2014 . D = E + F;
6-2015 . }
6-2016 .
6-2017 . A = 0x0006;
6-2018 . A = B+C;
6-2019 . A = B-C;
6-2020 . A = B-C;
6-2021 . A = B+C;
6-2022 . A = B-C;
6-2023 .
6-2024 . if (A gt B)
6-2025 . {
6-2026 . A = B + C;
6-2027 . D = E + F;
6-2028 . }
6-2029 .
6-2030 . A = 0x0002;
6-2031 . A = B-C;
6-2032 . A = B*C;
6-2033 .
6-2034 . if (A == B)
6-2035 . {
6-2036 . A = B + C;
6-2037 . D = E + F;
6-2038 . }
6-2039 .
6-2040 . A = B*C;
6-2041 . A = 0x0006;
6-2042 . A = B+C;
6-2043 . A = B*C;
6-2044 . A = B+C;
6-2045 . A = B/C;
6-2046 . A = 0x0006;
6-2047 . A = B-C;
6-2048 .
6-2049 . if (A ne B)
6-2050 . {
6-2051 . A = B + C;
6-2052 . D = E + F;
6-2053 . }
6-2054 .
6-2055 .
6-2056 . if (A < B)
6-2057 . {
6-2058 . A = B + C;
6-2059 . D = E + F;
6-2060 . }
6-2061 .
6-2062 . A = B/C;
6-2063 . A = B*C;
6-2064 . A = B-C;
6-2065 . /* LE SV TOC-1106 this is a ca-06.10.38 req to check pSOS*/
6-2066 .
6-2067 . if (A < = B)
6-2068 . {
6-2069 . A = B + C;
6-2070 . D = E + F;
6-2071 . }
6-2072 .
6-2073 .
6-2074 . if (A ge B)
6-2075 . {
6-2076 . A = B + C;
6-2077 . D = E + F;
6-2078 . }
6-2079 .
6-2080 .
6-2081 . if (A le B)
6-2082 . {
6-2083 . A = B + C;
6-2084 . D = E + F;
6-2085 . }
6-2086 .
6-2087 .
6-2088 . if (A gt B)
6-2089 . {
6-2090 . A = B + C;
6-2091 . D = E + F;
6-2092 . }
6-2093 .
6-2094 . A = B/C;
6-2095 .
6-2096 . if (A lt B)
6-2097 . {
6-2098 . A = B + C;
6-2099 . D = E + F;
6-2100 . }
6-2101 .
6-2102 .
6-2103 . if (A ne B)
6-2104 . {
6-2105 . A = B + C;
6-2106 . D = E + F;
6-2107 . }
6-2108 .
6-2109 . A = B/C;
6-2110 . A = 0x0002;
6-2111 . rcv_buffer = (U16 *) alloc(size+1);
6-2112 . A = B/C;
6-2113 . A = B-C;
6-2114 .
6-2115 . switch (ca stuff)
6-2116 . {
6-2117 . case one:
6-2118 . {
6-2119 . run_this;
6-2120 . break;
6-2121 . }
6-2122 . case two:
6-2123 . {
6-2124 . run_this;
6-2125 . break;
6-2126 . }
6-2127 . default:
6-2128 . {
6-2129 . SwError;
6-2130 . }
6-2131 . }
6-2132 .
6-2133 . A = B-C;
6-2134 . A = B+C;
6-2135 .
6-2136 . switch (ca stuff)
6-2137 . {
6-2138 . case one:
6-2139 . {
6-2140 . run_this;
6-2141 . break;
6-2142 . }
6-2143 . case two:
6-2144 . {
6-2145 . run_this;
6-2146 . break;
6-2147 . }
6-2148 . default:
6-2149 . {
6-2150 . SwError;
6-2151 . }
6-2152 . }
6-2153 .
6-2154 . A = B*C;
6-2155 . A = B/C;
6-2156 . A = B*C;
6-2157 . A = B-C;
6-2158 . A = B-C;
6-2159 . /* LE SV TOC-1107 this is a ca-06.10.57 req to validate*/
6-2160 . A = B*C;
6-2161 . A = B+C;
6-2162 . A = B*C;
6-2163 . A = B/C;
6-2164 .
6-2165 . switch (ca stuff)
6-2166 . {
6-2167 . case one:
6-2168 . {
6-2169 . run_this;
6-2170 . break;
6-2171 . }
6-2172 . case two:
6-2173 . {
6-2174 . run_this;
6-2175 . break;
6-2176 . }
6-2177 . default:
6-2178 . {
6-2179 . SwError;
6-2180 . }
6-2181 . }
6-2182 .
6-2183 . A = B/C;
6-2184 .
6-2185 . if (A ne B)
6-2186 . {
6-2187 . A = B + C;
6-2188 . D = E + F;
6-2189 . }
6-2190 .
6-2191 . A = B+C;
6-2192 . A = B/C;
6-2193 . A = (long)B + C;
6-2194 .
6-2195 . switch (ca stuff)
6-2196 . {
6-2197 . case one:
6-2198 . {
6-2199 . run_this;
6-2200 . break;
6-2201 . }
6-2202 . case two:
6-2203 . {
6-2204 . run_this;
6-2205 . break;
6-2206 . }
6-2207 . default:
6-2208 . {
6-2209 . SwError;
6-2210 . }
6-2211 . }
6-2212 .
6-2213 . A = B-C;
6-2214 . A = B-C;
6-2215 . A = B+C;
6-2216 . A = B/C;
6-2217 . A = B+C;
6-2218 . A = B+C;
6-2219 . /* LE SV TOC-1108 this is a ca-06.10.73 req to assign*/
6-2220 . A = B-C;
6-2221 . A = B-C;
6-2222 . A = B*C;
6-2223 . A = B/C;
6-2224 . A = B+C;
6-2225 . A = B/C;
6-2226 . A = B*C;
6-2227 .
6-2228 . if (A ne B)
6-2229 . {
6-2230 . A = B + C;
6-2231 . D = E + F;
6-2232 . }
6-2233 .
6-2234 . A = B*C;
6-2235 .
6-2236 . if {
6-2237 . X = Y + Z;
6-2238 . }
6-2239 . else {
6-2240 . halt;
6-2241 . }
6-2242 .
6-2243 . A = B/C;
6-2244 . /* LE SV TOC-1109 this is a ca-06.10.83 req to validate*/
6-2245 .
6-2246 . if (A le B)
6-2247 . {
6-2248 . A = B + C;
6-2249 . D = E + F;
6-2250 . }
6-2251 .
6-2252 . // max LOC 83
6-2253 .
6-2254 . }
6-2255 .
6 6 Result: result/source/pr-app/pr-app-CA123/ca/ca-06.c
7 7 Source: source/pr-app/pr-app-CA123/ca/ca-07.c
7-0 . /*
7-1 . ----------------------------------------------------------------------------
7-2 . --| BEGIN PROLOGUE
7-3 . --|
7-4 . --| CLASSIFICATION: UNCLASSIFIED
7-5 . --|
7-6 . --| FILE NAME: ca-07.c
7-7 . --|
7-8 . --| ABSTRACT:
7-9 . --| This file contains the 7 functions that do file ca stuff.
7-10 . --|
7-11 . --| HISTORY:
7-12 . --| CCCQ_NAME:
7-13 . --| CCCQ_VER:
7-14 . --|
7-15 . --| END PROLOGUE
7-16 . ----------------------------------------------------------------------------
7-17 . */
7-18 .
7-19 . #include C;
7-20 . float B;
7-21 . #define A;
7-22 . float B;
7-23 . #define D;
7-24 . #define C;
7-25 .
7-26 .
7-27 .
7-28 . /*
7-29 . -----------------------------------------------------------------------------
7-30 . --| NAME: ca.7.1
7-31 . --|
7-32 . --| ABSTRACT:
7-33 . --| This function does ca stuff.
7-34 . --|
7-35 . --| RETURNS:
7-36 . --| NONE.
7-37 . --|
7-38 . ----------------------------------------------------------------------------
7-39 . */
7-40 . static void ca.7.1(void)
7-41 . {
7-42 . A = B*C;
7-43 . A = B-C;
7-44 .
7-45 . if (A ne B)
7-46 . {
7-47 . A = B + C;
7-48 . D = E + F;
7-49 . }
7-50 .
7-51 .
7-52 . switch (ca stuff)
7-53 . {
7-54 . case one:
7-55 . {
7-56 . run_this;
7-57 . break;
7-58 . }
7-59 . case two:
7-60 . {
7-61 . run_this;
7-62 . break;
7-63 . }
7-64 . // missing default
7-65 . }
7-66 .
7-67 . A = B-C;
7-68 . A = B+C;
7-69 . A = B-C;
7-70 . A = B-C;
7-71 .
7-72 . if (A gt B)
7-73 . {
7-74 . A = B + C;
7-75 . D = E + F;
7-76 . }
7-77 .
7-78 . A = B/C;
7-79 . A = B*C;
7-80 . A = B*C;
7-81 .
7-82 . if {
7-83 . X = Y + Z;
7-84 . }
7-85 . else {
7-86 . halt;
7-87 . }
7-88 .
7-89 . A = B*C;
7-90 .
7-91 . if (A == B)
7-92 . {
7-93 . A = B + C;
7-94 . D = E + F;
7-95 . }
7-96 .
7-97 . A = B*C;
7-98 .
7-99 . if (A < B)
7-100 . {
7-101 . A = B + C;
7-102 . D = E + F;
7-103 . }
7-104 .
7-105 . /* LE SV TOC-1110 this is a ca-07.1.16 req to call isr*/
7-106 . A = (int)B + C;
7-107 . A = B+C;
7-108 . A = B+C;
7-109 . A = B*C;
7-110 . A = B*C;
7-111 .
7-112 . if (A le B)
7-113 . {
7-114 . A = B + C;
7-115 . D = E + F;
7-116 . }
7-117 .
7-118 .
7-119 . if (A == B)
7-120 . {
7-121 . A = B + C;
7-122 . D = E + F;
7-123 . }
7-124 .
7-125 . A = B+C;
7-126 . A = B-C;
7-127 . A = B/C;
7-128 . A = B-C;
7-129 .
7-130 . if (A le B)
7-131 . {
7-132 . A = B + C;
7-133 . D = E + F;
7-134 . }
7-135 .
7-136 . A = B*C;
7-137 . A = B-C;
7-138 . A = B*C;
7-139 .
7-140 . if (A == B)
7-141 . {
7-142 . A = B + C;
7-143 . D = E + F;
7-144 . }
7-145 .
7-146 .
7-147 . if (A > = B)
7-148 . {
7-149 . A = B + C;
7-150 . D = E + F;
7-151 . }
7-152 .
7-153 . A = B*C;
7-154 . A = B+C;
7-155 . A = B/C;
7-156 .
7-157 . switch (ca stuff)
7-158 . {
7-159 . case one:
7-160 . {
7-161 . run_this;
7-162 . break;
7-163 . }
7-164 . case two:
7-165 . {
7-166 . run_this;
7-167 . break;
7-168 . }
7-169 . default:
7-170 . {
7-171 . SwError;
7-172 . }
7-173 . }
7-174 .
7-175 .
7-176 . if (A lt B)
7-177 . {
7-178 . A = B + C;
7-179 . D = E + F;
7-180 . }
7-181 .
7-182 .
7-183 . if (A ge B)
7-184 . {
7-185 . A = B + C;
7-186 . D = E + F;
7-187 . }
7-188 .
7-189 .
7-190 . /* dead_block = C * D;
7-191 . dead_block = E * F; */
7-192 .
7-193 . A = B*C;
7-194 . A = B*C;
7-195 . A = B*C;
7-196 .
7-197 . if (A < B)
7-198 . {
7-199 . A = B + C;
7-200 . D = E + F;
7-201 . }
7-202 .
7-203 . /* LE SV TOC-1111 this is a ca-07.1.42 req to fail*/
7-204 . A = B-C;
7-205 . A = B/C;
7-206 . rcv_buffer = (U16 *) alloc(size+1);
7-207 . A = B/C;
7-208 .
7-209 . if (A > = B)
7-210 . {
7-211 . A = B + C;
7-212 . D = E + F;
7-213 . }
7-214 .
7-215 .
7-216 . if (A ge B)
7-217 . {
7-218 . A = B + C;
7-219 . D = E + F;
7-220 . }
7-221 .
7-222 . A = B/C;
7-223 . A = B/C;
7-224 . A = B/C;
7-225 . A = B+C;
7-226 . A = B*C;
7-227 . A = B-C;
7-228 . /* LE SV TOC-1112 this is a ca-07.1.53 req to store*/
7-229 . A = B*C;
7-230 . A = B/C;
7-231 .
7-232 . switch (ca stuff)
7-233 . {
7-234 . case one:
7-235 . {
7-236 . run_this;
7-237 . break;
7-238 . }
7-239 . case two:
7-240 . {
7-241 . run_this;
7-242 . break;
7-243 . }
7-244 . default:
7-245 . {
7-246 . SwError;
7-247 . }
7-248 . }
7-249 .
7-250 .
7-251 . if (A ge B)
7-252 . {
7-253 . A = B + C;
7-254 . D = E + F;
7-255 . }
7-256 .
7-257 .
7-258 . if (A lt B)
7-259 . {
7-260 . A = B + C;
7-261 . D = E + F;
7-262 . }
7-263 .
7-264 . A = B+C;
7-265 .
7-266 . if (A != B)
7-267 . {
7-268 . A = B + C;
7-269 . D = E + F;
7-270 . }
7-271 .
7-272 . A = B*C;
7-273 . A = B/C;
7-274 .
7-275 . if (A eq B)
7-276 . {
7-277 . A = B + C;
7-278 . D = E + F;
7-279 . }
7-280 .
7-281 . A = B+C;
7-282 . A = B/C;
7-283 .
7-284 . if (A ge B)
7-285 . {
7-286 . A = B + C;
7-287 . D = E + F;
7-288 . }
7-289 .
7-290 . // max LOC 65
7-291 .
7-292 . }
7-293 .
7-294 .
7-295 . /*
7-296 . -----------------------------------------------------------------------------
7-297 . --| NAME: ca.7.2
7-298 . --|
7-299 . --| ABSTRACT:
7-300 . --| This function does ca stuff.
7-301 . --|
7-302 . --| RETURNS:
7-303 . --| NONE.
7-304 . --|
7-305 . ----------------------------------------------------------------------------
7-306 . */
7-307 . static void ca.7.2(void)
7-308 . {
7-309 .
7-310 . if (A != B)
7-311 . {
7-312 . A = B + C;
7-313 . D = E + F;
7-314 . }
7-315 .
7-316 . A = B+C;
7-317 . A = B*C;
7-318 . A = B*C;
7-319 . A = B-C;
7-320 . A = B+C;
7-321 . A = B+C;
7-322 . A = B+C;
7-323 .
7-324 . switch (ca stuff)
7-325 . {
7-326 . case one:
7-327 . {
7-328 . run_this;
7-329 . break;
7-330 . }
7-331 . case two:
7-332 . {
7-333 . run_this;
7-334 . break;
7-335 . }
7-336 . default:
7-337 . {
7-338 . SwError;
7-339 . }
7-340 . }
7-341 .
7-342 .
7-343 . if (A le B)
7-344 . {
7-345 . A = B + C;
7-346 . D = E + F;
7-347 . }
7-348 .
7-349 . A = B/C;
7-350 . A = B*C;
7-351 . A = B-C;
7-352 . A = B+C;
7-353 . A = B+C;
7-354 .
7-355 . if (A > = B)
7-356 . {
7-357 . A = B + C;
7-358 . D = E + F;
7-359 . }
7-360 .
7-361 .
7-362 . if (veg)
7-363 . // missing curly brace
7-364 . variable = orange;
7-365 .
7-366 .
7-367 . if (A eq B)
7-368 . {
7-369 . A = B + C;
7-370 . D = E + F;
7-371 . }
7-372 .
7-373 . A = B*C;
7-374 . A = B*C;
7-375 .
7-376 . if (A lt B)
7-377 . {
7-378 . A = B + C;
7-379 . D = E + F;
7-380 . }
7-381 .
7-382 . A = B+C;
7-383 .
7-384 . if (A > = B)
7-385 . {
7-386 . A = B + C;
7-387 . D = E + F;
7-388 . }
7-389 .
7-390 . /* LE SV TOC-1113 this is a ca-07.2.23 req to call admin*/
7-391 . A = B+C;
7-392 . /* LE SV TOC-1114 this is a ca-07.2.24 req to convert*/
7-393 . A = B*C;
7-394 . /* LE SV TOC-1115 this is a ca-07.2.25 req to reject*/
7-395 . A = B/C;
7-396 . A = B-C;
7-397 . A = B/C;
7-398 . A = B-C;
7-399 . A = B+C;
7-400 . A = B-C;
7-401 .
7-402 . if (A le B)
7-403 . {
7-404 . A = B + C;
7-405 . D = E + F;
7-406 . }
7-407 .
7-408 . A = B+C;
7-409 .
7-410 . if (A ne B)
7-411 . {
7-412 . A = B + C;
7-413 . D = E + F;
7-414 . }
7-415 .
7-416 . A = B+C;
7-417 . A = B*C;
7-418 . A = B/C;
7-419 . A = B-C;
7-420 .
7-421 . if (A gt B)
7-422 . {
7-423 . A = B + C;
7-424 . D = E + F;
7-425 . }
7-426 .
7-427 . A = B/C;
7-428 .
7-429 . if (A < = B)
7-430 . {
7-431 . A = B + C;
7-432 . D = E + F;
7-433 . }
7-434 .
7-435 . A = B+C;
7-436 . A = B+C;
7-437 .
7-438 . if (A == B)
7-439 . {
7-440 . A = B + C;
7-441 . D = E + F;
7-442 . }
7-443 .
7-444 . A = B/C;
7-445 . A = B/C;
7-446 . A = B*C;
7-447 . A = B+C;
7-448 . A = B*C;
7-449 . A = B/C;
7-450 . A = B*C;
7-451 . A = B/C;
7-452 . A = B/C;
7-453 . A = B/C;
7-454 .
7-455 . if (A < B)
7-456 . {
7-457 . A = B + C;
7-458 . D = E + F;
7-459 . }
7-460 .
7-461 . A = B+C;
7-462 . A = B-C;
7-463 . A = B*C;
7-464 . A = B*C;
7-465 .
7-466 . if (A > = B)
7-467 . {
7-468 . A = B + C;
7-469 . D = E + F;
7-470 . }
7-471 .
7-472 . A = B/C;
7-473 .
7-474 . if (A ne B)
7-475 . {
7-476 . A = B + C;
7-477 . D = E + F;
7-478 . }
7-479 .
7-480 .
7-481 . if (A > B)
7-482 . {
7-483 . A = B + C;
7-484 . D = E + F;
7-485 . }
7-486 .
7-487 . A = 0x0004;
7-488 . A = B*C;
7-489 . /* LE SV TOC-1116 this is a ca-07.2.64 req to call admin*/
7-490 .
7-491 . if (A > = B)
7-492 . {
7-493 . A = B + C;
7-494 . D = E + F;
7-495 . }
7-496 .
7-497 . A = B/C;
7-498 . A = B/C;
7-499 . A = B+C;
7-500 . A = B+C;
7-501 . A = B*C;
7-502 .
7-503 . if (A gt B)
7-504 . {
7-505 . A = B + C;
7-506 . D = E + F;
7-507 . }
7-508 .
7-509 . A = B/C;
7-510 .
7-511 . if (A lt B)
7-512 . {
7-513 . A = B + C;
7-514 . D = E + F;
7-515 . }
7-516 .
7-517 . A = B+C;
7-518 . A = B-C;
7-519 . A = B*C;
7-520 .
7-521 . if (A > B)
7-522 . {
7-523 . A = B + C;
7-524 . D = E + F;
7-525 . }
7-526 .
7-527 . A = B+C;
7-528 . FreePtr = HmiStringPtr;
7-529 .
7-530 . if (A ge B)
7-531 . {
7-532 . A = B + C;
7-533 . D = E + F;
7-534 . }
7-535 .
7-536 . A = B*C;
7-537 . A = B*C;
7-538 . A = B*C;
7-539 .
7-540 . if (A > B)
7-541 . {
7-542 . A = B + C;
7-543 . D = E + F;
7-544 . }
7-545 .
7-546 .
7-547 . if (A ne B)
7-548 . {
7-549 . A = B + C;
7-550 . D = E + F;
7-551 . }
7-552 .
7-553 . A = B*C;
7-554 . A = B+C;
7-555 . A = B/C;
7-556 . A = B/C;
7-557 . A = B*C;
7-558 . A = B-C;
7-559 .
7-560 . if (A > = B)
7-561 . {
7-562 . A = B + C;
7-563 . D = E + F;
7-564 . }
7-565 .
7-566 .
7-567 . if (A eq B)
7-568 . {
7-569 . A = B + C;
7-570 . D = E + F;
7-571 . }
7-572 .
7-573 .
7-574 . if {
7-575 . X = Y + Z;
7-576 . }
7-577 . else {
7-578 . halt;
7-579 . }
7-580 .
7-581 . A = B-C;
7-582 . A = B*C;
7-583 . /* LE SV TOC-1117 this is a ca-07.2.94 req to transform*/
7-584 . A = B*C;
7-585 . // max LOC 94
7-586 .
7-587 . }
7-588 .
7-589 .
7-590 . /*
7-591 . -----------------------------------------------------------------------------
7-592 . --| NAME: ca.7.3
7-593 . --|
7-594 . --| ABSTRACT:
7-595 . --| This function does ca stuff.
7-596 . --|
7-597 . --| RETURNS:
7-598 . --| NONE.
7-599 . --|
7-600 . ----------------------------------------------------------------------------
7-601 . */
7-602 . static void ca.7.3(void)
7-603 . {
7-604 . A = B/C;
7-605 . A = 0x0008;
7-606 . A = B-C;
7-607 . A = B*C;
7-608 . A = B-C;
7-609 . A = B*C;
7-610 . A = B+C;
7-611 . A = B/C;
7-612 . A = B/C;
7-613 . A = B/C;
7-614 . A = B-C;
7-615 . A = B+C;
7-616 .
7-617 . if (A lt B)
7-618 . {
7-619 . A = B + C;
7-620 . D = E + F;
7-621 . }
7-622 .
7-623 .
7-624 . if (A > = B)
7-625 . {
7-626 . A = B + C;
7-627 . D = E + F;
7-628 . }
7-629 .
7-630 . A = B/C;
7-631 .
7-632 . switch (ca stuff)
7-633 . {
7-634 . case one:
7-635 . {
7-636 . run_this;
7-637 . break;
7-638 . }
7-639 . case two:
7-640 . {
7-641 . run_this;
7-642 . break;
7-643 . }
7-644 . default:
7-645 . {
7-646 . SwError;
7-647 . }
7-648 . }
7-649 .
7-650 . /* LE SV TOC-1118 this is a ca-07.3.16 req to convert*/
7-651 . A = B*C;
7-652 . A = B*C;
7-653 . A = B*C;
7-654 . A = B-C;
7-655 . A = B*C;
7-656 . A = B*C;
7-657 . A = B/C;
7-658 . A = 0x0008;
7-659 . A = B/C;
7-660 .
7-661 . if (A > B)
7-662 . {
7-663 . A = B + C;
7-664 . D = E + F;
7-665 . }
7-666 .
7-667 . A = B/C;
7-668 . /* LE SV TOC-1119 this is a ca-07.3.26 req to call admin*/
7-669 . A = B*C;
7-670 . A = B-C;
7-671 .
7-672 . if (A < = B)
7-673 . {
7-674 . A = B + C;
7-675 . D = E + F;
7-676 . }
7-677 .
7-678 . // TBD - what do I do now
7-679 . A = B/C;
7-680 . A = B*C;
7-681 .
7-682 . if (A > B)
7-683 . {
7-684 . A = B + C;
7-685 . D = E + F;
7-686 . }
7-687 .
7-688 .
7-689 . if (A < = B)
7-690 . {
7-691 . A = B + C;
7-692 . D = E + F;
7-693 . }
7-694 .
7-695 . A = B-C;
7-696 . A = B+C;
7-697 . A = B-C;
7-698 . A = B-C;
7-699 . A = (int)B + C;
7-700 . A = B+C;
7-701 .
7-702 . if (A < B)
7-703 . {
7-704 . A = B + C;
7-705 . D = E + F;
7-706 . }
7-707 .
7-708 .
7-709 . if (A lt B)
7-710 . {
7-711 . A = B + C;
7-712 . D = E + F;
7-713 . }
7-714 .
7-715 . A = B+C;
7-716 . A = B/C;
7-717 . A = B-C;
7-718 . A = B*C;
7-719 . A = B*C;
7-720 .
7-721 . if (A lt B)
7-722 . {
7-723 . A = B + C;
7-724 . D = E + F;
7-725 . }
7-726 .
7-727 .
7-728 . switch (ca stuff)
7-729 . {
7-730 . case one:
7-731 . {
7-732 . run_this;
7-733 . break;
7-734 . }
7-735 . case two:
7-736 . {
7-737 . run_this;
7-738 . break;
7-739 . }
7-740 . default:
7-741 . {
7-742 . SwError;
7-743 . }
7-744 . }
7-745 .
7-746 . A = B*C;
7-747 . A = B+C;
7-748 . A = B+C;
7-749 .
7-750 . if (A > B)
7-751 . {
7-752 . A = B + C;
7-753 . D = E + F;
7-754 . }
7-755 .
7-756 . /* LE SV TOC-1120 this is a ca-07.3.51 req to check pSOS*/
7-757 .
7-758 . switch (ca stuff)
7-759 . {
7-760 . case one:
7-761 . {
7-762 . run_this;
7-763 . // missing break
7-764 . }
7-765 . case two:
7-766 . {
7-767 . run_this;
7-768 . break;
7-769 . }
7-770 . default:
7-771 . {
7-772 . SwError;
7-773 . }
7-774 . }
7-775 .
7-776 .
7-777 . if (A < B)
7-778 . {
7-779 . A = B + C;
7-780 . D = E + F;
7-781 . }
7-782 .
7-783 .
7-784 . if (A != B)
7-785 . {
7-786 . A = B + C;
7-787 . D = E + F;
7-788 . }
7-789 .
7-790 . // max LOC 52
7-791 .
7-792 . }
7-793 .
7-794 .
7-795 . /*
7-796 . -----------------------------------------------------------------------------
7-797 . --| NAME: ca.7.4
7-798 . --|
7-799 . --| ABSTRACT:
7-800 . --| This function does ca stuff.
7-801 . --|
7-802 . --| RETURNS:
7-803 . --| NONE.
7-804 . --|
7-805 . ----------------------------------------------------------------------------
7-806 . */
7-807 . static void ca.7.4(void)
7-808 . {
7-809 .
7-810 . if (A le B)
7-811 . {
7-812 . A = B + C;
7-813 . D = E + F;
7-814 . }
7-815 .
7-816 .
7-817 . if (A < = B)
7-818 . {
7-819 . A = B + C;
7-820 . D = E + F;
7-821 . }
7-822 .
7-823 . A = B/C;
7-824 . A = B-C;
7-825 . A = B-C;
7-826 . A = B/C;
7-827 . A = B*C;
7-828 . A = B*C;
7-829 .
7-830 . if (A < B)
7-831 . {
7-832 . A = B + C;
7-833 . D = E + F;
7-834 . }
7-835 .
7-836 .
7-837 . if (A < = B)
7-838 . {
7-839 . A = B + C;
7-840 . D = E + F;
7-841 . }
7-842 .
7-843 . // TBD - what do I do now
7-844 . A = B+C;
7-845 . A = B+C;
7-846 . /* LE SV TOC-1121 this is a ca-07.4.13 req to inhibit*/
7-847 . A = B+C;
7-848 .
7-849 . if (A > = B)
7-850 . {
7-851 . A = B + C;
7-852 . D = E + F;
7-853 . }
7-854 .
7-855 . A = B-C;
7-856 . /* LE SV TOC-1122 this is a ca-07.4.16 req to audit*/
7-857 . A = B-C;
7-858 .
7-859 . switch (ca stuff)
7-860 . {
7-861 . case one:
7-862 . {
7-863 . run_this;
7-864 . break;
7-865 . }
7-866 . case two:
7-867 . {
7-868 . run_this;
7-869 . break;
7-870 . }
7-871 . default:
7-872 . {
7-873 . SwError;
7-874 . }
7-875 . }
7-876 .
7-877 . /* LE SV TOC-1123 this is a ca-07.4.18 req to detect error*/
7-878 .
7-879 . if (A ne B)
7-880 . {
7-881 . A = B + C;
7-882 . D = E + F;
7-883 . }
7-884 .
7-885 .
7-886 . if (A > = B)
7-887 . {
7-888 . A = B + C;
7-889 . D = E + F;
7-890 . }
7-891 .
7-892 . A = B/C;
7-893 . A = B/C;
7-894 . A = B+C;
7-895 . A = B/C;
7-896 . // max LOC 23
7-897 .
7-898 . }
7-899 .
7-900 .
7-901 . /*
7-902 . -----------------------------------------------------------------------------
7-903 . --| NAME: ca.7.5
7-904 . --|
7-905 . --| ABSTRACT:
7-906 . --| This function does ca stuff.
7-907 . --|
7-908 . --| RETURNS:
7-909 . --| NONE.
7-910 . --|
7-911 . ----------------------------------------------------------------------------
7-912 . */
7-913 . static void ca.7.5(void)
7-914 . {
7-915 . A = B/C;
7-916 . A = B+C;
7-917 .
7-918 . if (A > = B)
7-919 . {
7-920 . A = B + C;
7-921 . D = E + F;
7-922 . }
7-923 .
7-924 . A = B+C;
7-925 . A = B/C;
7-926 . A = B+C;
7-927 . /* LE SV TOC-1124 this is a ca-07.5.7 req to update*/
7-928 . A = B/C;
7-929 . A = B/C;
7-930 . A = B+C;
7-931 . A = B+C;
7-932 . A = B*C;
7-933 . A = 0x0007;
7-934 . A = B-C;
7-935 . A = B/C;
7-936 . A = B/C;
7-937 .
7-938 . if (A < B)
7-939 . {
7-940 . A = B + C;
7-941 . D = E + F;
7-942 . }
7-943 .
7-944 . A = B/C;
7-945 . A = B/C;
7-946 .
7-947 . if (A lt B)
7-948 . {
7-949 . A = B + C;
7-950 . D = E + F;
7-951 . }
7-952 .
7-953 . A = B/C;
7-954 .
7-955 . if (A < = B)
7-956 . {
7-957 . A = B + C;
7-958 . D = E + F;
7-959 . }
7-960 .
7-961 . A = B*C;
7-962 . A = B*C;
7-963 . A = B-C;
7-964 . A = (int)B + C;
7-965 .
7-966 . if (A > = B)
7-967 . {
7-968 . A = B + C;
7-969 . D = E + F;
7-970 . }
7-971 .
7-972 . A = B+C;
7-973 . A = B/C;
7-974 . // max LOC 26
7-975 .
7-976 . }
7-977 .
7-978 .
7-979 . /*
7-980 . -----------------------------------------------------------------------------
7-981 . --| NAME: ca.7.6
7-982 . --|
7-983 . --| ABSTRACT:
7-984 . --| This function does ca stuff.
7-985 . --|
7-986 . --| RETURNS:
7-987 . --| NONE.
7-988 . --|
7-989 . ----------------------------------------------------------------------------
7-990 . */
7-991 . static void ca.7.6(void)
7-992 . {
7-993 . A = B*C;
7-994 . A = B/C;
7-995 .
7-996 . if (A ge B)
7-997 . {
7-998 . A = B + C;
7-999 . D = E + F;
7-1000 . }
7-1001 .
7-1002 .
7-1003 . if (A ge B)
7-1004 . {
7-1005 . A = B + C;
7-1006 . D = E + F;
7-1007 . }
7-1008 .
7-1009 . A = B-C;
7-1010 .
7-1011 . if (A > B)
7-1012 . {
7-1013 . A = B + C;
7-1014 . D = E + F;
7-1015 . }
7-1016 .
7-1017 . A = B+C;
7-1018 . A = B+C;
7-1019 . A = B*C;
7-1020 . A = B*C;
7-1021 .
7-1022 . if (A lt B)
7-1023 . {
7-1024 . A = B + C;
7-1025 . D = E + F;
7-1026 . }
7-1027 .
7-1028 . A = B+C;
7-1029 . /* LE SV TOC-1125 this is a ca-07.6.13 req to enable*/
7-1030 .
7-1031 . if (A lt B)
7-1032 . {
7-1033 . A = B + C;
7-1034 . D = E + F;
7-1035 . }
7-1036 .
7-1037 . A = B*C;
7-1038 .
7-1039 . if (A gt B)
7-1040 . {
7-1041 . A = B + C;
7-1042 . D = E + F;
7-1043 . }
7-1044 .
7-1045 . A = B*C;
7-1046 . A = B-C;
7-1047 . A = B*C;
7-1048 . A = B*C;
7-1049 . A = B/C;
7-1050 . A = B/C;
7-1051 . A = B/C;
7-1052 . A = B*C;
7-1053 . A = B/C;
7-1054 . A = B-C;
7-1055 . A = B/C;
7-1056 .
7-1057 . if (A > = B)
7-1058 . {
7-1059 . A = B + C;
7-1060 . D = E + F;
7-1061 . }
7-1062 .
7-1063 .
7-1064 . if (A eq B)
7-1065 . {
7-1066 . A = B + C;
7-1067 . D = E + F;
7-1068 . }
7-1069 .
7-1070 . A = B-C;
7-1071 .
7-1072 . if (A lt B)
7-1073 . {
7-1074 . A = B + C;
7-1075 . D = E + F;
7-1076 . }
7-1077 .
7-1078 . /* LE SV TOC-1126 this is a ca-07.6.31 req to process*/
7-1079 . A = B-C;
7-1080 . A = B+C;
7-1081 . A = B+C;
7-1082 .
7-1083 . if (A le B)
7-1084 . {
7-1085 . A = B + C;
7-1086 . D = E + F;
7-1087 . }
7-1088 .
7-1089 .
7-1090 . if (A ne B)
7-1091 . {
7-1092 . A = B + C;
7-1093 . D = E + F;
7-1094 . }
7-1095 .
7-1096 . A = B*C;
7-1097 .
7-1098 . if (A == B)
7-1099 . {
7-1100 . A = B + C;
7-1101 . D = E + F;
7-1102 . }
7-1103 .
7-1104 . A = B-C;
7-1105 . A = B+C;
7-1106 . A = B/C;
7-1107 . A = B+C;
7-1108 . A = B+C;
7-1109 .
7-1110 . if (A != B)
7-1111 . {
7-1112 . A = B + C;
7-1113 . D = E + F;
7-1114 . }
7-1115 .
7-1116 . A = B+C;
7-1117 .
7-1118 . if (A le B)
7-1119 . {
7-1120 . A = B + C;
7-1121 . D = E + F;
7-1122 . }
7-1123 .
7-1124 . A = B+C;
7-1125 .
7-1126 . if (A < B)
7-1127 . {
7-1128 . A = B + C;
7-1129 . D = E + F;
7-1130 . }
7-1131 .
7-1132 . A = B*C;
7-1133 .
7-1134 . if (A > = B)
7-1135 . {
7-1136 . A = B + C;
7-1137 . D = E + F;
7-1138 . }
7-1139 .
7-1140 . A = B+C;
7-1141 . /* LE SV TOC-1127 this is a ca-07.6.51 req to compare*/
7-1142 .
7-1143 . if (A != B)
7-1144 . {
7-1145 . A = B + C;
7-1146 . D = E + F;
7-1147 . }
7-1148 .
7-1149 . A = B*C;
7-1150 . A = B/C;
7-1151 . A = B/C;
7-1152 . A = B/C;
7-1153 . A = B*C;
7-1154 . A = B/C;
7-1155 . A = B-C;
7-1156 . A = B/C;
7-1157 . A = B+C;
7-1158 . /* LE SV TOC-1128 this is a ca-07.6.61 req to enable*/
7-1159 .
7-1160 . if (A ne B)
7-1161 . {
7-1162 . A = B + C;
7-1163 . D = E + F;
7-1164 . }
7-1165 .
7-1166 . A = B/C;
7-1167 . // (P) this is really improtant
7-1168 . A = B-C;
7-1169 .
7-1170 . switch (ca stuff)
7-1171 . {
7-1172 . case one:
7-1173 . {
7-1174 . run_this;
7-1175 . break;
7-1176 . }
7-1177 . case two:
7-1178 . {
7-1179 . run_this;
7-1180 . break;
7-1181 . }
7-1182 . default:
7-1183 . {
7-1184 . SwError;
7-1185 . }
7-1186 . }
7-1187 .
7-1188 .
7-1189 . if (A ge B)
7-1190 . {
7-1191 . A = B + C;
7-1192 . D = E + F;
7-1193 . }
7-1194 .
7-1195 .
7-1196 . if (A < B)
7-1197 . {
7-1198 . A = B + C;
7-1199 . D = E + F;
7-1200 . }
7-1201 .
7-1202 . A = B+C;
7-1203 . A = B-C;
7-1204 .
7-1205 . if (A == B)
7-1206 . {
7-1207 . A = B + C;
7-1208 . D = E + F;
7-1209 . }
7-1210 .
7-1211 . A = B-C;
7-1212 . A = B*C;
7-1213 . A = B/C;
7-1214 . A = B/C;
7-1215 . /* LE SV TOC-1129 this is a ca-07.6.74 req to inhibit*/
7-1216 . A = B*C;
7-1217 .
7-1218 . if (A < = B)
7-1219 . {
7-1220 . A = B + C;
7-1221 . D = E + F;
7-1222 . }
7-1223 .
7-1224 . A = B+C;
7-1225 . A = B/C;
7-1226 . // max LOC 77
7-1227 .
7-1228 . }
7-1229 .
7-1230 .
7-1231 . /*
7-1232 . -----------------------------------------------------------------------------
7-1233 . --| NAME: ca.7.7
7-1234 . --|
7-1235 . --| ABSTRACT:
7-1236 . --| This function does ca stuff.
7-1237 . --|
7-1238 . --| RETURNS:
7-1239 . --| NONE.
7-1240 . --|
7-1241 . ----------------------------------------------------------------------------
7-1242 . */
7-1243 . static void ca.7.7(void)
7-1244 . {
7-1245 . A = B/C;
7-1246 . A = B*C;
7-1247 .
7-1248 . if (A eq B)
7-1249 . {
7-1250 . A = B + C;
7-1251 . D = E + F;
7-1252 . }
7-1253 .
7-1254 .
7-1255 . if (A ne B)
7-1256 . {
7-1257 . A = B + C;
7-1258 . D = E + F;
7-1259 . }
7-1260 .
7-1261 .
7-1262 . if (A eq B)
7-1263 . {
7-1264 . A = B + C;
7-1265 . D = E + F;
7-1266 . }
7-1267 .
7-1268 . A = B-C;
7-1269 .
7-1270 . if (A != B)
7-1271 . {
7-1272 . A = B + C;
7-1273 . D = E + F;
7-1274 . }
7-1275 .
7-1276 .
7-1277 . if (A le B)
7-1278 . {
7-1279 . A = B + C;
7-1280 . D = E + F;
7-1281 . }
7-1282 .
7-1283 .
7-1284 . if (A > = B)
7-1285 . {
7-1286 . A = B + C;
7-1287 . D = E + F;
7-1288 . }
7-1289 .
7-1290 .
7-1291 . if (A lt B)
7-1292 . {
7-1293 . A = B + C;
7-1294 . D = E + F;
7-1295 . }
7-1296 .
7-1297 . A = B+C;
7-1298 . A = B/C;
7-1299 .
7-1300 . if (A < = B)
7-1301 . {
7-1302 . A = B + C;
7-1303 . D = E + F;
7-1304 . }
7-1305 .
7-1306 .
7-1307 . if (A ne B)
7-1308 . {
7-1309 . A = B + C;
7-1310 . D = E + F;
7-1311 . }
7-1312 .
7-1313 .
7-1314 . if (A eq B)
7-1315 . {
7-1316 . A = B + C;
7-1317 . D = E + F;
7-1318 . }
7-1319 .
7-1320 . A = B+C;
7-1321 .
7-1322 . if (A != B)
7-1323 . {
7-1324 . A = B + C;
7-1325 . D = E + F;
7-1326 . }
7-1327 .
7-1328 . // max LOC 17
7-1329 .
7-1330 . }
7-1331 .
7 7 Result: result/source/pr-app/pr-app-CA123/ca/ca-07.c
8 8 Source: source/pr-app/pr-app-CA123/ca/ca-08.c
8-0 . /*
8-1 . ----------------------------------------------------------------------------
8-2 . --| BEGIN PROLOGUE
8-3 . --|
8-4 . --| CLASSIFICATION: UNCLASSIFIED
8-5 . --|
8-6 . --| FILE NAME: ca-08.c
8-7 . --|
8-8 . --| ABSTRACT:
8-9 . --| This file contains the 12 functions that do file ca stuff.
8-10 . --|
8-11 . --| HISTORY:
8-12 . --| CCCQ_NAME:
8-13 . --| CCCQ_VER:
8-14 . --|
8-15 . --| END PROLOGUE
8-16 . ----------------------------------------------------------------------------
8-17 . */
8-18 .
8-19 . #include B;
8-20 . float B;
8-21 . char D;
8-22 . #define A;
8-23 . #define C;
8-24 . #include D;
8-25 . #include A;
8-26 . #include A;
8-27 .
8-28 .
8-29 .
8-30 . /*
8-31 . -----------------------------------------------------------------------------
8-32 . --| NAME: ca.8.1
8-33 . --|
8-34 . --| ABSTRACT:
8-35 . --| This function does ca stuff.
8-36 . --|
8-37 . --| RETURNS:
8-38 . --| NONE.
8-39 . --|
8-40 . ----------------------------------------------------------------------------
8-41 . */
8-42 . static void ca.8.1(void)
8-43 . {
8-44 . A = B+C;
8-45 . A = B-C;
8-46 . A = B+C;
8-47 . A = B*C;
8-48 . A = B-C;
8-49 . A = B*C;
8-50 . /* LE SV TOC-1130 this is a ca-08.1.7 req to fail*/
8-51 . A = B+C;
8-52 . A = B+C;
8-53 . A = B+C;
8-54 .
8-55 . if (A == B)
8-56 . {
8-57 . A = B + C;
8-58 . D = E + F;
8-59 . }
8-60 .
8-61 .
8-62 . /* dead_block = C * D;
8-63 . dead_block = E * F; */
8-64 .
8-65 . A = B/C;
8-66 .
8-67 . if (A < = B)
8-68 . {
8-69 . A = B + C;
8-70 . D = E + F;
8-71 . }
8-72 .
8-73 . A = B*C;
8-74 . A = B*C;
8-75 . A = B+C;
8-76 . A = B/C;
8-77 .
8-78 . if (A gt B)
8-79 . {
8-80 . A = B + C;
8-81 . D = E + F;
8-82 . }
8-83 .
8-84 . A = B/C;
8-85 . A = B-C;
8-86 . A = B*C;
8-87 . A = B+C;
8-88 . A = B-C;
8-89 . A = B-C;
8-90 . A = B+C;
8-91 .
8-92 . switch (ca stuff)
8-93 . {
8-94 . case one:
8-95 . {
8-96 . run_this;
8-97 . // missing break
8-98 . }
8-99 . case two:
8-100 . {
8-101 . run_this;
8-102 . break;
8-103 . }
8-104 . default:
8-105 . {
8-106 . SwError;
8-107 . }
8-108 . }
8-109 .
8-110 . A = B-C;
8-111 . A = B-C;
8-112 . A = B+C;
8-113 . A = B+C;
8-114 . A = B+C;
8-115 . A = B/C;
8-116 . A = B-C;
8-117 . A = B*C;
8-118 .
8-119 . if (A gt B)
8-120 . {
8-121 . A = B + C;
8-122 . D = E + F;
8-123 . }
8-124 .
8-125 .
8-126 . if (A lt B)
8-127 . {
8-128 . A = B + C;
8-129 . D = E + F;
8-130 . }
8-131 .
8-132 . A = B-C;
8-133 . A = B*C;
8-134 . A = (int)B + C;
8-135 . A = B*C;
8-136 . A = B*C;
8-137 . A = B-C;
8-138 . A = B/C;
8-139 .
8-140 . if (A lt B)
8-141 . {
8-142 . A = B + C;
8-143 . D = E + F;
8-144 . }
8-145 .
8-146 . A = B+C;
8-147 .
8-148 . if (A ne B)
8-149 . {
8-150 . A = B + C;
8-151 . D = E + F;
8-152 . }
8-153 .
8-154 . A = B+C;
8-155 . A = B*C;
8-156 . A = B/C;
8-157 . send_buffer = (U16 *) malloc(size+1);
8-158 . A = B+C;
8-159 . A = B*C;
8-160 . A = B/C;
8-161 . A = B*C;
8-162 . /* LE SV TOC-1131 this is a ca-08.1.51 req to set Real Time Clock*/
8-163 . A = 0x0004;
8-164 . A = B-C;
8-165 .
8-166 . if (A < = B)
8-167 . {
8-168 . A = B + C;
8-169 . D = E + F;
8-170 . }
8-171 .
8-172 . A = B/C;
8-173 .
8-174 . if (A < = B)
8-175 . {
8-176 . A = B + C;
8-177 . D = E + F;
8-178 . }
8-179 .
8-180 .
8-181 . if (A > = B)
8-182 . {
8-183 . A = B + C;
8-184 . D = E + F;
8-185 . }
8-186 .
8-187 . A = B-C;
8-188 . // max LOC 56
8-189 .
8-190 . }
8-191 .
8-192 .
8-193 . /*
8-194 . -----------------------------------------------------------------------------
8-195 . --| NAME: ca.8.2
8-196 . --|
8-197 . --| ABSTRACT:
8-198 . --| This function does ca stuff.
8-199 . --|
8-200 . --| RETURNS:
8-201 . --| NONE.
8-202 . --|
8-203 . ----------------------------------------------------------------------------
8-204 . */
8-205 . static void ca.8.2(void)
8-206 . {
8-207 .
8-208 . if (A > = B)
8-209 . {
8-210 . A = B + C;
8-211 . D = E + F;
8-212 . }
8-213 .
8-214 . A = B/C;
8-215 . A = B+C;
8-216 . A = B*C;
8-217 .
8-218 . if (A > = B)
8-219 . {
8-220 . A = B + C;
8-221 . D = E + F;
8-222 . }
8-223 .
8-224 . A = B/C;
8-225 .
8-226 . if (A == B)
8-227 . {
8-228 . A = B + C;
8-229 . D = E + F;
8-230 . }
8-231 .
8-232 . A = B+C;
8-233 . A = B-C;
8-234 . A = B/C;
8-235 .
8-236 . if (A < B)
8-237 . {
8-238 . A = B + C;
8-239 . D = E + F;
8-240 . }
8-241 .
8-242 . // max LOC 11
8-243 .
8-244 . }
8-245 .
8-246 .
8-247 . /*
8-248 . -----------------------------------------------------------------------------
8-249 . --| NAME: ca.8.3
8-250 . --|
8-251 . --| ABSTRACT:
8-252 . --| This function does ca stuff.
8-253 . --|
8-254 . --| RETURNS:
8-255 . --| NONE.
8-256 . --|
8-257 . ----------------------------------------------------------------------------
8-258 . */
8-259 . static void ca.8.3(void)
8-260 . {
8-261 .
8-262 . if (A gt B)
8-263 . {
8-264 . A = B + C;
8-265 . D = E + F;
8-266 . }
8-267 .
8-268 . A = B-C;
8-269 . A = B+C;
8-270 . A = B+C;
8-271 .
8-272 . if (A < B)
8-273 . {
8-274 . A = B + C;
8-275 . D = E + F;
8-276 . }
8-277 .
8-278 . /* LE SV TOC-1132 this is a ca-08.3.6 req to translate*/
8-279 . A = B*C;
8-280 .
8-281 . if (A eq B)
8-282 . {
8-283 . A = B + C;
8-284 . D = E + F;
8-285 . }
8-286 .
8-287 .
8-288 . if (A > = B)
8-289 . {
8-290 . A = B + C;
8-291 . D = E + F;
8-292 . }
8-293 .
8-294 .
8-295 . if (A > B)
8-296 . {
8-297 . A = B + C;
8-298 . D = E + F;
8-299 . }
8-300 .
8-301 . A = B-C;
8-302 . A = B-C;
8-303 . A = B+C;
8-304 . A = B+C;
8-305 . A = B-C;
8-306 . A = B/C;
8-307 . A = B-C;
8-308 . A = B/C;
8-309 . A = B*C;
8-310 .
8-311 . /*
8-312 . dead_block = C * D;
8-313 . dead_block = E * F;
8-314 . */
8-315 .
8-316 .
8-317 . if (A > = B)
8-318 . {
8-319 . A = B + C;
8-320 . D = E + F;
8-321 . }
8-322 .
8-323 . A = B/C;
8-324 .
8-325 . switch (ca stuff)
8-326 . {
8-327 . case one:
8-328 . {
8-329 . run_this;
8-330 . break;
8-331 . }
8-332 . case two:
8-333 . {
8-334 . run_this;
8-335 . break;
8-336 . }
8-337 . default:
8-338 . {
8-339 . SwError;
8-340 . }
8-341 . }
8-342 .
8-343 .
8-344 . if (A ge B)
8-345 . {
8-346 . A = B + C;
8-347 . D = E + F;
8-348 . }
8-349 .
8-350 .
8-351 . if (A le B)
8-352 . {
8-353 . A = B + C;
8-354 . D = E + F;
8-355 . }
8-356 .
8-357 . A = B-C;
8-358 .
8-359 . if (A > B)
8-360 . {
8-361 . A = B + C;
8-362 . D = E + F;
8-363 . }
8-364 .
8-365 .
8-366 . if (A lt B)
8-367 . {
8-368 . A = B + C;
8-369 . D = E + F;
8-370 . }
8-371 .
8-372 .
8-373 . if (A == B)
8-374 . {
8-375 . A = B + C;
8-376 . D = E + F;
8-377 . }
8-378 .
8-379 . A = B/C;
8-380 . A = B/C;
8-381 . // max LOC 29
8-382 .
8-383 . }
8-384 .
8-385 .
8-386 . /*
8-387 . -----------------------------------------------------------------------------
8-388 . --| NAME: ca.8.4
8-389 . --|
8-390 . --| ABSTRACT:
8-391 . --| This function does ca stuff.
8-392 . --|
8-393 . --| RETURNS:
8-394 . --| NONE.
8-395 . --|
8-396 . ----------------------------------------------------------------------------
8-397 . */
8-398 . static void ca.8.4(void)
8-399 . {
8-400 .
8-401 . if (A le B)
8-402 . {
8-403 . A = B + C;
8-404 . D = E + F;
8-405 . }
8-406 .
8-407 . A = B/C;
8-408 .
8-409 . switch (ca stuff)
8-410 . {
8-411 . case one:
8-412 . {
8-413 . run_this;
8-414 . break;
8-415 . }
8-416 . case two:
8-417 . {
8-418 . run_this;
8-419 . break;
8-420 . }
8-421 . default:
8-422 . {
8-423 . SwError;
8-424 . }
8-425 . }
8-426 .
8-427 . /* LE SV TOC-1133 this is a ca-08.4.4 req to translate*/
8-428 . A = B-C;
8-429 .
8-430 . if (A ge B)
8-431 . {
8-432 . A = B + C;
8-433 . D = E + F;
8-434 . }
8-435 .
8-436 . A = B*C;
8-437 .
8-438 . if (A > = B)
8-439 . {
8-440 . A = B + C;
8-441 . D = E + F;
8-442 . }
8-443 .
8-444 . /* LE SV TOC-1134 this is a ca-08.4.8 req to set Real Time Clock*/
8-445 . A = B/C;
8-446 .
8-447 . if (A > B)
8-448 . {
8-449 . A = B + C;
8-450 . D = E + F;
8-451 . }
8-452 .
8-453 . rcv_buffer = (U16 *) alloc(size+1);
8-454 . A = B-C;
8-455 . /* LE SV TOC-1135 this is a ca-08.4.11 req to call admin*/
8-456 . A = B*C;
8-457 .
8-458 . if (A != B)
8-459 . {
8-460 . A = B + C;
8-461 . D = E + F;
8-462 . }
8-463 .
8-464 . A = B/C;
8-465 .
8-466 . if (A eq B)
8-467 . {
8-468 . A = B + C;
8-469 . D = E + F;
8-470 . }
8-471 .
8-472 .
8-473 . if (A < B)
8-474 . {
8-475 . A = B + C;
8-476 . D = E + F;
8-477 . }
8-478 .
8-479 . A = B-C;
8-480 . FreePtr = HmiStringPtr;
8-481 . A = B+C;
8-482 . A = B+C;
8-483 . A = B/C;
8-484 . A = B+C;
8-485 . A = B/C;
8-486 . /* LE SV TOC-1136 this is a ca-08.4.22 req to detect error*/
8-487 .
8-488 . if (A != B)
8-489 . {
8-490 . A = B + C;
8-491 . D = E + F;
8-492 . }
8-493 .
8-494 . A = B/C;
8-495 . A = B+C;
8-496 . // max LOC 24
8-497 .
8-498 . }
8-499 .
8-500 .
8-501 . /*
8-502 . -----------------------------------------------------------------------------
8-503 . --| NAME: ca.8.5
8-504 . --|
8-505 . --| ABSTRACT:
8-506 . --| This function does ca stuff.
8-507 . --|
8-508 . --| RETURNS:
8-509 . --| NONE.
8-510 . --|
8-511 . ----------------------------------------------------------------------------
8-512 . */
8-513 . static void ca.8.5(void)
8-514 . {
8-515 . A = B+C;
8-516 .
8-517 . if (A > B)
8-518 . {
8-519 . A = B + C;
8-520 . D = E + F;
8-521 . }
8-522 .
8-523 . A = B*C;
8-524 . A = B+C;
8-525 .
8-526 . if (A < = B)
8-527 . {
8-528 . A = B + C;
8-529 . D = E + F;
8-530 . }
8-531 .
8-532 .
8-533 . if (A ge B)
8-534 . {
8-535 . A = B + C;
8-536 . D = E + F;
8-537 . }
8-538 .
8-539 .
8-540 . if (A > = B)
8-541 . {
8-542 . A = B + C;
8-543 . D = E + F;
8-544 . }
8-545 .
8-546 . A = B+C;
8-547 . A = B*C;
8-548 .
8-549 . if (A eq B)
8-550 . {
8-551 . A = B + C;
8-552 . D = E + F;
8-553 . }
8-554 .
8-555 . A = B+C;
8-556 . A = 0x0004;
8-557 .
8-558 . if (A lt B)
8-559 . {
8-560 . A = B + C;
8-561 . D = E + F;
8-562 . }
8-563 .
8-564 . // max LOC 12
8-565 .
8-566 . }
8-567 .
8-568 .
8-569 . /*
8-570 . -----------------------------------------------------------------------------
8-571 . --| NAME: ca.8.6
8-572 . --|
8-573 . --| ABSTRACT:
8-574 . --| This function does ca stuff.
8-575 . --|
8-576 . --| RETURNS:
8-577 . --| NONE.
8-578 . --|
8-579 . ----------------------------------------------------------------------------
8-580 . */
8-581 . static void ca.8.6(void)
8-582 . {
8-583 . A = B*C;
8-584 . A = B*C;
8-585 .
8-586 . if ($ca stuff > $otherca stuff)
8-587 . /* LE SV TOC-008 we really should log all error calls */
8-588 . {
8-589 . A = B + C;
8-590 . }
8-591 .
8-592 . A = B*C;
8-593 .
8-594 . if (A gt B)
8-595 . {
8-596 . A = B + C;
8-597 . D = E + F;
8-598 . }
8-599 .
8-600 . A = B+C;
8-601 . /* LE SV TOC-1137 this is a ca-08.6.6 req to enable*/
8-602 .
8-603 . if (A gt B)
8-604 . {
8-605 . A = B + C;
8-606 . D = E + F;
8-607 . }
8-608 .
8-609 . A = 0x0006;
8-610 .
8-611 . if (A == B)
8-612 . {
8-613 . A = B + C;
8-614 . D = E + F;
8-615 . }
8-616 .
8-617 .
8-618 . if (A < = B)
8-619 . {
8-620 . A = B + C;
8-621 . D = E + F;
8-622 . }
8-623 .
8-624 . A = B*C;
8-625 . A = B/C;
8-626 .
8-627 . if (A le B)
8-628 . {
8-629 . A = B + C;
8-630 . D = E + F;
8-631 . }
8-632 .
8-633 . A = B-C;
8-634 . A = B-C;
8-635 . A = B-C;
8-636 . A = B+C;
8-637 . A = B*C;
8-638 .
8-639 . switch (ca stuff)
8-640 . {
8-641 . case one:
8-642 . {
8-643 . run_this;
8-644 . // missing break
8-645 . }
8-646 . case two:
8-647 . {
8-648 . run_this;
8-649 . break;
8-650 . }
8-651 . default:
8-652 . {
8-653 . SwError;
8-654 . }
8-655 . }
8-656 .
8-657 . A = B/C;
8-658 .
8-659 . if (A lt B)
8-660 . {
8-661 . A = B + C;
8-662 . D = E + F;
8-663 . }
8-664 .
8-665 . A = B/C;
8-666 . A = B+C;
8-667 . A = B+C;
8-668 . A = B-C;
8-669 . A = B/C;
8-670 . /* LE SV TOC-1138 this is a ca-08.6.24 req to call isr*/
8-671 .
8-672 . if (A < = B)
8-673 . {
8-674 . A = B + C;
8-675 . D = E + F;
8-676 . }
8-677 .
8-678 . A = B-C;
8-679 . A = B/C;
8-680 . /* LE SV TOC-1139 this is a ca-08.6.27 req to call admin*/
8-681 .
8-682 . if (A gt B)
8-683 . {
8-684 . A = B + C;
8-685 . D = E + F;
8-686 . }
8-687 .
8-688 . A = B+C;
8-689 . A = B+C;
8-690 .
8-691 . if (A < = B)
8-692 . {
8-693 . A = B + C;
8-694 . D = E + F;
8-695 . }
8-696 .
8-697 . A = B*C;
8-698 . A = B+C;
8-699 . A = B*C;
8-700 . A = B*C;
8-701 . A = 0x0003;
8-702 .
8-703 . if (A == B)
8-704 . {
8-705 . A = B + C;
8-706 . D = E + F;
8-707 . }
8-708 .
8-709 .
8-710 . if (A < B)
8-711 . {
8-712 . A = B + C;
8-713 . D = E + F;
8-714 . }
8-715 .
8-716 . A = B*C;
8-717 . A = B+C;
8-718 . A = B-C;
8-719 . A = B-C;
8-720 . A = B/C;
8-721 . A = B-C;
8-722 . A = B+C;
8-723 . A = B/C;
8-724 .
8-725 . if (A < = B)
8-726 . {
8-727 . A = B + C;
8-728 . D = E + F;
8-729 . }
8-730 .
8-731 . A = B+C;
8-732 .
8-733 . switch (ca stuff)
8-734 . {
8-735 . case one:
8-736 . {
8-737 . run_this;
8-738 . break;
8-739 . }
8-740 . case two:
8-741 . {
8-742 . run_this;
8-743 . break;
8-744 . }
8-745 . default:
8-746 . {
8-747 . SwError;
8-748 . }
8-749 . }
8-750 .
8-751 .
8-752 . if (A eq B)
8-753 . {
8-754 . A = B + C;
8-755 . D = E + F;
8-756 . }
8-757 .
8-758 . A = B-C;
8-759 .
8-760 . if (A > B)
8-761 . {
8-762 . A = B + C;
8-763 . D = E + F;
8-764 . }
8-765 .
8-766 . A = B+C;
8-767 .
8-768 . if (A eq B)
8-769 . {
8-770 . A = B + C;
8-771 . D = E + F;
8-772 . }
8-773 .
8-774 . A = B*C;
8-775 . A = B-C;
8-776 .
8-777 . if (A > B)
8-778 . {
8-779 . A = B + C;
8-780 . D = E + F;
8-781 . }
8-782 .
8-783 .
8-784 . if (A < B)
8-785 . {
8-786 . A = B + C;
8-787 . D = E + F;
8-788 . }
8-789 .
8-790 . A = B/C;
8-791 . A = B+C;
8-792 . A = B/C;
8-793 . A = B+C;
8-794 .
8-795 . if (A gt B)
8-796 . {
8-797 . A = B + C;
8-798 . D = E + F;
8-799 . }
8-800 .
8-801 . A = B*C;
8-802 . A = B-C;
8-803 . A = B/C;
8-804 . A = B*C;
8-805 . A = B+C;
8-806 . A = B/C;
8-807 . A = B+C;
8-808 .
8-809 . if (A gt B)
8-810 . {
8-811 . A = B + C;
8-812 . D = E + F;
8-813 . }
8-814 .
8-815 .
8-816 . if (A < B)
8-817 . {
8-818 . A = B + C;
8-819 . D = E + F;
8-820 . }
8-821 .
8-822 . A = B*C;
8-823 . A = B/C;
8-824 . A = B+C;
8-825 .
8-826 . if (A gt B)
8-827 . {
8-828 . A = B + C;
8-829 . D = E + F;
8-830 . }
8-831 .
8-832 . // max LOC 74
8-833 .
8-834 . }
8-835 .
8-836 .
8-837 . /*
8-838 . -----------------------------------------------------------------------------
8-839 . --| NAME: ca.8.7
8-840 . --|
8-841 . --| ABSTRACT:
8-842 . --| This function does ca stuff.
8-843 . --|
8-844 . --| RETURNS:
8-845 . --| NONE.
8-846 . --|
8-847 . ----------------------------------------------------------------------------
8-848 . */
8-849 . static void ca.8.7(void)
8-850 . {
8-851 . A = B/C;
8-852 . A = B+C;
8-853 .
8-854 . if (A < = B)
8-855 . {
8-856 . A = B + C;
8-857 . D = E + F;
8-858 . }
8-859 .
8-860 . A = B*C;
8-861 .
8-862 . if (A lt B)
8-863 . {
8-864 . A = B + C;
8-865 . D = E + F;
8-866 . }
8-867 .
8-868 . A = B*C;
8-869 .
8-870 . if (A > B)
8-871 . {
8-872 . A = B + C;
8-873 . D = E + F;
8-874 . }
8-875 .
8-876 . A = B+C;
8-877 .
8-878 . if (A le B)
8-879 . {
8-880 . A = B + C;
8-881 . D = E + F;
8-882 . }
8-883 .
8-884 . A = B-C;
8-885 . A = B/C;
8-886 . A = B+C;
8-887 . A = B/C;
8-888 . A = B+C;
8-889 . A = B*C;
8-890 .
8-891 . if (A < = B)
8-892 . {
8-893 . A = B + C;
8-894 . D = E + F;
8-895 . }
8-896 .
8-897 .
8-898 . if (A ge B)
8-899 . {
8-900 . A = B + C;
8-901 . D = E + F;
8-902 . }
8-903 .
8-904 . A = B*C;
8-905 .
8-906 . switch (ca stuff)
8-907 . {
8-908 . case one:
8-909 . {
8-910 . run_this;
8-911 . break;
8-912 . }
8-913 . case two:
8-914 . {
8-915 . run_this;
8-916 . break;
8-917 . }
8-918 . default:
8-919 . {
8-920 . SwError;
8-921 . }
8-922 . }
8-923 .
8-924 .
8-925 . if (A le B)
8-926 . {
8-927 . A = B + C;
8-928 . D = E + F;
8-929 . }
8-930 .
8-931 . A = B+C;
8-932 .
8-933 . if (A ne B)
8-934 . {
8-935 . A = B + C;
8-936 . D = E + F;
8-937 . }
8-938 .
8-939 . A = B/C;
8-940 . A = B+C;
8-941 .
8-942 . if (A le B)
8-943 . {
8-944 . A = B + C;
8-945 . D = E + F;
8-946 . }
8-947 .
8-948 . A = B/C;
8-949 . A = B/C;
8-950 . A = B/C;
8-951 .
8-952 . if (A == B)
8-953 . {
8-954 . A = B + C;
8-955 . D = E + F;
8-956 . }
8-957 .
8-958 .
8-959 . if {
8-960 . X = Y + Z;
8-961 . }
8-962 . else {
8-963 . halt;
8-964 . }
8-965 .
8-966 .
8-967 . if (A < B)
8-968 . {
8-969 . A = B + C;
8-970 . D = E + F;
8-971 . }
8-972 .
8-973 . A = B+C;
8-974 .
8-975 . if (A != B)
8-976 . {
8-977 . A = B + C;
8-978 . D = E + F;
8-979 . }
8-980 .
8-981 . A = B-C;
8-982 .
8-983 . if (A ge B)
8-984 . {
8-985 . A = B + C;
8-986 . D = E + F;
8-987 . }
8-988 .
8-989 .
8-990 . switch (ca stuff)
8-991 . {
8-992 . case one:
8-993 . {
8-994 . run_this;
8-995 . break;
8-996 . }
8-997 . case two:
8-998 . {
8-999 . run_this;
8-1000 . break;
8-1001 . }
8-1002 . default:
8-1003 . {
8-1004 . SwError;
8-1005 . }
8-1006 . }
8-1007 .
8-1008 . A = B+C;
8-1009 . A = B/C;
8-1010 . A = B/C;
8-1011 .
8-1012 . if (A < = B)
8-1013 . {
8-1014 . A = B + C;
8-1015 . D = E + F;
8-1016 . }
8-1017 .
8-1018 .
8-1019 . if (A ge B)
8-1020 . {
8-1021 . A = B + C;
8-1022 . D = E + F;
8-1023 . }
8-1024 .
8-1025 . A = B+C;
8-1026 . A = B+C;
8-1027 . A = B-C;
8-1028 . A = 0x0009;
8-1029 . A = B+C;
8-1030 . A = 0x0003;
8-1031 .
8-1032 . switch (ca stuff)
8-1033 . {
8-1034 . case one:
8-1035 . {
8-1036 . run_this;
8-1037 . break;
8-1038 . }
8-1039 . case two:
8-1040 . {
8-1041 . run_this;
8-1042 . break;
8-1043 . }
8-1044 . // missing default
8-1045 . }
8-1046 .
8-1047 . A = B-C;
8-1048 . A = B*C;
8-1049 . A = B*C;
8-1050 . A = B/C;
8-1051 . A = B*C;
8-1052 . A = B+C;
8-1053 . A = B/C;
8-1054 . // max LOC 51
8-1055 .
8-1056 . }
8-1057 .
8-1058 .
8-1059 . /*
8-1060 . -----------------------------------------------------------------------------
8-1061 . --| NAME: ca.8.8
8-1062 . --|
8-1063 . --| ABSTRACT:
8-1064 . --| This function does ca stuff.
8-1065 . --|
8-1066 . --| RETURNS:
8-1067 . --| NONE.
8-1068 . --|
8-1069 . ----------------------------------------------------------------------------
8-1070 . */
8-1071 . static void ca.8.8(void)
8-1072 . {
8-1073 . A = B+C;
8-1074 . /* LE SV TOC-1140 this is a ca-08.8.2 req to verify*/
8-1075 . A = B/C;
8-1076 . A = B*C;
8-1077 . A = B+C;
8-1078 . A = B*C;
8-1079 . A = B/C;
8-1080 .
8-1081 . if (A ne B)
8-1082 . {
8-1083 . A = B + C;
8-1084 . D = E + F;
8-1085 . }
8-1086 .
8-1087 .
8-1088 . if (A != B)
8-1089 . {
8-1090 . A = B + C;
8-1091 . D = E + F;
8-1092 . }
8-1093 .
8-1094 . A = B/C;
8-1095 . A = B*C;
8-1096 .
8-1097 . if (A < = B)
8-1098 . {
8-1099 . A = B + C;
8-1100 . D = E + F;
8-1101 . }
8-1102 .
8-1103 . A = B*C;
8-1104 .
8-1105 . if (A le B)
8-1106 . {
8-1107 . A = B + C;
8-1108 . D = E + F;
8-1109 . }
8-1110 .
8-1111 .
8-1112 . if (A != B)
8-1113 . {
8-1114 . A = B + C;
8-1115 . D = E + F;
8-1116 . }
8-1117 .
8-1118 . A = B+C;
8-1119 . A = B-C;
8-1120 . A = B+C;
8-1121 . A = B/C;
8-1122 . A = B/C;
8-1123 . /* LE SV TOC-1141 this is a ca-08.8.20 req to verify*/
8-1124 . A = B+C;
8-1125 . A = B-C;
8-1126 . /* LE SV TOC-1142 this is a ca-08.8.22 req to transform*/
8-1127 .
8-1128 . if (A ne B)
8-1129 . {
8-1130 . A = B + C;
8-1131 . D = E + F;
8-1132 . }
8-1133 .
8-1134 . A = B/C;
8-1135 . A = B+C;
8-1136 .
8-1137 . if (A == B)
8-1138 . {
8-1139 . A = B + C;
8-1140 . D = E + F;
8-1141 . }
8-1142 .
8-1143 . A = B/C;
8-1144 .
8-1145 . if (A eq B)
8-1146 . {
8-1147 . A = B + C;
8-1148 . D = E + F;
8-1149 . }
8-1150 .
8-1151 .
8-1152 . if (A > B)
8-1153 . {
8-1154 . A = B + C;
8-1155 . D = E + F;
8-1156 . }
8-1157 .
8-1158 .
8-1159 . if (A > B)
8-1160 . {
8-1161 . A = B + C;
8-1162 . D = E + F;
8-1163 . }
8-1164 .
8-1165 .
8-1166 . if (A == B)
8-1167 . {
8-1168 . A = B + C;
8-1169 . D = E + F;
8-1170 . }
8-1171 .
8-1172 . A = B-C;
8-1173 . A = B+C;
8-1174 .
8-1175 . switch (ca stuff)
8-1176 . {
8-1177 . case one:
8-1178 . {
8-1179 . run_this;
8-1180 . break;
8-1181 . }
8-1182 . case two:
8-1183 . {
8-1184 . run_this;
8-1185 . break;
8-1186 . }
8-1187 . default:
8-1188 . {
8-1189 . // missing error call
8-1190 . }
8-1191 . }
8-1192 .
8-1193 .
8-1194 . if (A gt B)
8-1195 . {
8-1196 . A = B + C;
8-1197 . D = E + F;
8-1198 . }
8-1199 .
8-1200 . A = B*C;
8-1201 .
8-1202 . if (A > B)
8-1203 . {
8-1204 . A = B + C;
8-1205 . D = E + F;
8-1206 . }
8-1207 .
8-1208 . A = B+C;
8-1209 . A = B/C;
8-1210 .
8-1211 . if (A < = B)
8-1212 . {
8-1213 . A = B + C;
8-1214 . D = E + F;
8-1215 . }
8-1216 .
8-1217 . A = B+C;
8-1218 . A = B+C;
8-1219 . A = B/C;
8-1220 . // max LOC 41
8-1221 .
8-1222 . }
8-1223 .
8-1224 .
8-1225 . /*
8-1226 . -----------------------------------------------------------------------------
8-1227 . --| NAME: ca.8.9
8-1228 . --|
8-1229 . --| ABSTRACT:
8-1230 . --| This function does ca stuff.
8-1231 . --|
8-1232 . --| RETURNS:
8-1233 . --| NONE.
8-1234 . --|
8-1235 . ----------------------------------------------------------------------------
8-1236 . */
8-1237 . static void ca.8.9(void)
8-1238 . {
8-1239 .
8-1240 . if (A ne B)
8-1241 . {
8-1242 . A = B + C;
8-1243 . D = E + F;
8-1244 . }
8-1245 .
8-1246 . A = B*C;
8-1247 . A = B+C;
8-1248 .
8-1249 . if (A le B)
8-1250 . {
8-1251 . A = B + C;
8-1252 . D = E + F;
8-1253 . }
8-1254 .
8-1255 . A = B-C;
8-1256 . A = B+C;
8-1257 . A = B*C;
8-1258 . A = B-C;
8-1259 . A = B/C;
8-1260 .
8-1261 . switch (ca stuff)
8-1262 . {
8-1263 . case one:
8-1264 . {
8-1265 . run_this;
8-1266 . break;
8-1267 . }
8-1268 . case two:
8-1269 . {
8-1270 . run_this;
8-1271 . break;
8-1272 . }
8-1273 . default:
8-1274 . {
8-1275 . SwError;
8-1276 . }
8-1277 . }
8-1278 .
8-1279 . A = B/C;
8-1280 .
8-1281 . if (A == B)
8-1282 . {
8-1283 . A = B + C;
8-1284 . D = E + F;
8-1285 . }
8-1286 .
8-1287 . A = B*C;
8-1288 . // max LOC 13
8-1289 .
8-1290 . }
8-1291 .
8-1292 .
8-1293 . /*
8-1294 . -----------------------------------------------------------------------------
8-1295 . --| NAME: ca.8.10
8-1296 . --|
8-1297 . --| ABSTRACT:
8-1298 . --| This function does ca stuff.
8-1299 . --|
8-1300 . --| RETURNS:
8-1301 . --| NONE.
8-1302 . --|
8-1303 . ----------------------------------------------------------------------------
8-1304 . */
8-1305 . static void ca.8.10(void)
8-1306 . {
8-1307 . A = B/C;
8-1308 .
8-1309 . if (A le B)
8-1310 . {
8-1311 . A = B + C;
8-1312 . D = E + F;
8-1313 . }
8-1314 .
8-1315 . A = B/C;
8-1316 . A = B-C;
8-1317 . A = B-C;
8-1318 . A = B+C;
8-1319 .
8-1320 . if (A ge B)
8-1321 . {
8-1322 . A = B + C;
8-1323 . D = E + F;
8-1324 . }
8-1325 .
8-1326 . A = 0x0003;
8-1327 . A = B/C;
8-1328 . A = B-C;
8-1329 . A = B*C;
8-1330 . A = B/C;
8-1331 . A = B+C;
8-1332 . A = B-C;
8-1333 . A = B/C;
8-1334 . A = B/C;
8-1335 . A = B+C;
8-1336 . A = B+C;
8-1337 . A = B*C;
8-1338 . // max LOC 18
8-1339 .
8-1340 . }
8-1341 .
8-1342 .
8-1343 . /*
8-1344 . -----------------------------------------------------------------------------
8-1345 . --| NAME: ca.8.11
8-1346 . --|
8-1347 . --| ABSTRACT:
8-1348 . --| This function does ca stuff.
8-1349 . --|
8-1350 . --| RETURNS:
8-1351 . --| NONE.
8-1352 . --|
8-1353 . ----------------------------------------------------------------------------
8-1354 . */
8-1355 . static void ca.8.11(void)
8-1356 . {
8-1357 . A = B*C;
8-1358 . /* LE SV TOC-1143 this is a ca-08.11.2 req to reject*/
8-1359 .
8-1360 . if (A == B)
8-1361 . {
8-1362 . A = B + C;
8-1363 . D = E + F;
8-1364 . }
8-1365 .
8-1366 . /* LE SV TOC-1144 this is a ca-08.11.3 req to audit*/
8-1367 . A = B+C;
8-1368 . A = B*C;
8-1369 . A = B*C;
8-1370 . A = B/C;
8-1371 .
8-1372 . if (A eq B)
8-1373 . {
8-1374 . A = B + C;
8-1375 . D = E + F;
8-1376 . }
8-1377 .
8-1378 .
8-1379 . if (A gt B)
8-1380 . {
8-1381 . A = B + C;
8-1382 . D = E + F;
8-1383 . }
8-1384 .
8-1385 . A = B+C;
8-1386 . A = B-C;
8-1387 .
8-1388 . if (A ne B)
8-1389 . {
8-1390 . A = B + C;
8-1391 . D = E + F;
8-1392 . }
8-1393 .
8-1394 . A = B-C;
8-1395 . A = B-C;
8-1396 . A = B/C;
8-1397 .
8-1398 . switch (ca stuff)
8-1399 . {
8-1400 . case one:
8-1401 . {
8-1402 . run_this;
8-1403 . break;
8-1404 . }
8-1405 . case two:
8-1406 . {
8-1407 . run_this;
8-1408 . break;
8-1409 . }
8-1410 . default:
8-1411 . {
8-1412 . SwError;
8-1413 . }
8-1414 . }
8-1415 .
8-1416 .
8-1417 . if (A > = B)
8-1418 . {
8-1419 . A = B + C;
8-1420 . D = E + F;
8-1421 . }
8-1422 .
8-1423 . A = B+C;
8-1424 .
8-1425 . if (A lt B)
8-1426 . {
8-1427 . A = B + C;
8-1428 . D = E + F;
8-1429 . }
8-1430 .
8-1431 . A = B/C;
8-1432 .
8-1433 . if (A lt B)
8-1434 . {
8-1435 . A = B + C;
8-1436 . D = E + F;
8-1437 . }
8-1438 .
8-1439 . A = B/C;
8-1440 . A = B+C;
8-1441 . /* LE SV TOC-1145 this is a ca-08.11.23 req to verify*/
8-1442 . A = B+C;
8-1443 . A = B-C;
8-1444 . A = B/C;
8-1445 . A = B+C;
8-1446 .
8-1447 . if (A eq B)
8-1448 . {
8-1449 . A = B + C;
8-1450 . D = E + F;
8-1451 . }
8-1452 .
8-1453 .
8-1454 . if (A le B)
8-1455 . {
8-1456 . A = B + C;
8-1457 . D = E + F;
8-1458 . }
8-1459 .
8-1460 . A = 0x0009;
8-1461 . A = B/C;
8-1462 . A = B*C;
8-1463 .
8-1464 . if (A ne B)
8-1465 . {
8-1466 . A = B + C;
8-1467 . D = E + F;
8-1468 . }
8-1469 .
8-1470 . A = 0x0001;
8-1471 . A = B*C;
8-1472 .
8-1473 . if (A > B)
8-1474 . {
8-1475 . A = B + C;
8-1476 . D = E + F;
8-1477 . }
8-1478 .
8-1479 .
8-1480 . if (A < B)
8-1481 . {
8-1482 . A = B + C;
8-1483 . D = E + F;
8-1484 . }
8-1485 .
8-1486 . A = B-C;
8-1487 . A = B-C;
8-1488 .
8-1489 . if (A lt B)
8-1490 . {
8-1491 . A = B + C;
8-1492 . D = E + F;
8-1493 . }
8-1494 .
8-1495 .
8-1496 . switch (ca stuff)
8-1497 . {
8-1498 . case one:
8-1499 . {
8-1500 . run_this;
8-1501 . break;
8-1502 . }
8-1503 . case two:
8-1504 . {
8-1505 . run_this;
8-1506 . break;
8-1507 . }
8-1508 . default:
8-1509 . {
8-1510 . SwError;
8-1511 . }
8-1512 . }
8-1513 .
8-1514 . A = B+C;
8-1515 . A = B-C;
8-1516 .
8-1517 . if (A > = B)
8-1518 . {
8-1519 . A = B + C;
8-1520 . D = E + F;
8-1521 . }
8-1522 .
8-1523 .
8-1524 . if (A ne B)
8-1525 . {
8-1526 . A = B + C;
8-1527 . D = E + F;
8-1528 . }
8-1529 .
8-1530 . A = B/C;
8-1531 . A = B/C;
8-1532 . A = B+C;
8-1533 . // max LOC 45
8-1534 .
8-1535 . }
8-1536 .
8-1537 .
8-1538 . /*
8-1539 . -----------------------------------------------------------------------------
8-1540 . --| NAME: ca.8.12
8-1541 . --|
8-1542 . --| ABSTRACT:
8-1543 . --| This function does ca stuff.
8-1544 . --|
8-1545 . --| RETURNS:
8-1546 . --| NONE.
8-1547 . --|
8-1548 . ----------------------------------------------------------------------------
8-1549 . */
8-1550 . static void ca.8.12(void)
8-1551 . {
8-1552 . A = B*C;
8-1553 . A = 0x0008;
8-1554 . A = B+C;
8-1555 .
8-1556 . if (A gt B)
8-1557 . {
8-1558 . A = B + C;
8-1559 . D = E + F;
8-1560 . }
8-1561 .
8-1562 . A = B*C;
8-1563 . A = B*C;
8-1564 . A = B*C;
8-1565 . A = B+C;
8-1566 .
8-1567 . if (A < B)
8-1568 . {
8-1569 . A = B + C;
8-1570 . D = E + F;
8-1571 . }
8-1572 .
8-1573 . A = B/C;
8-1574 . // ??? go see ws
8-1575 . A = B*C;
8-1576 . /* LE SV TOC-1146 this is a ca-08.12.11 req to store*/
8-1577 .
8-1578 . if (A == B)
8-1579 . {
8-1580 . A = B + C;
8-1581 . D = E + F;
8-1582 . }
8-1583 .
8-1584 .
8-1585 . if (A ge B)
8-1586 . {
8-1587 . A = B + C;
8-1588 . D = E + F;
8-1589 . }
8-1590 .
8-1591 . /* LE SV TOC-1147 this is a ca-08.12.13 req to update*/
8-1592 . A = B*C;
8-1593 .
8-1594 . if (A < = B)
8-1595 . {
8-1596 . A = B + C;
8-1597 . D = E + F;
8-1598 . }
8-1599 .
8-1600 . A = B*C;
8-1601 . A = B/C;
8-1602 . A = B-C;
8-1603 .
8-1604 . if (A le B)
8-1605 . {
8-1606 . A = B + C;
8-1607 . D = E + F;
8-1608 . }
8-1609 .
8-1610 . A = B-C;
8-1611 .
8-1612 . if (A < = B)
8-1613 . {
8-1614 . A = B + C;
8-1615 . D = E + F;
8-1616 . }
8-1617 .
8-1618 . A = B/C;
8-1619 . A = B*C;
8-1620 .
8-1621 . if (A > B)
8-1622 . {
8-1623 . A = B + C;
8-1624 . D = E + F;
8-1625 . }
8-1626 .
8-1627 . A = B+C;
8-1628 . A = B-C;
8-1629 .
8-1630 . if (A lt B)
8-1631 . {
8-1632 . A = B + C;
8-1633 . D = E + F;
8-1634 . }
8-1635 .
8-1636 .
8-1637 . switch (ca stuff)
8-1638 . {
8-1639 . case one:
8-1640 . {
8-1641 . run_this;
8-1642 . break;
8-1643 . }
8-1644 . case two:
8-1645 . {
8-1646 . run_this;
8-1647 . break;
8-1648 . }
8-1649 . default:
8-1650 . {
8-1651 . SwError;
8-1652 . }
8-1653 . }
8-1654 .
8-1655 . A = B/C;
8-1656 .
8-1657 . if (A != B)
8-1658 . {
8-1659 . A = B + C;
8-1660 . D = E + F;
8-1661 . }
8-1662 .
8-1663 . A = B-C;
8-1664 . A = B-C;
8-1665 . A = B+C;
8-1666 . /* LE SV TOC-1148 this is a ca-08.12.33 req to check unix*/
8-1667 . A = B-C;
8-1668 . A = B/C;
8-1669 .
8-1670 . if (A ge B)
8-1671 . {
8-1672 . A = B + C;
8-1673 . D = E + F;
8-1674 . }
8-1675 .
8-1676 . A = B*C;
8-1677 . A = B/C;
8-1678 .
8-1679 . if (A lt B)
8-1680 . {
8-1681 . A = B + C;
8-1682 . D = E + F;
8-1683 . }
8-1684 .
8-1685 .
8-1686 . if (A lt B)
8-1687 . {
8-1688 . A = B + C;
8-1689 . D = E + F;
8-1690 . }
8-1691 .
8-1692 . A = B/C;
8-1693 .
8-1694 . if (A > B)
8-1695 . {
8-1696 . A = B + C;
8-1697 . D = E + F;
8-1698 . }
8-1699 .
8-1700 . /* LE SV TOC-1149 this is a ca-08.12.42 req to reject*/
8-1701 . A = B+C;
8-1702 . A = 0x0006;
8-1703 .
8-1704 . if (A gt B)
8-1705 . {
8-1706 . A = B + C;
8-1707 . D = E + F;
8-1708 . }
8-1709 .
8-1710 . A = B+C;
8-1711 . A = B/C;
8-1712 . A = B+C;
8-1713 . // max LOC 46
8-1714 .
8-1715 . }
8-1716 .
8 8 Result: result/source/pr-app/pr-app-CA123/ca/ca-08.c
9 9 Source: source/pr-app/pr-app-CA123/ca/ca-09.c
9-0 .
9-1 .
9-2 . #include A;
9-3 . #define A;
9-4 . float B;
9-5 . #include B;
9-6 . #define B;
9-7 .
9-8 .
9-9 .
9-10 . /*
9-11 . -----------------------------------------------------------------------------
9-12 . --| NAME: ca.9.1
9-13 . --|
9-14 . --| ABSTRACT:
9-15 . --| This function does ca stuff.
9-16 . --|
9-17 . --| RETURNS:
9-18 . --| NONE.
9-19 . --|
9-20 . ----------------------------------------------------------------------------
9-21 . */
9-22 . static void ca.9.1(void)
9-23 . {
9-24 . A = B/C;
9-25 . A = B*C;
9-26 . do forever;
9-27 .
9-28 . if (A < = B)
9-29 . {
9-30 . A = B + C;
9-31 . D = E + F;
9-32 . }
9-33 .
9-34 . A = B/C;
9-35 .
9-36 . if (A < B)
9-37 . {
9-38 . A = B + C;
9-39 . D = E + F;
9-40 . }
9-41 .
9-42 . /* LE SV TOC-1150 this is a ca-09.1.6 req to increment*/
9-43 .
9-44 . if (A != B)
9-45 . {
9-46 . A = B + C;
9-47 . D = E + F;
9-48 . }
9-49 .
9-50 . A = B/C;
9-51 . A = B/C;
9-52 . // TBD - what do I do now
9-53 . A = B/C;
9-54 . A = B+C;
9-55 .
9-56 . switch (ca stuff)
9-57 . {
9-58 . case:
9-59 . case:
9-60 . // stacked case statements but only if there is a new line in between
9-61 .
9-62 . case:
9-63 . case:
9-64 . case:
9-65 . {
9-66 . run_this;
9-67 . break;
9-68 . }
9-69 . default:
9-70 . {
9-71 . halt;
9-72 . }
9-73 . }
9-74 .
9-75 .
9-76 . if (A < B)
9-77 . {
9-78 . A = B + C;
9-79 . D = E + F;
9-80 . }
9-81 .
9-82 . A = B*C;
9-83 .
9-84 . if (A eq B)
9-85 . {
9-86 . A = B + C;
9-87 . D = E + F;
9-88 . }
9-89 .
9-90 .
9-91 . switch (ca stuff)
9-92 . {
9-93 . case one:
9-94 . {
9-95 . run_this;
9-96 . break;
9-97 . }
9-98 . case two:
9-99 . {
9-100 . run_this;
9-101 . break;
9-102 . }
9-103 . default:
9-104 . {
9-105 . SwError;
9-106 . }
9-107 . }
9-108 .
9-109 . A = B/C;
9-110 .
9-111 . if (A lt B)
9-112 . {
9-113 . A = B + C;
9-114 . D = E + F;
9-115 . }
9-116 .
9-117 . A = B-C;
9-118 . A = B+C;
9-119 . A = B/C;
9-120 . A = B/C;
9-121 . /* LE SV TOC-1151 this is a ca-09.1.21 req to compare*/
9-122 .
9-123 . if (A le B)
9-124 . {
9-125 . A = B + C;
9-126 . D = E + F;
9-127 . }
9-128 .
9-129 . A = B*C;
9-130 .
9-131 . switch (ca stuff)
9-132 . {
9-133 . case one:
9-134 . {
9-135 . run_this;
9-136 . break;
9-137 . }
9-138 . case two:
9-139 . {
9-140 . run_this;
9-141 . break;
9-142 . }
9-143 . default:
9-144 . {
9-145 . SwError;
9-146 . }
9-147 . }
9-148 .
9-149 . A = B-C;
9-150 . A = B+C;
9-151 . do forever;
9-152 . A = B-C;
9-153 . A = 0x0003;
9-154 .
9-155 . if (A != B)
9-156 . {
9-157 . A = B + C;
9-158 . D = E + F;
9-159 . }
9-160 .
9-161 . A = B*C;
9-162 .
9-163 . if (A gt B)
9-164 . {
9-165 . A = B + C;
9-166 . D = E + F;
9-167 . }
9-168 .
9-169 . A = B-C;
9-170 . A = B/C;
9-171 . A = B/C;
9-172 . A = B+C;
9-173 . A = B/C;
9-174 . // max LOC 34
9-175 .
9-176 . }
9-177 .
9-178 .
9-179 . /*
9-180 . -----------------------------------------------------------------------------
9-181 . --| NAME: ca.9.2
9-182 . --|
9-183 . --| ABSTRACT:
9-184 . --| This function does ca stuff.
9-185 . --|
9-186 . --| RETURNS:
9-187 . --| NONE.
9-188 . --|
9-189 . ----------------------------------------------------------------------------
9-190 . */
9-191 . static void ca.9.2(void)
9-192 . {
9-193 . A = B-C;
9-194 .
9-195 . if (A != B)
9-196 . {
9-197 . A = B + C;
9-198 . D = E + F;
9-199 . }
9-200 .
9-201 . A = B/C;
9-202 .
9-203 . if (A eq B)
9-204 . {
9-205 . A = B + C;
9-206 . D = E + F;
9-207 . }
9-208 .
9-209 .
9-210 . if (A < = B)
9-211 . {
9-212 . A = B + C;
9-213 . D = E + F;
9-214 . }
9-215 .
9-216 .
9-217 . /*
9-218 . dead_code = B - C;
9-219 . dead_code = D - E;
9-220 . dead_code = F - G;
9-221 . */
9-222 .
9-223 .
9-224 . if (A lt B)
9-225 . {
9-226 . A = B + C;
9-227 . D = E + F;
9-228 . }
9-229 .
9-230 . A = B+C;
9-231 . A = B*C;
9-232 . A = B-C;
9-233 . A = B/C;
9-234 . A = B-C;
9-235 .
9-236 . if (A < B)
9-237 . {
9-238 . A = B + C;
9-239 . D = E + F;
9-240 . }
9-241 .
9-242 .
9-243 . if (A ge B)
9-244 . {
9-245 . A = B + C;
9-246 . D = E + F;
9-247 . }
9-248 .
9-249 .
9-250 . if (A lt B)
9-251 . {
9-252 . A = B + C;
9-253 . D = E + F;
9-254 . }
9-255 .
9-256 . A = B+C;
9-257 . A = B/C;
9-258 .
9-259 . if (A ge B)
9-260 . {
9-261 . A = B + C;
9-262 . D = E + F;
9-263 . }
9-264 .
9-265 . A = B*C;
9-266 .
9-267 . if (A ne B)
9-268 . {
9-269 . A = B + C;
9-270 . D = E + F;
9-271 . }
9-272 .
9-273 . A = B-C;
9-274 . A = B+C;
9-275 . A = B/C;
9-276 . A = B/C;
9-277 . A = B-C;
9-278 .
9-279 . if (A != B)
9-280 . {
9-281 . A = B + C;
9-282 . D = E + F;
9-283 . }
9-284 .
9-285 . A = B-C;
9-286 .
9-287 . if (A le B)
9-288 . {
9-289 . A = B + C;
9-290 . D = E + F;
9-291 . }
9-292 .
9-293 . /* LE SV TOC-1152 this is a ca-09.2.28 req to call admin*/
9-294 . A = B-C;
9-295 . A = B-C;
9-296 . A = B-C;
9-297 . A = B+C;
9-298 . A = B+C;
9-299 . A = B/C;
9-300 . A = B-C;
9-301 .
9-302 . if (A eq B)
9-303 . {
9-304 . A = B + C;
9-305 . D = E + F;
9-306 . }
9-307 .
9-308 . A = B/C;
9-309 .
9-310 . if (A eq B)
9-311 . {
9-312 . A = B + C;
9-313 . D = E + F;
9-314 . }
9-315 .
9-316 .
9-317 . if (A lt B)
9-318 . {
9-319 . A = B + C;
9-320 . D = E + F;
9-321 . }
9-322 .
9-323 . A = B*C;
9-324 . A = B-C;
9-325 . A = B-C;
9-326 . A = B-C;
9-327 . A = B/C;
9-328 . A = B-C;
9-329 . A = B/C;
9-330 .
9-331 . switch (ca stuff)
9-332 . {
9-333 . case one:
9-334 . {
9-335 . run_this;
9-336 . break;
9-337 . }
9-338 . case two:
9-339 . {
9-340 . run_this;
9-341 . break;
9-342 . }
9-343 . default:
9-344 . {
9-345 . // missing error call
9-346 . }
9-347 . }
9-348 .
9-349 . A = B/C;
9-350 . A = 0x0003;
9-351 . A = B+C;
9-352 .
9-353 . if (A eq B)
9-354 . {
9-355 . A = B + C;
9-356 . D = E + F;
9-357 . }
9-358 .
9-359 . A = B+C;
9-360 .
9-361 . if (A gt B)
9-362 . {
9-363 . A = B + C;
9-364 . D = E + F;
9-365 . }
9-366 .
9-367 . A = B/C;
9-368 .
9-369 . if (A lt B)
9-370 . {
9-371 . A = B + C;
9-372 . D = E + F;
9-373 . }
9-374 .
9-375 .
9-376 . #ifdef LAZY
9-377 . // this is not nice
9-378 . A = B + C;
9-379 . A = B + C;
9-380 . #endif
9-381 .
9-382 . A = B/C;
9-383 . A = B*C;
9-384 .
9-385 . if (A eq B)
9-386 . {
9-387 . A = B + C;
9-388 . D = E + F;
9-389 . }
9-390 .
9-391 . A = B+C;
9-392 . A = B*C;
9-393 .
9-394 . if (A > = B)
9-395 . {
9-396 . A = B + C;
9-397 . D = E + F;
9-398 . }
9-399 .
9-400 . A = B/C;
9-401 . A = B/C;
9-402 .
9-403 . if (A == B)
9-404 . {
9-405 . A = B + C;
9-406 . D = E + F;
9-407 . }
9-408 .
9-409 . A = B*C;
9-410 . A = B*C;
9-411 . A = B-C;
9-412 . A = B/C;
9-413 . A = B-C;
9-414 . A = B+C;
9-415 .
9-416 . if (A ne B)
9-417 . {
9-418 . A = B + C;
9-419 . D = E + F;
9-420 . }
9-421 .
9-422 . A = B-C;
9-423 .
9-424 . if (A ne B)
9-425 . {
9-426 . A = B + C;
9-427 . D = E + F;
9-428 . }
9-429 .
9-430 . A = B-C;
9-431 . A = B*C;
9-432 . // max LOC 72
9-433 .
9-434 . }
9-435 .
9-436 .
9-437 . /*
9-438 . -----------------------------------------------------------------------------
9-439 . --| NAME: ca.9.3
9-440 . --|
9-441 . --| ABSTRACT:
9-442 . --| This function does ca stuff.
9-443 . --|
9-444 . --| RETURNS:
9-445 . --| NONE.
9-446 . --|
9-447 . ----------------------------------------------------------------------------
9-448 . */
9-449 . static void ca.9.3(void)
9-450 . {
9-451 . A = B/C;
9-452 . A = B/C;
9-453 . A = B-C;
9-454 .
9-455 . if (A < B)
9-456 . {
9-457 . A = B + C;
9-458 . D = E + F;
9-459 . }
9-460 .
9-461 . A = B*C;
9-462 . A = B*C;
9-463 . A = B/C;
9-464 . A = B*C;
9-465 . A = B/C;
9-466 . A = B/C;
9-467 . A = B/C;
9-468 . A = B/C;
9-469 .
9-470 . switch (ca stuff)
9-471 . {
9-472 . case one:
9-473 . {
9-474 . run_this;
9-475 . break;
9-476 . }
9-477 . case two:
9-478 . {
9-479 . run_this;
9-480 . break;
9-481 . }
9-482 . default:
9-483 . {
9-484 . SwError;
9-485 . }
9-486 . }
9-487 .
9-488 .
9-489 . if (A ne B)
9-490 . {
9-491 . A = B + C;
9-492 . D = E + F;
9-493 . }
9-494 .
9-495 .
9-496 . if (A == B)
9-497 . {
9-498 . A = B + C;
9-499 . D = E + F;
9-500 . }
9-501 .
9-502 . A = B-C;
9-503 . A = B/C;
9-504 . A = B-C;
9-505 . A = B/C;
9-506 . A = B-C;
9-507 .
9-508 . if (A > = B)
9-509 . {
9-510 . A = B + C;
9-511 . D = E + F;
9-512 . }
9-513 .
9-514 . A = B*C;
9-515 . A = B/C;
9-516 . A = B/C;
9-517 . A = B-C;
9-518 . A = B+C;
9-519 . A = B*C;
9-520 .
9-521 . if (A == B)
9-522 . {
9-523 . A = B + C;
9-524 . D = E + F;
9-525 . }
9-526 .
9-527 .
9-528 . if (A ge B)
9-529 . {
9-530 . A = B + C;
9-531 . D = E + F;
9-532 . }
9-533 .
9-534 .
9-535 . if (A < B)
9-536 . {
9-537 . A = B + C;
9-538 . D = E + F;
9-539 . }
9-540 .
9-541 . A = B/C;
9-542 . A = B/C;
9-543 . A = B*C;
9-544 .
9-545 . if (A le B)
9-546 . {
9-547 . A = B + C;
9-548 . D = E + F;
9-549 . }
9-550 .
9-551 . A = B-C;
9-552 . A = B*C;
9-553 . A = B+C;
9-554 .
9-555 . /* dead_block = C * D;
9-556 . dead_block = E * F; */
9-557 .
9-558 . A = B/C;
9-559 . A = B/C;
9-560 .
9-561 . if (A ne B)
9-562 . {
9-563 . A = B + C;
9-564 . D = E + F;
9-565 . }
9-566 .
9-567 . A = B+C;
9-568 . A = B-C;
9-569 .
9-570 . if (A le B)
9-571 . {
9-572 . A = B + C;
9-573 . D = E + F;
9-574 . }
9-575 .
9-576 . rcv_buffer = (U16 *) alloc(size+1);
9-577 . A = B-C;
9-578 . A = B-C;
9-579 .
9-580 . if (A > B)
9-581 . {
9-582 . A = B + C;
9-583 . D = E + F;
9-584 . }
9-585 .
9-586 . A = B-C;
9-587 . A = B/C;
9-588 .
9-589 . if (A < B)
9-590 . {
9-591 . A = B + C;
9-592 . D = E + F;
9-593 . }
9-594 .
9-595 . // max LOC 49
9-596 .
9-597 . }
9-598 .
9-599 .
9-600 . /*
9-601 . -----------------------------------------------------------------------------
9-602 . --| NAME: ca.9.4
9-603 . --|
9-604 . --| ABSTRACT:
9-605 . --| This function does ca stuff.
9-606 . --|
9-607 . --| RETURNS:
9-608 . --| NONE.
9-609 . --|
9-610 . ----------------------------------------------------------------------------
9-611 . */
9-612 . static void ca.9.4(void)
9-613 . {
9-614 . A = B+C;
9-615 . A = B-C;
9-616 . A = B+C;
9-617 . A = B*C;
9-618 . A = B*C;
9-619 . A = B/C;
9-620 .
9-621 . if (A gt B)
9-622 . {
9-623 . A = B + C;
9-624 . D = E + F;
9-625 . }
9-626 .
9-627 . A = B*C;
9-628 .
9-629 . switch (ca stuff)
9-630 . {
9-631 . case one:
9-632 . {
9-633 . run_this;
9-634 . break;
9-635 . }
9-636 . case two:
9-637 . {
9-638 . run_this;
9-639 . break;
9-640 . }
9-641 . default:
9-642 . {
9-643 . // missing error call
9-644 . }
9-645 . }
9-646 .
9-647 .
9-648 . if (A eq B)
9-649 . {
9-650 . A = B + C;
9-651 . D = E + F;
9-652 . }
9-653 .
9-654 . A = B-C;
9-655 . A = B*C;
9-656 . A = B/C;
9-657 . A = B/C;
9-658 . A = B+C;
9-659 . /* LE SV TOC-1153 this is a ca-09.4.15 req to assign*/
9-660 . A = B*C;
9-661 . A = B-C;
9-662 . free(FreePtr);
9-663 . A = B/C;
9-664 .
9-665 . if (A > = B)
9-666 . {
9-667 . A = B + C;
9-668 . D = E + F;
9-669 . }
9-670 .
9-671 . A = B*C;
9-672 . A = B*C;
9-673 . A = B/C;
9-674 . A = B*C;
9-675 . /* LE SV TOC-1154 this is a ca-09.4.23 req to transform*/
9-676 .
9-677 . if (A eq B)
9-678 . {
9-679 . A = B + C;
9-680 . D = E + F;
9-681 . }
9-682 .
9-683 . A = B-C;
9-684 . A = B*C;
9-685 . A = B-C;
9-686 .
9-687 . if (A < = B)
9-688 . {
9-689 . A = B + C;
9-690 . D = E + F;
9-691 . }
9-692 .
9-693 .
9-694 . if (A eq B)
9-695 . {
9-696 . A = B + C;
9-697 . D = E + F;
9-698 . }
9-699 .
9-700 . A = B-C;
9-701 . A = B-C;
9-702 . A = B*C;
9-703 .
9-704 . if (A < B)
9-705 . {
9-706 . A = B + C;
9-707 . D = E + F;
9-708 . }
9-709 .
9-710 .
9-711 . if (A le B)
9-712 . {
9-713 . A = B + C;
9-714 . D = E + F;
9-715 . }
9-716 .
9-717 .
9-718 . if (A ne B)
9-719 . {
9-720 . A = B + C;
9-721 . D = E + F;
9-722 . }
9-723 .
9-724 . A = B+C;
9-725 .
9-726 . if (A gt B)
9-727 . {
9-728 . A = B + C;
9-729 . D = E + F;
9-730 . }
9-731 .
9-732 . A = B/C;
9-733 . A = B*C;
9-734 . A = B*C;
9-735 . A = B/C;
9-736 . A = B+C;
9-737 . A = B-C;
9-738 . A = B/C;
9-739 .
9-740 . switch (ca stuff)
9-741 . {
9-742 . case one:
9-743 . {
9-744 . switch (nested)
9-745 . {
9-746 . case:
9-747 . X = Y + Z;
9-748 . case:
9-749 . X = Y + Z;
9-750 . default:
9-751 . SwError;
9-752 . }
9-753 . }
9-754 . case two:
9-755 . {
9-756 . run_this;
9-757 . break;
9-758 . }
9-759 . default:
9-760 . {
9-761 . SwError;
9-762 . }
9-763 . }
9-764 .
9-765 .
9-766 . switch (ca stuff)
9-767 . {
9-768 . case one:
9-769 . {
9-770 . run_this;
9-771 . break;
9-772 . }
9-773 . case two:
9-774 . {
9-775 . run_this;
9-776 . break;
9-777 . }
9-778 . default:
9-779 . {
9-780 . SwError;
9-781 . }
9-782 . }
9-783 .
9-784 . A = B+C;
9-785 . A = B/C;
9-786 . // max LOC 46
9-787 .
9-788 . }
9-789 .
9-790 .
9-791 . /*
9-792 . -----------------------------------------------------------------------------
9-793 . --| NAME: ca.9.5
9-794 . --|
9-795 . --| ABSTRACT:
9-796 . --| This function does ca stuff.
9-797 . --|
9-798 . --| RETURNS:
9-799 . --| NONE.
9-800 . --|
9-801 . ----------------------------------------------------------------------------
9-802 . */
9-803 . static void ca.9.5(void)
9-804 . {
9-805 .
9-806 . if ($ca stuff > $otherca stuff)
9-807 . /* LE SV TOC-008 we really should log all error calls */
9-808 . {
9-809 . A = B + C;
9-810 . }
9-811 .
9-812 . A = B*C;
9-813 . A = B*C;
9-814 .
9-815 . if (A ne B)
9-816 . {
9-817 . A = B + C;
9-818 . D = E + F;
9-819 . }
9-820 .
9-821 . A = B/C;
9-822 . A = B/C;
9-823 . A = B+C;
9-824 . A = B/C;
9-825 . A = B/C;
9-826 .
9-827 . if (A le B)
9-828 . {
9-829 . A = B + C;
9-830 . D = E + F;
9-831 . }
9-832 .
9-833 . A = B+C;
9-834 .
9-835 . if (A > = B)
9-836 . {
9-837 . A = B + C;
9-838 . D = E + F;
9-839 . }
9-840 .
9-841 . A = B/C;
9-842 . A = B/C;
9-843 . A = B/C;
9-844 .
9-845 . switch (ca stuff)
9-846 . {
9-847 . case one:
9-848 . {
9-849 . run_this;
9-850 . break;
9-851 . }
9-852 . case two:
9-853 . {
9-854 . run_this;
9-855 . break;
9-856 . }
9-857 . default:
9-858 . {
9-859 . SwError;
9-860 . }
9-861 . }
9-862 .
9-863 .
9-864 . if (A eq B)
9-865 . {
9-866 . A = B + C;
9-867 . D = E + F;
9-868 . }
9-869 .
9-870 .
9-871 . if (A < = B)
9-872 . {
9-873 . A = B + C;
9-874 . D = E + F;
9-875 . }
9-876 .
9-877 . A = B/C;
9-878 .
9-879 . if (A ne B)
9-880 . {
9-881 . A = B + C;
9-882 . D = E + F;
9-883 . }
9-884 .
9-885 .
9-886 . if (A < B)
9-887 . {
9-888 . A = B + C;
9-889 . D = E + F;
9-890 . }
9-891 .
9-892 . /* LE SV TOC-1155 this is a ca-09.5.21 req to disable*/
9-893 . A = B+C;
9-894 . A = B*C;
9-895 . A = B-C;
9-896 .
9-897 . if (A gt B)
9-898 . {
9-899 . A = B + C;
9-900 . D = E + F;
9-901 . }
9-902 .
9-903 .
9-904 . if (A < = B)
9-905 . {
9-906 . A = B + C;
9-907 . D = E + F;
9-908 . }
9-909 .
9-910 . A = B/C;
9-911 .
9-912 . if (A > B)
9-913 . {
9-914 . A = B + C;
9-915 . D = E + F;
9-916 . }
9-917 .
9-918 . A = B+C;
9-919 . A = B/C;
9-920 . A = B*C;
9-921 .
9-922 . if (A le B)
9-923 . {
9-924 . A = B + C;
9-925 . D = E + F;
9-926 . }
9-927 .
9-928 .
9-929 . if (A > = B)
9-930 . {
9-931 . A = B + C;
9-932 . D = E + F;
9-933 . }
9-934 .
9-935 . A = B-C;
9-936 .
9-937 . if (A != B)
9-938 . {
9-939 . A = B + C;
9-940 . D = E + F;
9-941 . }
9-942 .
9-943 . A = B/C;
9-944 . A = B-C;
9-945 . A = B-C;
9-946 . A = B*C;
9-947 . A = (int)B + C;
9-948 . A = B/C;
9-949 . A = B/C;
9-950 .
9-951 . if (A ne B)
9-952 . {
9-953 . A = B + C;
9-954 . D = E + F;
9-955 . }
9-956 .
9-957 . A = B+C;
9-958 .
9-959 . if (A < B)
9-960 . {
9-961 . A = B + C;
9-962 . D = E + F;
9-963 . }
9-964 .
9-965 . A = B+C;
9-966 . A = B/C;
9-967 . A = B/C;
9-968 .
9-969 . if (A > B)
9-970 . {
9-971 . A = B + C;
9-972 . D = E + F;
9-973 . }
9-974 .
9-975 .
9-976 . if (A gt B)
9-977 . {
9-978 . A = B + C;
9-979 . D = E + F;
9-980 . }
9-981 .
9-982 .
9-983 . switch (ca stuff)
9-984 . {
9-985 . case one:
9-986 . {
9-987 . run_this;
9-988 . break;
9-989 . }
9-990 . case two:
9-991 . {
9-992 . run_this;
9-993 . break;
9-994 . }
9-995 . default:
9-996 . {
9-997 . SwError;
9-998 . }
9-999 . }
9-1000 .
9-1001 . A = B/C;
9-1002 . A = B-C;
9-1003 . A = B-C;
9-1004 . A = B-C;
9-1005 .
9-1006 . if (A ne B)
9-1007 . {
9-1008 . A = B + C;
9-1009 . D = E + F;
9-1010 . }
9-1011 .
9-1012 . A = B+C;
9-1013 . A = B*C;
9-1014 .
9-1015 . switch (ca stuff)
9-1016 . {
9-1017 . case one:
9-1018 . {
9-1019 . run_this;
9-1020 . break;
9-1021 . }
9-1022 . case two:
9-1023 . {
9-1024 . run_this;
9-1025 . break;
9-1026 . }
9-1027 . default:
9-1028 . {
9-1029 . SwError;
9-1030 . }
9-1031 . }
9-1032 .
9-1033 . A = B/C;
9-1034 . A = B*C;
9-1035 . A = B-C;
9-1036 . A = B-C;
9-1037 . A = B-C;
9-1038 .
9-1039 . if (A ne B)
9-1040 . {
9-1041 . A = B + C;
9-1042 . D = E + F;
9-1043 . }
9-1044 .
9-1045 . A = B*C;
9-1046 . A = B/C;
9-1047 . A = B-C;
9-1048 . A = B-C;
9-1049 .
9-1050 . if {
9-1051 . X = Y + Z;
9-1052 . }
9-1053 . else {
9-1054 . halt;
9-1055 . }
9-1056 .
9-1057 . A = B/C;
9-1058 . A = B-C;
9-1059 . A = B*C;
9-1060 .
9-1061 . if (A != B)
9-1062 . {
9-1063 . A = B + C;
9-1064 . D = E + F;
9-1065 . }
9-1066 .
9-1067 .
9-1068 . if (A < B)
9-1069 . {
9-1070 . A = B + C;
9-1071 . D = E + F;
9-1072 . }
9-1073 .
9-1074 . /* LE SV TOC-1156 this is a ca-09.5.73 req to enable*/
9-1075 . A = B-C;
9-1076 .
9-1077 . switch (ca stuff)
9-1078 . {
9-1079 . case one:
9-1080 . {
9-1081 . run_this;
9-1082 . // missing break
9-1083 . }
9-1084 . case two:
9-1085 . {
9-1086 . run_this;
9-1087 . break;
9-1088 . }
9-1089 . default:
9-1090 . {
9-1091 . SwError;
9-1092 . }
9-1093 . }
9-1094 .
9-1095 . A = B-C;
9-1096 .
9-1097 . /* dead_code = B + C;
9-1098 . dead_code = D + E;
9-1099 . dead_code = F + G; */
9-1100 .
9-1101 . A = B/C;
9-1102 . A = B/C;
9-1103 . A = B+C;
9-1104 . A = B+C;
9-1105 . // max LOC 78
9-1106 .
9-1107 . }
9-1108 .
9-1109 .
9-1110 . /*
9-1111 . -----------------------------------------------------------------------------
9-1112 . --| NAME: ca.9.6
9-1113 . --|
9-1114 . --| ABSTRACT:
9-1115 . --| This function does ca stuff.
9-1116 . --|
9-1117 . --| RETURNS:
9-1118 . --| NONE.
9-1119 . --|
9-1120 . ----------------------------------------------------------------------------
9-1121 . */
9-1122 . static void ca.9.6(void)
9-1123 . {
9-1124 .
9-1125 . if (A ne B)
9-1126 . {
9-1127 . A = B + C;
9-1128 . D = E + F;
9-1129 . }
9-1130 .
9-1131 .
9-1132 . if (A ge B)
9-1133 . {
9-1134 . A = B + C;
9-1135 . D = E + F;
9-1136 . }
9-1137 .
9-1138 . A = B*C;
9-1139 . A = B+C;
9-1140 . A = 0x0001;
9-1141 . A = B*C;
9-1142 . A = B*C;
9-1143 . /* LE SV TOC-1157 this is a ca-09.6.7 req to verify*/
9-1144 .
9-1145 . if (A == B)
9-1146 . {
9-1147 . A = B + C;
9-1148 . D = E + F;
9-1149 . }
9-1150 .
9-1151 .
9-1152 . if (A ne B)
9-1153 . {
9-1154 . A = B + C;
9-1155 . D = E + F;
9-1156 . }
9-1157 .
9-1158 . A = B+C;
9-1159 . A = B-C;
9-1160 . A = B*C;
9-1161 . A = B*C;
9-1162 . A = B+C;
9-1163 . A = 0x0009;
9-1164 . A = B/C;
9-1165 . /* LE SV TOC-1158 this is a ca-09.6.15 req to halt*/
9-1166 . A = B-C;
9-1167 . A = B-C;
9-1168 . A = B*C;
9-1169 . A = B*C;
9-1170 .
9-1171 . /* dead_block = C * D;
9-1172 . dead_block = E * F; */
9-1173 .
9-1174 . A = B*C;
9-1175 .
9-1176 . switch (ca stuff)
9-1177 . {
9-1178 . case one:
9-1179 . {
9-1180 . run_this;
9-1181 . // missing break
9-1182 . }
9-1183 . case two:
9-1184 . {
9-1185 . run_this;
9-1186 . break;
9-1187 . }
9-1188 . default:
9-1189 . {
9-1190 . SwError;
9-1191 . }
9-1192 . }
9-1193 .
9-1194 .
9-1195 . if (A ne B)
9-1196 . {
9-1197 . A = B + C;
9-1198 . D = E + F;
9-1199 . }
9-1200 .
9-1201 . A = B*C;
9-1202 .
9-1203 . if (A lt B)
9-1204 . {
9-1205 . A = B + C;
9-1206 . D = E + F;
9-1207 . }
9-1208 .
9-1209 .
9-1210 . if (A < = B)
9-1211 . {
9-1212 . A = B + C;
9-1213 . D = E + F;
9-1214 . }
9-1215 .
9-1216 . A = B-C;
9-1217 . A = B+C;
9-1218 .
9-1219 . if (A le B)
9-1220 . {
9-1221 . A = B + C;
9-1222 . D = E + F;
9-1223 . }
9-1224 .
9-1225 . A = B*C;
9-1226 .
9-1227 . if (A > = B)
9-1228 . {
9-1229 . A = B + C;
9-1230 . D = E + F;
9-1231 . }
9-1232 .
9-1233 . send_buffer = (U16 *) malloc(size+1);
9-1234 . A = B*C;
9-1235 . A = B-C;
9-1236 .
9-1237 . /* dead_code = B + C;
9-1238 . dead_code = D + E;
9-1239 . dead_code = F + G; */
9-1240 .
9-1241 . A = B-C;
9-1242 . A = 0x0007;
9-1243 . A = B/C;
9-1244 . A = B/C;
9-1245 . A = B-C;
9-1246 . A = B+C;
9-1247 . A = B*C;
9-1248 .
9-1249 . if (A > = B)
9-1250 . {
9-1251 . A = B + C;
9-1252 . D = E + F;
9-1253 . }
9-1254 .
9-1255 . A = B*C;
9-1256 . A = B-C;
9-1257 . A = B/C;
9-1258 . A = B+C;
9-1259 . A = B+C;
9-1260 . // max LOC 42
9-1261 .
9-1262 . }
9-1263 .
9-1264 .
9-1265 . /*
9-1266 . -----------------------------------------------------------------------------
9-1267 . --| NAME: ca.9.7
9-1268 . --|
9-1269 . --| ABSTRACT:
9-1270 . --| This function does ca stuff.
9-1271 . --|
9-1272 . --| RETURNS:
9-1273 . --| NONE.
9-1274 . --|
9-1275 . ----------------------------------------------------------------------------
9-1276 . */
9-1277 . static void ca.9.7(void)
9-1278 . {
9-1279 . A = B/C;
9-1280 . A = B+C;
9-1281 . A = B+C;
9-1282 .
9-1283 . if (A ge B)
9-1284 . {
9-1285 . A = B + C;
9-1286 . D = E + F;
9-1287 . }
9-1288 .
9-1289 .
9-1290 . if (A != B)
9-1291 . {
9-1292 . A = B + C;
9-1293 . D = E + F;
9-1294 . }
9-1295 .
9-1296 .
9-1297 . if (A > B)
9-1298 . {
9-1299 . A = B + C;
9-1300 . D = E + F;
9-1301 . }
9-1302 .
9-1303 . A = B*C;
9-1304 .
9-1305 . if (A ne B)
9-1306 . {
9-1307 . A = B + C;
9-1308 . D = E + F;
9-1309 . }
9-1310 .
9-1311 . A = B*C;
9-1312 . A = B+C;
9-1313 . A = B+C;
9-1314 .
9-1315 . if (A ge B)
9-1316 . {
9-1317 . A = B + C;
9-1318 . D = E + F;
9-1319 . }
9-1320 .
9-1321 .
9-1322 . if (A != B)
9-1323 . {
9-1324 . A = B + C;
9-1325 . D = E + F;
9-1326 . }
9-1327 .
9-1328 . A = B/C;
9-1329 . A = B-C;
9-1330 . A = B*C;
9-1331 . A = B/C;
9-1332 . A = B/C;
9-1333 . A = B-C;
9-1334 .
9-1335 . if (A < B)
9-1336 . {
9-1337 . A = B + C;
9-1338 . D = E + F;
9-1339 . }
9-1340 .
9-1341 . A = B-C;
9-1342 . A = B+C;
9-1343 . A = B+C;
9-1344 .
9-1345 . if (A < = B)
9-1346 . {
9-1347 . A = B + C;
9-1348 . D = E + F;
9-1349 . }
9-1350 .
9-1351 . A = B/C;
9-1352 . /* LE SV TOC-1159 this is a ca-09.7.26 req to fail*/
9-1353 .
9-1354 . if (A le B)
9-1355 . {
9-1356 . A = B + C;
9-1357 . D = E + F;
9-1358 . }
9-1359 .
9-1360 . A = B*C;
9-1361 . /* LE SV TOC-1160 this is a ca-09.7.28 req to audit*/
9-1362 .
9-1363 . if (A == B)
9-1364 . {
9-1365 . A = B + C;
9-1366 . D = E + F;
9-1367 . }
9-1368 .
9-1369 .
9-1370 . if (A < = B)
9-1371 . {
9-1372 . A = B + C;
9-1373 . D = E + F;
9-1374 . }
9-1375 .
9-1376 .
9-1377 . if (A > B)
9-1378 . {
9-1379 . A = B + C;
9-1380 . D = E + F;
9-1381 . }
9-1382 .
9-1383 .
9-1384 . if (A gt B)
9-1385 . {
9-1386 . A = B + C;
9-1387 . D = E + F;
9-1388 . }
9-1389 .
9-1390 .
9-1391 . if (A ge B)
9-1392 . {
9-1393 . A = B + C;
9-1394 . D = E + F;
9-1395 . }
9-1396 .
9-1397 . A = B+C;
9-1398 .
9-1399 . if (A ne B)
9-1400 . {
9-1401 . A = B + C;
9-1402 . D = E + F;
9-1403 . }
9-1404 .
9-1405 . A = B/C;
9-1406 .
9-1407 . if (A ge B)
9-1408 . {
9-1409 . A = B + C;
9-1410 . D = E + F;
9-1411 . }
9-1412 .
9-1413 . A = B-C;
9-1414 . A = 0x0003;
9-1415 .
9-1416 . if (A lt B)
9-1417 . {
9-1418 . A = B + C;
9-1419 . D = E + F;
9-1420 . }
9-1421 .
9-1422 . A = B/C;
9-1423 . /* LE SV TOC-1161 this is a ca-09.7.40 req to audit*/
9-1424 . A = B*C;
9-1425 . A = B+C;
9-1426 .
9-1427 . if (A > = B)
9-1428 . {
9-1429 . A = B + C;
9-1430 . D = E + F;
9-1431 . }
9-1432 .
9-1433 . A = B/C;
9-1434 . A = B-C;
9-1435 . A = B*C;
9-1436 . A = B/C;
9-1437 . A = B+C;
9-1438 . A = B+C;
9-1439 . A = B*C;
9-1440 . A = B*C;
9-1441 . A = B+C;
9-1442 .
9-1443 . switch (ca stuff)
9-1444 . {
9-1445 . case one:
9-1446 . {
9-1447 . run_this;
9-1448 . // missing break
9-1449 . }
9-1450 . case two:
9-1451 . {
9-1452 . run_this;
9-1453 . break;
9-1454 . }
9-1455 . default:
9-1456 . {
9-1457 . SwError;
9-1458 . }
9-1459 . }
9-1460 .
9-1461 . A = B/C;
9-1462 . /* LE SV TOC-1162 this is a ca-09.7.53 req to transform*/
9-1463 . A = B-C;
9-1464 . A = B+C;
9-1465 . A = B-C;
9-1466 .
9-1467 . if (A > = B)
9-1468 . {
9-1469 . A = B + C;
9-1470 . D = E + F;
9-1471 . }
9-1472 .
9-1473 .
9-1474 . if (A == B)
9-1475 . {
9-1476 . A = B + C;
9-1477 . D = E + F;
9-1478 . }
9-1479 .
9-1480 .
9-1481 . switch (ca stuff)
9-1482 . {
9-1483 . case one:
9-1484 . {
9-1485 . run_this;
9-1486 . break;
9-1487 . }
9-1488 . case two:
9-1489 . {
9-1490 . run_this;
9-1491 . break;
9-1492 . }
9-1493 . default:
9-1494 . {
9-1495 . SwError;
9-1496 . }
9-1497 . }
9-1498 .
9-1499 . // max LOC 58
9-1500 .
9-1501 . }
9-1502 .
9-1503 .
9-1504 . /*
9-1505 . -----------------------------------------------------------------------------
9-1506 . --| NAME: ca.9.8
9-1507 . --|
9-1508 . --| ABSTRACT:
9-1509 . --| This function does ca stuff.
9-1510 . --|
9-1511 . --| RETURNS:
9-1512 . --| NONE.
9-1513 . --|
9-1514 . ----------------------------------------------------------------------------
9-1515 . */
9-1516 . static void ca.9.8(void)
9-1517 . {
9-1518 . A = B/C;
9-1519 .
9-1520 . if (A > B)
9-1521 . {
9-1522 . A = B + C;
9-1523 . D = E + F;
9-1524 . }
9-1525 .
9-1526 .
9-1527 . switch (ca stuff)
9-1528 . {
9-1529 . case one:
9-1530 . {
9-1531 . run_this;
9-1532 . break;
9-1533 . }
9-1534 . case two:
9-1535 . {
9-1536 . run_this;
9-1537 . break;
9-1538 . }
9-1539 . default:
9-1540 . {
9-1541 . SwError;
9-1542 . }
9-1543 . }
9-1544 .
9-1545 .
9-1546 . if (A eq B)
9-1547 . {
9-1548 . A = B + C;
9-1549 . D = E + F;
9-1550 . }
9-1551 .
9-1552 . A = B-C;
9-1553 . A = B-C;
9-1554 .
9-1555 . if (A lt B)
9-1556 . {
9-1557 . A = B + C;
9-1558 . D = E + F;
9-1559 . }
9-1560 .
9-1561 .
9-1562 . if (A > B)
9-1563 . {
9-1564 . A = B + C;
9-1565 . D = E + F;
9-1566 . }
9-1567 .
9-1568 .
9-1569 . if (A > B)
9-1570 . {
9-1571 . A = B + C;
9-1572 . D = E + F;
9-1573 . }
9-1574 .
9-1575 . A = 0x0001;
9-1576 . A = B-C;
9-1577 .
9-1578 . if (A < B)
9-1579 . {
9-1580 . A = B + C;
9-1581 . D = E + F;
9-1582 . }
9-1583 .
9-1584 .
9-1585 . if (A ge B)
9-1586 . {
9-1587 . A = B + C;
9-1588 . D = E + F;
9-1589 . }
9-1590 .
9-1591 .
9-1592 . if (A > = B)
9-1593 . {
9-1594 . A = B + C;
9-1595 . D = E + F;
9-1596 . }
9-1597 .
9-1598 . A = B-C;
9-1599 . /* LE SV TOC-1163 this is a ca-09.8.15 req to call admin*/
9-1600 .
9-1601 . if (A < B)
9-1602 . {
9-1603 . A = B + C;
9-1604 . D = E + F;
9-1605 . }
9-1606 .
9-1607 . A = 0x0002;
9-1608 . A = B-C;
9-1609 . A = B*C;
9-1610 . A = B-C;
9-1611 . A = B/C;
9-1612 . A = B-C;
9-1613 . A = B+C;
9-1614 .
9-1615 . if (A != B)
9-1616 . {
9-1617 . A = B + C;
9-1618 . D = E + F;
9-1619 . }
9-1620 .
9-1621 .
9-1622 . if (A == B)
9-1623 . {
9-1624 . A = B + C;
9-1625 . D = E + F;
9-1626 . }
9-1627 .
9-1628 .
9-1629 . switch (ca stuff)
9-1630 . {
9-1631 . case:
9-1632 . case:
9-1633 . // stacked case statements but only if there is a new line in between
9-1634 .
9-1635 . case:
9-1636 . case:
9-1637 . case:
9-1638 . {
9-1639 . run_this;
9-1640 . break;
9-1641 . }
9-1642 . default:
9-1643 . {
9-1644 . halt;
9-1645 . }
9-1646 . }
9-1647 .
9-1648 . A = B/C;
9-1649 . A = B*C;
9-1650 . A = B*C;
9-1651 .
9-1652 . if (A != B)
9-1653 . {
9-1654 . A = B + C;
9-1655 . D = E + F;
9-1656 . }
9-1657 .
9-1658 . A = B+C;
9-1659 . A = B+C;
9-1660 . A = B*C;
9-1661 .
9-1662 . if (A ne B)
9-1663 . {
9-1664 . A = B + C;
9-1665 . D = E + F;
9-1666 . }
9-1667 .
9-1668 . A = B-C;
9-1669 .
9-1670 . if (A == B)
9-1671 . {
9-1672 . A = B + C;
9-1673 . D = E + F;
9-1674 . }
9-1675 .
9-1676 . A = B*C;
9-1677 . /* LE SV TOC-1164 this is a ca-09.8.35 req to assign*/
9-1678 . A = B+C;
9-1679 . A = B*C;
9-1680 .
9-1681 . if (A < B)
9-1682 . {
9-1683 . A = B + C;
9-1684 . D = E + F;
9-1685 . }
9-1686 .
9-1687 . A = B/C;
9-1688 . A = B-C;
9-1689 .
9-1690 . if (A > = B)
9-1691 . {
9-1692 . A = B + C;
9-1693 . D = E + F;
9-1694 . }
9-1695 .
9-1696 . A = B+C;
9-1697 . A = B+C;
9-1698 . A = B*C;
9-1699 . /* LE SV TOC-1165 this is a ca-09.8.44 req to inhibit*/
9-1700 .
9-1701 . if (A eq B)
9-1702 . {
9-1703 . A = B + C;
9-1704 . D = E + F;
9-1705 . }
9-1706 .
9-1707 . A = B+C;
9-1708 . A = B+C;
9-1709 . A = B+C;
9-1710 .
9-1711 . if (A lt B)
9-1712 . {
9-1713 . A = B + C;
9-1714 . D = E + F;
9-1715 . }
9-1716 .
9-1717 .
9-1718 . if (A gt B)
9-1719 . {
9-1720 . A = B + C;
9-1721 . D = E + F;
9-1722 . }
9-1723 .
9-1724 . A = B-C;
9-1725 . A = B*C;
9-1726 . A = 0x0009;
9-1727 . A = B/C;
9-1728 . A = B-C;
9-1729 . A = B+C;
9-1730 . /* LE SV TOC-1166 this is a ca-09.8.55 req to inhibit*/
9-1731 .
9-1732 . if (A ge B)
9-1733 . {
9-1734 . A = B + C;
9-1735 . D = E + F;
9-1736 . }
9-1737 .
9-1738 . A = B*C;
9-1739 . A = B/C;
9-1740 . A = B/C;
9-1741 . A = B-C;
9-1742 . A = B-C;
9-1743 . A = B*C;
9-1744 . A = B-C;
9-1745 . A = B*C;
9-1746 . A = B*C;
9-1747 . A = B/C;
9-1748 .
9-1749 . if (A == B)
9-1750 . {
9-1751 . A = B + C;
9-1752 . D = E + F;
9-1753 . }
9-1754 .
9-1755 . A = B-C;
9-1756 .
9-1757 . if (A > = B)
9-1758 . {
9-1759 . A = B + C;
9-1760 . D = E + F;
9-1761 . }
9-1762 .
9-1763 .
9-1764 . if (A > B)
9-1765 . {
9-1766 . A = B + C;
9-1767 . D = E + F;
9-1768 . }
9-1769 .
9-1770 .
9-1771 . if (A gt B)
9-1772 . {
9-1773 . A = B + C;
9-1774 . D = E + F;
9-1775 . }
9-1776 .
9-1777 . /* LE SV TOC-1167 this is a ca-09.8.71 req to set RTC*/
9-1778 . A = B*C;
9-1779 . A = B*C;
9-1780 . A = B/C;
9-1781 .
9-1782 . if (A ge B)
9-1783 . {
9-1784 . A = B + C;
9-1785 . D = E + F;
9-1786 . }
9-1787 .
9-1788 . A = 0x0008;
9-1789 .
9-1790 . if (A != B)
9-1791 . {
9-1792 . A = B + C;
9-1793 . D = E + F;
9-1794 . }
9-1795 .
9-1796 .
9-1797 . switch (ca stuff)
9-1798 . {
9-1799 . case one:
9-1800 . {
9-1801 . run_this;
9-1802 . break;
9-1803 . }
9-1804 . case two:
9-1805 . {
9-1806 . run_this;
9-1807 . break;
9-1808 . }
9-1809 . default:
9-1810 . {
9-1811 . SwError;
9-1812 . }
9-1813 . }
9-1814 .
9-1815 . A = B/C;
9-1816 . A = B*C;
9-1817 . // max LOC 78
9-1818 .
9-1819 . }
9-1820 .
9-1821 .
9-1822 . /*
9-1823 . -----------------------------------------------------------------------------
9-1824 . --| NAME: ca.9.9
9-1825 . --|
9-1826 . --| ABSTRACT:
9-1827 . --| This function does ca stuff.
9-1828 . --|
9-1829 . --| RETURNS:
9-1830 . --| NONE.
9-1831 . --|
9-1832 . ----------------------------------------------------------------------------
9-1833 . */
9-1834 . static void ca.9.9(void)
9-1835 . {
9-1836 .
9-1837 . switch (ca stuff)
9-1838 . {
9-1839 . case one:
9-1840 . {
9-1841 . run_this;
9-1842 . break;
9-1843 . }
9-1844 . case two:
9-1845 . {
9-1846 . run_this;
9-1847 . break;
9-1848 . }
9-1849 . default:
9-1850 . {
9-1851 . SwError;
9-1852 . }
9-1853 . }
9-1854 .
9-1855 . A = B-C;
9-1856 . /* LE SV TOC-1168 this is a ca-09.9.3 req to set RTC*/
9-1857 .
9-1858 . if (A < B)
9-1859 . {
9-1860 . A = B + C;
9-1861 . D = E + F;
9-1862 . }
9-1863 .
9-1864 . A = B+C;
9-1865 . A = B*C;
9-1866 . A = B/C;
9-1867 . // (P) this is really improtant
9-1868 . A = B-C;
9-1869 . A = B/C;
9-1870 . FreePtr = HmiStringPtr;
9-1871 . A = B-C;
9-1872 . A = B/C;
9-1873 .
9-1874 . /* dead_code = B + C;
9-1875 . dead_code = D + E;
9-1876 . dead_code = F + G; */
9-1877 .
9-1878 . A = B/C;
9-1879 .
9-1880 . if (A ge B)
9-1881 . {
9-1882 . A = B + C;
9-1883 . D = E + F;
9-1884 . }
9-1885 .
9-1886 . A = B+C;
9-1887 . A = B*C;
9-1888 .
9-1889 . if (A == B)
9-1890 . {
9-1891 . A = B + C;
9-1892 . D = E + F;
9-1893 . }
9-1894 .
9-1895 . A = B*C;
9-1896 . A = B+C;
9-1897 . A = B/C;
9-1898 .
9-1899 . if (A gt B)
9-1900 . {
9-1901 . A = B + C;
9-1902 . D = E + F;
9-1903 . }
9-1904 .
9-1905 .
9-1906 . if (A < B)
9-1907 . {
9-1908 . A = B + C;
9-1909 . D = E + F;
9-1910 . }
9-1911 .
9-1912 .
9-1913 . if (A gt B)
9-1914 . {
9-1915 . A = B + C;
9-1916 . D = E + F;
9-1917 . }
9-1918 .
9-1919 . A = B+C;
9-1920 . A = B/C;
9-1921 .
9-1922 . if (A lt B)
9-1923 . {
9-1924 . A = B + C;
9-1925 . D = E + F;
9-1926 . }
9-1927 .
9-1928 . A = B+C;
9-1929 . A = B-C;
9-1930 . /* LE SV TOC-1169 this is a ca-09.9.27 req to halt*/
9-1931 . A = B/C;
9-1932 . A = B/C;
9-1933 . A = B-C;
9-1934 . FreePtr = HmiStringPtr;
9-1935 . A = B-C;
9-1936 .
9-1937 . if (A > B)
9-1938 . {
9-1939 . A = B + C;
9-1940 . D = E + F;
9-1941 . }
9-1942 .
9-1943 .
9-1944 . if (A < B)
9-1945 . {
9-1946 . A = B + C;
9-1947 . D = E + F;
9-1948 . }
9-1949 .
9-1950 .
9-1951 . switch (ca stuff)
9-1952 . {
9-1953 . case one:
9-1954 . {
9-1955 . run_this;
9-1956 . break;
9-1957 . }
9-1958 . case two:
9-1959 . {
9-1960 . run_this;
9-1961 . break;
9-1962 . }
9-1963 . default:
9-1964 . {
9-1965 . SwError;
9-1966 . }
9-1967 . }
9-1968 .
9-1969 . A = 0x0004;
9-1970 . A = B-C;
9-1971 . A = B-C;
9-1972 . // max LOC 35
9-1973 .
9-1974 . }
9-1975 .
9-1976 .
9-1977 . /*
9-1978 . -----------------------------------------------------------------------------
9-1979 . --| NAME: ca.9.10
9-1980 . --|
9-1981 . --| ABSTRACT:
9-1982 . --| This function does ca stuff.
9-1983 . --|
9-1984 . --| RETURNS:
9-1985 . --| NONE.
9-1986 . --|
9-1987 . ----------------------------------------------------------------------------
9-1988 . */
9-1989 . static void ca.9.10(void)
9-1990 . {
9-1991 .
9-1992 . if (A < = B)
9-1993 . {
9-1994 . A = B + C;
9-1995 . D = E + F;
9-1996 . }
9-1997 .
9-1998 .
9-1999 . if (A ge B)
9-2000 . {
9-2001 . A = B + C;
9-2002 . D = E + F;
9-2003 . }
9-2004 .
9-2005 .
9-2006 . if (A > B)
9-2007 . {
9-2008 . A = B + C;
9-2009 . D = E + F;
9-2010 . }
9-2011 .
9-2012 .
9-2013 . if (A > B)
9-2014 . {
9-2015 . A = B + C;
9-2016 . D = E + F;
9-2017 . }
9-2018 .
9-2019 . A = B+C;
9-2020 .
9-2021 . if (A eq B)
9-2022 . {
9-2023 . A = B + C;
9-2024 . D = E + F;
9-2025 . }
9-2026 .
9-2027 .
9-2028 . if (A > = B)
9-2029 . {
9-2030 . A = B + C;
9-2031 . D = E + F;
9-2032 . }
9-2033 .
9-2034 . A = B/C;
9-2035 . A = B*C;
9-2036 . A = B*C;
9-2037 . A = B+C;
9-2038 .
9-2039 . if (A ne B)
9-2040 . {
9-2041 . A = B + C;
9-2042 . D = E + F;
9-2043 . }
9-2044 .
9-2045 . A = B+C;
9-2046 . // TBS - I need to figure this out
9-2047 . A = B+C;
9-2048 . A = B+C;
9-2049 .
9-2050 . if (A > = B)
9-2051 . {
9-2052 . A = B + C;
9-2053 . D = E + F;
9-2054 . }
9-2055 .
9-2056 . A = B*C;
9-2057 . A = B/C;
9-2058 .
9-2059 . if (A le B)
9-2060 . {
9-2061 . A = B + C;
9-2062 . D = E + F;
9-2063 . }
9-2064 .
9-2065 .
9-2066 . if (A < = B)
9-2067 . {
9-2068 . A = B + C;
9-2069 . D = E + F;
9-2070 . }
9-2071 .
9-2072 .
9-2073 . if (A gt B)
9-2074 . {
9-2075 . A = B + C;
9-2076 . D = E + F;
9-2077 . }
9-2078 .
9-2079 . A = B*C;
9-2080 . A = B+C;
9-2081 . A = B-C;
9-2082 . A = B/C;
9-2083 .
9-2084 . if (A > = B)
9-2085 . {
9-2086 . A = B + C;
9-2087 . D = E + F;
9-2088 . }
9-2089 .
9-2090 . A = B*C;
9-2091 . A = B*C;
9-2092 .
9-2093 . switch (ca stuff)
9-2094 . {
9-2095 . case one:
9-2096 . {
9-2097 . run_this;
9-2098 . break;
9-2099 . }
9-2100 . case two:
9-2101 . {
9-2102 . run_this;
9-2103 . break;
9-2104 . }
9-2105 . default:
9-2106 . {
9-2107 . SwError;
9-2108 . }
9-2109 . }
9-2110 .
9-2111 . A = B/C;
9-2112 . A = B/C;
9-2113 . A = B*C;
9-2114 .
9-2115 . if (A > = B)
9-2116 . {
9-2117 . A = B + C;
9-2118 . D = E + F;
9-2119 . }
9-2120 .
9-2121 . A = B-C;
9-2122 . // max LOC 34
9-2123 .
9-2124 . }
9-2125 .
9-2126 .
9-2127 . /*
9-2128 . -----------------------------------------------------------------------------
9-2129 . --| NAME: ca.9.11
9-2130 . --|
9-2131 . --| ABSTRACT:
9-2132 . --| This function does ca stuff.
9-2133 . --|
9-2134 . --| RETURNS:
9-2135 . --| NONE.
9-2136 . --|
9-2137 . ----------------------------------------------------------------------------
9-2138 . */
9-2139 . static void ca.9.11(void)
9-2140 . {
9-2141 . A = B+C;
9-2142 .
9-2143 . if (A eq B)
9-2144 . {
9-2145 . A = B + C;
9-2146 . D = E + F;
9-2147 . }
9-2148 .
9-2149 . A = B+C;
9-2150 .
9-2151 . if (A == B)
9-2152 . {
9-2153 . A = B + C;
9-2154 . D = E + F;
9-2155 . }
9-2156 .
9-2157 . A = B+C;
9-2158 . A = B-C;
9-2159 . A = B-C;
9-2160 . A = B/C;
9-2161 . A = B*C;
9-2162 . // max LOC 9
9-2163 .
9-2164 . }
9-2165 .
9 9 Result: result/source/pr-app/pr-app-CA123/ca/ca-09.c