Logevents v111003 analysis/pr-app-RDP123 s_cpc-listing-c.html C:\IndigoPerl\bin\perl.exe 5.006

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

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

12/08/2003 16:14:07

Details Report

1 1 Source: source/pr-app/pr-app-RDP123/rdp-01.c
 1-0 . /*
 1-1 . ----------------------------------------------------------------------------
 1-2 . --| BEGIN PROLOGUE
 1-3 . --|
 1-4 . --| CLASSIFICATION: UNCLASSIFIED
 1-5 . --|
 1-6 . --| FILE NAME:      rdp-01.c
 1-7 . --|
 1-8 . --| ABSTRACT:
 1-9 . --|   This file contains the 6 functions that do file rdp stuff.
 1-10 . --|
 1-11 . --| HISTORY:
 1-12 . --|   CCCQ_NAME:
 1-13 . --|   CCCQ_VER: 
 1-14 . --|
 1-15 . --| END PROLOGUE
 1-16 . ----------------------------------------------------------------------------
 1-17 . */
 1-18 . 
 1-19 . #define D;
 1-20 . float B;
 1-21 . #define B;
 1-22 . #define B;
 1-23 . float B;
 1-24 . 
 1-25 . 
 1-26 . 
 1-27 . /*
 1-28 . -----------------------------------------------------------------------------
 1-29 . --| NAME:   rdp.1.1
 1-30 . --|
 1-31 . --| ABSTRACT:
 1-32 . --|   This function does rdp stuff.
 1-33 . --|
 1-34 . --| RETURNS:
 1-35 . --|   NONE.
 1-36 . --|
 1-37 . ----------------------------------------------------------------------------
 1-38 . */
 1-39 . static void rdp.1.1(void)
 1-40 . {
 1-41 . A = B+C;
 1-42 . 
 1-43 . if (A ne B)
 1-44 . {
 1-45 .    A = B + C;
 1-46 .    D = E + F;
 1-47 . }
 1-48 . 
 1-49 . A = B+C;
 1-50 . 
 1-51 . switch (rdp stuff)
 1-52 . {
 1-53 .    case one:
 1-54 .    {
 1-55 .       run_this; 
 1-56 .       break;
 1-57 .    }
 1-58 .    case two:
 1-59 .    {
 1-60 .       run_this;
 1-61 .       break;
 1-62 .    }
 1-63 .    default:
 1-64 .    {
 1-65 .        SwError;
 1-66 .    }
 1-67 . }
 1-68 . 
 1-69 . /* LE SV TOC-2601 this is a rdp-01.1.5 req to disable*/
 1-70 . A = B*C;
 1-71 . 
 1-72 . if (A == B)
 1-73 . {
 1-74 .    A = B + C;
 1-75 .    D = E + F;
 1-76 . }
 1-77 . 
 1-78 . 
 1-79 . if (A lt B)
 1-80 . {
 1-81 .    A = B + C;
 1-82 .    D = E + F;
 1-83 . }
 1-84 . 
 1-85 . // max LOC 7
 1-86 . 
 1-87 . }
 1-88 . 
 1-89 . 
 1-90 . /*
 1-91 . -----------------------------------------------------------------------------
 1-92 . --| NAME:   rdp.1.2
 1-93 . --|
 1-94 . --| ABSTRACT:
 1-95 . --|   This function does rdp stuff.
 1-96 . --|
 1-97 . --| RETURNS:
 1-98 . --|   NONE.
 1-99 . --|
 1-100 . ----------------------------------------------------------------------------
 1-101 . */
 1-102 . static void rdp.1.2(void)
 1-103 . {
 1-104 . A = B*C;
 1-105 . A = B+C;
 1-106 . /* LE SV TOC-2602 this is a rdp-01.2.3 req to recover*/
 1-107 . 
 1-108 . switch (rdp stuff)
 1-109 . {
 1-110 .    case one:
 1-111 .    {
 1-112 .       run_this; 
 1-113 .       break;
 1-114 .    }
 1-115 .    case two:
 1-116 .    {
 1-117 .       run_this;
 1-118 .       break;
 1-119 .    }
 1-120 .    default:
 1-121 .    {
 1-122 .        SwError;
 1-123 .    }
 1-124 . }
 1-125 . 
 1-126 . A = B+C;
 1-127 . A = B-C;
 1-128 . 
 1-129 . if (A > = B)
 1-130 . {
 1-131 .    A = B + C;
 1-132 .    D = E + F;
 1-133 . }
 1-134 . 
 1-135 . A = B+C;
 1-136 . A = B+C;
 1-137 . /* LE SV TOC-2603 this is a rdp-01.2.9 req to enable*/
 1-138 . A = (int)B + C;
 1-139 . A = B-C;
 1-140 . /* LE SV TOC-2604 this is a rdp-01.2.10 req to record*/
 1-141 . 
 1-142 . if (A != B)
 1-143 . {
 1-144 .    A = B + C;
 1-145 .    D = E + F;
 1-146 . }
 1-147 . 
 1-148 . A = B-C;
 1-149 . 
 1-150 . if (A lt B)
 1-151 . {
 1-152 .    A = B + C;
 1-153 .    D = E + F;
 1-154 . }
 1-155 . 
 1-156 . 
 1-157 . switch (rdp stuff)
 1-158 . {
 1-159 .    case one:
 1-160 .    {
 1-161 .       run_this; 
 1-162 .       break;
 1-163 .    }
 1-164 .    case two:
 1-165 .    {
 1-166 .       run_this;
 1-167 .       break;
 1-168 .    }
 1-169 .    default:
 1-170 .    {
 1-171 .        SwError;
 1-172 .    }
 1-173 . }
 1-174 . 
 1-175 . 
 1-176 . if (A le B)
 1-177 . {
 1-178 .    A = B + C;
 1-179 .    D = E + F;
 1-180 . }
 1-181 . 
 1-182 . A = B+C;
 1-183 . A = B-C;
 1-184 . 
 1-185 . switch (rdp stuff)
 1-186 . {
 1-187 .    case one:
 1-188 .    {
 1-189 .       run_this; 
 1-190 .       break;
 1-191 .    }
 1-192 .    case two:
 1-193 .    {
 1-194 .       run_this;
 1-195 .       break;
 1-196 .    }
 1-197 .    default:
 1-198 .    {
 1-199 .        SwError;
 1-200 .    }
 1-201 . }
 1-202 . 
 1-203 . A = B/C;
 1-204 . A = B*C;
 1-205 . 
 1-206 . if (A == B)
 1-207 . {
 1-208 .    A = B + C;
 1-209 .    D = E + F;
 1-210 . }
 1-211 . 
 1-212 . A = B-C;
 1-213 . rcv_buffer = (U16 *) alloc(size+1);
 1-214 . A = B-C;
 1-215 . 
 1-216 . if (A gt B)
 1-217 . {
 1-218 .    A = B + C;
 1-219 .    D = E + F;
 1-220 . }
 1-221 . 
 1-222 . A = B-C;
 1-223 . A = B-C;
 1-224 . A = B+C;
 1-225 . A = B/C;
 1-226 . 
 1-227 . if (A gt B)
 1-228 . {
 1-229 .    A = B + C;
 1-230 .    D = E + F;
 1-231 . }
 1-232 . 
 1-233 . A = B/C;
 1-234 . 
 1-235 . if (A == B)
 1-236 . {
 1-237 .    A = B + C;
 1-238 .    D = E + F;
 1-239 . }
 1-240 . 
 1-241 . A = B*C;
 1-242 . A = B*C;
 1-243 . 
 1-244 . if (A < = B)
 1-245 . {
 1-246 .    A = B + C;
 1-247 .    D = E + F;
 1-248 . }
 1-249 . 
 1-250 . A = B/C;
 1-251 . A = B/C;
 1-252 . 
 1-253 . if (A > = B)
 1-254 . {
 1-255 .    A = B + C;
 1-256 .    D = E + F;
 1-257 . }
 1-258 . 
 1-259 . A = B*C;
 1-260 . A = B/C;
 1-261 . A = B-C;
 1-262 . A = B*C;
 1-263 . /* LE SV TOC-2605 this is a rdp-01.2.41 req to process*/
 1-264 . A = B/C;
 1-265 . A = B+C;
 1-266 . A = B*C;
 1-267 . 
 1-268 . if (A ge B)
 1-269 . {
 1-270 .    A = B + C;
 1-271 .    D = E + F;
 1-272 . }
 1-273 . 
 1-274 . /* LE SV TOC-2606 this is a rdp-01.2.45 req to record*/
 1-275 . A = B+C;
 1-276 . 
 1-277 . if (A ne B)
 1-278 . {
 1-279 .    A = B + C;
 1-280 .    D = E + F;
 1-281 . }
 1-282 . 
 1-283 . A = B/C;
 1-284 . 
 1-285 . if (A >  B)
 1-286 . {
 1-287 .    A = B + C;
 1-288 .    D = E + F;
 1-289 . }
 1-290 . 
 1-291 . A = B*C;
 1-292 . 
 1-293 . if (A lt B)
 1-294 . {
 1-295 .    A = B + C;
 1-296 .    D = E + F;
 1-297 . }
 1-298 . 
 1-299 . 
 1-300 . /* dead_block = C * D; 
 1-301 . dead_block = E * F; */
 1-302 . 
 1-303 . A = B+C;
 1-304 . 
 1-305 . if (A == B)
 1-306 . {
 1-307 .    A = B + C;
 1-308 .    D = E + F;
 1-309 . }
 1-310 . 
 1-311 . 
 1-312 . if (A > = B)
 1-313 . {
 1-314 .    A = B + C;
 1-315 .    D = E + F;
 1-316 . }
 1-317 . 
 1-318 . /* LE SV TOC-2607 this is a rdp-01.2.54 req to disable*/
 1-319 . 
 1-320 . if (A gt B)
 1-321 . {
 1-322 .    A = B + C;
 1-323 .    D = E + F;
 1-324 . }
 1-325 . 
 1-326 . 
 1-327 . if (A >  B)
 1-328 . {
 1-329 .    A = B + C;
 1-330 .    D = E + F;
 1-331 . }
 1-332 . 
 1-333 . A = B/C;
 1-334 . A = B*C;
 1-335 . A = B+C;
 1-336 . 
 1-337 . if (A ge B)
 1-338 . {
 1-339 .    A = B + C;
 1-340 .    D = E + F;
 1-341 . }
 1-342 . 
 1-343 . 
 1-344 . if (A < = B)
 1-345 . {
 1-346 .    A = B + C;
 1-347 .    D = E + F;
 1-348 . }
 1-349 . 
 1-350 . A = B*C;
 1-351 . A = B-C;
 1-352 . 
 1-353 . if (A lt B)
 1-354 . {
 1-355 .    A = B + C;
 1-356 .    D = E + F;
 1-357 . }
 1-358 . 
 1-359 . A = B-C;
 1-360 . A = B/C;
 1-361 . A = B*C;
 1-362 . A = B*C;
 1-363 . 
 1-364 . if (A == B)
 1-365 . {
 1-366 .    A = B + C;
 1-367 .    D = E + F;
 1-368 . }
 1-369 . 
 1-370 . A = B/C;
 1-371 . A = B/C;
 1-372 . A = B-C;
 1-373 . // TBD - what do I do now
 1-374 . 
 1-375 . if (A lt B)
 1-376 . {
 1-377 .    A = B + C;
 1-378 .    D = E + F;
 1-379 . }
 1-380 . 
 1-381 . // max LOC 72
 1-382 . 
 1-383 . }
 1-384 . 
 1-385 . 
 1-386 . /*
 1-387 . -----------------------------------------------------------------------------
 1-388 . --| NAME:   rdp.1.3
 1-389 . --|
 1-390 . --| ABSTRACT:
 1-391 . --|   This function does rdp stuff.
 1-392 . --|
 1-393 . --| RETURNS:
 1-394 . --|   NONE.
 1-395 . --|
 1-396 . ----------------------------------------------------------------------------
 1-397 . */
 1-398 . static void rdp.1.3(void)
 1-399 . {
 1-400 . 
 1-401 . if (A gt B)
 1-402 . {
 1-403 .    A = B + C;
 1-404 .    D = E + F;
 1-405 . }
 1-406 . 
 1-407 . /* LE SV TOC-2608 this is a rdp-01.3.2 req to check pSOS*/
 1-408 . 
 1-409 . if (A != B)
 1-410 . {
 1-411 .    A = B + C;
 1-412 .    D = E + F;
 1-413 . }
 1-414 . 
 1-415 . A = B*C;
 1-416 . A = B/C;
 1-417 . A = B/C;
 1-418 . // (P) this is really improtant
 1-419 . A = B-C;
 1-420 . A = B*C;
 1-421 . A = B/C;
 1-422 . 
 1-423 . if (A gt B)
 1-424 . {
 1-425 .    A = B + C;
 1-426 .    D = E + F;
 1-427 . }
 1-428 . 
 1-429 . 
 1-430 . switch (rdp stuff)
 1-431 . {
 1-432 .    case one:
 1-433 .    {
 1-434 .       run_this; 
 1-435 .       break;
 1-436 .    }
 1-437 .    case two:
 1-438 .    {
 1-439 .       run_this;
 1-440 .       break;
 1-441 .    }
 1-442 .    default:
 1-443 .    {
 1-444 .        SwError;
 1-445 .    }
 1-446 . }
 1-447 . 
 1-448 . A = B/C;
 1-449 . A = B/C;
 1-450 . A = B/C;
 1-451 . /* LE SV TOC-2609 this is a rdp-01.3.14 req to verify*/
 1-452 . A = B*C;
 1-453 . /* LE SV TOC-2610 this is a rdp-01.3.15 req to increment*/
 1-454 . 
 1-455 . if (A le B)
 1-456 . {
 1-457 .    A = B + C;
 1-458 .    D = E + F;
 1-459 . }
 1-460 . 
 1-461 . A = B/C;
 1-462 . 
 1-463 . switch (rdp stuff)
 1-464 . {
 1-465 .    case one:
 1-466 .    {
 1-467 .       switch (nested)
 1-468 .       {
 1-469 .          case:
 1-470 .             X = Y + Z;
 1-471 .          case:
 1-472 .             X = Y + Z;
 1-473 .          default:
 1-474 .             SwError;
 1-475 .       } 
 1-476 .    }
 1-477 .    case two:
 1-478 .    {
 1-479 .       run_this;
 1-480 .       break;
 1-481 .    }
 1-482 .    default:
 1-483 .    {
 1-484 .       SwError;
 1-485 .    }
 1-486 . }
 1-487 . 
 1-488 . A = B/C;
 1-489 . A = B/C;
 1-490 . 
 1-491 . /* dead_block = C * D; 
 1-492 . dead_block = E * F; */
 1-493 . 
 1-494 . 
 1-495 . if (A ne B)
 1-496 . {
 1-497 .    A = B + C;
 1-498 .    D = E + F;
 1-499 . }
 1-500 . 
 1-501 . A = B+C;
 1-502 . A = B*C;
 1-503 . A = B+C;
 1-504 . 
 1-505 . if (A >  B)
 1-506 . {
 1-507 .    A = B + C;
 1-508 .    D = E + F;
 1-509 . }
 1-510 . 
 1-511 . 
 1-512 . if (A <  B)
 1-513 . {
 1-514 .    A = B + C;
 1-515 .    D = E + F;
 1-516 . }
 1-517 . 
 1-518 . /* LE SV TOC-2611 this is a rdp-01.3.25 req to reject*/
 1-519 . 
 1-520 . if (A != B)
 1-521 . {
 1-522 .    A = B + C;
 1-523 .    D = E + F;
 1-524 . }
 1-525 . 
 1-526 . A = B/C;
 1-527 . 
 1-528 . if (A <  B)
 1-529 . {
 1-530 .    A = B + C;
 1-531 .    D = E + F;
 1-532 . }
 1-533 . 
 1-534 . 
 1-535 . if (A gt B)
 1-536 . {
 1-537 .    A = B + C;
 1-538 .    D = E + F;
 1-539 . }
 1-540 . 
 1-541 . A = B/C;
 1-542 . 
 1-543 . if (A > = B)
 1-544 . {
 1-545 .    A = B + C;
 1-546 .    D = E + F;
 1-547 . }
 1-548 . 
 1-549 . 
 1-550 . if (A le B)
 1-551 . {
 1-552 .    A = B + C;
 1-553 .    D = E + F;
 1-554 . }
 1-555 . 
 1-556 . A = B*C;
 1-557 . 
 1-558 . if (A eq B)
 1-559 . {
 1-560 .    A = B + C;
 1-561 .    D = E + F;
 1-562 . }
 1-563 . 
 1-564 . 
 1-565 . if (A ge B)
 1-566 . {
 1-567 .    A = B + C;
 1-568 .    D = E + F;
 1-569 . }
 1-570 . 
 1-571 . A = B*C;
 1-572 . 
 1-573 . switch (rdp stuff)
 1-574 . {
 1-575 .    case one:
 1-576 .    {
 1-577 .       run_this; 
 1-578 .       break;
 1-579 .    }
 1-580 .    case two:
 1-581 .    {
 1-582 .       run_this;
 1-583 .       break;
 1-584 .    }
 1-585 .    default:
 1-586 .    {
 1-587 .        SwError;
 1-588 .    }
 1-589 . }
 1-590 . 
 1-591 . A = B/C;
 1-592 . A = B-C;
 1-593 . /* LE SV TOC-2612 this is a rdp-01.3.39 req to reject*/
 1-594 . A = B*C;
 1-595 . 
 1-596 . if (A == B)
 1-597 . {
 1-598 .    A = B + C;
 1-599 .    D = E + F;
 1-600 . }
 1-601 . 
 1-602 . 
 1-603 . if (A eq B)
 1-604 . {
 1-605 .    A = B + C;
 1-606 .    D = E + F;
 1-607 . }
 1-608 . 
 1-609 . 
 1-610 . switch (rdp stuff)
 1-611 . {
 1-612 .    case:
 1-613 .    case:
 1-614 .    // stacked case statements but only if there is a new line in between
 1-615 . 
 1-616 .    case:
 1-617 .    case:
 1-618 .    case:
 1-619 .    {
 1-620 .       run_this;
 1-621 .       break;
 1-622 .    }
 1-623 .    default:
 1-624 .    {
 1-625 .       halt;
 1-626 .    }
 1-627 . }
 1-628 . 
 1-629 . A = B*C;
 1-630 . A = B*C;
 1-631 . 
 1-632 . if (A eq B)
 1-633 . {
 1-634 .    A = B + C;
 1-635 .    D = E + F;
 1-636 . }
 1-637 . 
 1-638 . A = B+C;
 1-639 . A = B*C;
 1-640 . A = B-C;
 1-641 . 
 1-642 . if (A ge B)
 1-643 . {
 1-644 .    A = B + C;
 1-645 .    D = E + F;
 1-646 . }
 1-647 . 
 1-648 . A = B*C;
 1-649 . A = B/C;
 1-650 . 
 1-651 . if (A != B)
 1-652 . {
 1-653 .    A = B + C;
 1-654 .    D = E + F;
 1-655 . }
 1-656 . 
 1-657 . A = B*C;
 1-658 . A = B+C;
 1-659 . A = B*C;
 1-660 . 
 1-661 . if (A <  B)
 1-662 . {
 1-663 .    A = B + C;
 1-664 .    D = E + F;
 1-665 . }
 1-666 . 
 1-667 . 
 1-668 . if (A > = B)
 1-669 . {
 1-670 .    A = B + C;
 1-671 .    D = E + F;
 1-672 . }
 1-673 . 
 1-674 . 
 1-675 . if (A <  B)
 1-676 . {
 1-677 .    A = B + C;
 1-678 .    D = E + F;
 1-679 . }
 1-680 . 
 1-681 . 
 1-682 . if (A != B)
 1-683 . {
 1-684 .    A = B + C;
 1-685 .    D = E + F;
 1-686 . }
 1-687 . 
 1-688 . A = B/C;
 1-689 . A = B*C;
 1-690 . /* LE SV TOC-2613 this is a rdp-01.3.61 req to set RTC*/
 1-691 . 
 1-692 . if (A gt B)
 1-693 . {
 1-694 .    A = B + C;
 1-695 .    D = E + F;
 1-696 . }
 1-697 . 
 1-698 . 
 1-699 . if (A gt B)
 1-700 . {
 1-701 .    A = B + C;
 1-702 .    D = E + F;
 1-703 . }
 1-704 . 
 1-705 . A = B/C;
 1-706 . A = B-C;
 1-707 . 
 1-708 . if (A != B)
 1-709 . {
 1-710 .    A = B + C;
 1-711 .    D = E + F;
 1-712 . }
 1-713 . 
 1-714 . 
 1-715 . if (A <  B)
 1-716 . {
 1-717 .    A = B + C;
 1-718 .    D = E + F;
 1-719 . }
 1-720 . 
 1-721 . A = B-C;
 1-722 . A = B/C;
 1-723 . A = B*C;
 1-724 . 
 1-725 . if (A gt B)
 1-726 . {
 1-727 .    A = B + C;
 1-728 .    D = E + F;
 1-729 . }
 1-730 . 
 1-731 . 
 1-732 . if (A <  B)
 1-733 . {
 1-734 .    A = B + C;
 1-735 .    D = E + F;
 1-736 . }
 1-737 . 
 1-738 . 
 1-739 . if (A ne B)
 1-740 . {
 1-741 .    A = B + C;
 1-742 .    D = E + F;
 1-743 . }
 1-744 . 
 1-745 . A = B/C;
 1-746 . A = B-C;
 1-747 . A = B/C;
 1-748 . A = B-C;
 1-749 . A = B/C;
 1-750 . 
 1-751 . if (A > = B)
 1-752 . {
 1-753 .    A = B + C;
 1-754 .    D = E + F;
 1-755 . }
 1-756 . 
 1-757 . 
 1-758 . if (A gt B)
 1-759 . {
 1-760 .    A = B + C;
 1-761 .    D = E + F;
 1-762 . }
 1-763 . 
 1-764 . A = B/C;
 1-765 . /* LE SV TOC-2614 this is a rdp-01.3.81 req to translate*/
 1-766 . A = B+C;
 1-767 . A = B/C;
 1-768 . A = B/C;
 1-769 . A = B-C;
 1-770 . A = B/C;
 1-771 . A = B-C;
 1-772 . A = B/C;
 1-773 . 
 1-774 . if (A eq B)
 1-775 . {
 1-776 .    A = B + C;
 1-777 .    D = E + F;
 1-778 . }
 1-779 . 
 1-780 . 
 1-781 . if (A le B)
 1-782 . {
 1-783 .    A = B + C;
 1-784 .    D = E + F;
 1-785 . }
 1-786 . 
 1-787 . A = B-C;
 1-788 . A = B/C;
 1-789 . 
 1-790 . if (A gt B)
 1-791 . {
 1-792 .    A = B + C;
 1-793 .    D = E + F;
 1-794 . }
 1-795 . 
 1-796 . 
 1-797 . if (A ne B)
 1-798 . {
 1-799 .    A = B + C;
 1-800 .    D = E + F;
 1-801 . }
 1-802 . 
 1-803 . A = B*C;
 1-804 . A = B-C;
 1-805 . 
 1-806 . if (A > = B)
 1-807 . {
 1-808 .    A = B + C;
 1-809 .    D = E + F;
 1-810 . }
 1-811 . 
 1-812 . A = B/C;
 1-813 . /* LE SV TOC-2615 this is a rdp-01.3.98 req to convert*/
 1-814 . A = B+C;
 1-815 . // max LOC 98
 1-816 . 
 1-817 . }
 1-818 . 
 1-819 . 
 1-820 . /*
 1-821 . -----------------------------------------------------------------------------
 1-822 . --| NAME:   rdp.1.4
 1-823 . --|
 1-824 . --| ABSTRACT:
 1-825 . --|   This function does rdp stuff.
 1-826 . --|
 1-827 . --| RETURNS:
 1-828 . --|   NONE.
 1-829 . --|
 1-830 . ----------------------------------------------------------------------------
 1-831 . */
 1-832 . static void rdp.1.4(void)
 1-833 . {
 1-834 . 
 1-835 . if (A <  B)
 1-836 . {
 1-837 .    A = B + C;
 1-838 .    D = E + F;
 1-839 . }
 1-840 . 
 1-841 . A = B*C;
 1-842 . A = B/C;
 1-843 . 
 1-844 . if (A lt B)
 1-845 . {
 1-846 .    A = B + C;
 1-847 .    D = E + F;
 1-848 . }
 1-849 . 
 1-850 . A = B+C;
 1-851 . A = B+C;
 1-852 . A = B+C;
 1-853 . // (P) this is really improtant
 1-854 . A = B*C;
 1-855 . A = B+C;
 1-856 . 
 1-857 . if (A >  B)
 1-858 . {
 1-859 .    A = B + C;
 1-860 .    D = E + F;
 1-861 . }
 1-862 . 
 1-863 . 
 1-864 . if (A ge B)
 1-865 . {
 1-866 .    A = B + C;
 1-867 .    D = E + F;
 1-868 . }
 1-869 . 
 1-870 . A = B-C;
 1-871 . A = (float)B + C;
 1-872 . 
 1-873 . if (A ge B)
 1-874 . {
 1-875 .    A = B + C;
 1-876 .    D = E + F;
 1-877 . }
 1-878 . 
 1-879 . do forever;
 1-880 . A = B-C;
 1-881 . A = B/C;
 1-882 . /* LE SV TOC-2616 this is a rdp-01.4.16 req to detect error*/
 1-883 . A = B*C;
 1-884 . A = B/C;
 1-885 . 
 1-886 . switch (rdp stuff)
 1-887 . {
 1-888 .    case one:
 1-889 .    {
 1-890 .       run_this; 
 1-891 .       break;
 1-892 .    }
 1-893 .    case two:
 1-894 .    {
 1-895 .       run_this;
 1-896 .       break;
 1-897 .    }
 1-898 .    default:
 1-899 .    {
 1-900 .        SwError;
 1-901 .    }
 1-902 . }
 1-903 . 
 1-904 . A = B*C;
 1-905 . 
 1-906 . if (A > = B)
 1-907 . {
 1-908 .    A = B + C;
 1-909 .    D = E + F;
 1-910 . }
 1-911 . 
 1-912 . A = B+C;
 1-913 . 
 1-914 . if (A le B)
 1-915 . {
 1-916 .    A = B + C;
 1-917 .    D = E + F;
 1-918 . }
 1-919 . 
 1-920 . A = B+C;
 1-921 . A = B-C;
 1-922 . 
 1-923 . if (A eq B)
 1-924 . {
 1-925 .    A = B + C;
 1-926 .    D = E + F;
 1-927 . }
 1-928 . 
 1-929 . // max LOC 25
 1-930 . 
 1-931 . }
 1-932 . 
 1-933 . 
 1-934 . /*
 1-935 . -----------------------------------------------------------------------------
 1-936 . --| NAME:   rdp.1.5
 1-937 . --|
 1-938 . --| ABSTRACT:
 1-939 . --|   This function does rdp stuff.
 1-940 . --|
 1-941 . --| RETURNS:
 1-942 . --|   NONE.
 1-943 . --|
 1-944 . ----------------------------------------------------------------------------
 1-945 . */
 1-946 . static void rdp.1.5(void)
 1-947 . {
 1-948 . 
 1-949 . if (A >  B)
 1-950 . {
 1-951 .    A = B + C;
 1-952 .    D = E + F;
 1-953 . }
 1-954 . 
 1-955 . /* LE SV TOC-2617 this is a rdp-01.5.2 req to assign*/
 1-956 . A = B*C;
 1-957 . /* LE SV TOC-2618 this is a rdp-01.5.3 req to process*/
 1-958 . A = B/C;
 1-959 . A = B/C;
 1-960 . A = B-C;
 1-961 . A = B-C;
 1-962 . A = B-C;
 1-963 . A = B*C;
 1-964 . 
 1-965 . if (A ne B)
 1-966 . {
 1-967 .    A = B + C;
 1-968 .    D = E + F;
 1-969 . }
 1-970 . 
 1-971 . A = B-C;
 1-972 . A = B-C;
 1-973 . 
 1-974 . if (A le B)
 1-975 . {
 1-976 .    A = B + C;
 1-977 .    D = E + F;
 1-978 . }
 1-979 . 
 1-980 . A = B*C;
 1-981 . A = B/C;
 1-982 . /* LE SV TOC-2619 this is a rdp-01.5.15 req to store*/
 1-983 . A = B-C;
 1-984 . // max LOC 15
 1-985 . 
 1-986 . }
 1-987 . 
 1-988 . 
 1-989 . /*
 1-990 . -----------------------------------------------------------------------------
 1-991 . --| NAME:   rdp.1.6
 1-992 . --|
 1-993 . --| ABSTRACT:
 1-994 . --|   This function does rdp stuff.
 1-995 . --|
 1-996 . --| RETURNS:
 1-997 . --|   NONE.
 1-998 . --|
 1-999 . ----------------------------------------------------------------------------
 1-1000 . */
 1-1001 . static void rdp.1.6(void)
 1-1002 . {
 1-1003 . // max LOC 0
 1-1004 . 
 1-1005 . }
 1-1006 . 

1 1 Result: result/source/pr-app/pr-app-RDP123/rdp-01.c


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

2 2 Result: result/source/pr-app/pr-app-RDP123/rdp-02.c

Settings

Hide Controls Show Checked Summary Checked Details Not Checked All

done
12/08/2003 16:14:07 start
12/08/2003 16:14:08 end