50 50 Source: source/ft-app/ft-app-B1.1/pwr/pwr-08.c
50-0 . /*
50-1 . ----------------------------------------------------------------------------
50-2 . --| BEGIN PROLOGUE
50-3 . --|
50-4 . --| CLASSIFICATION: UNCLASSIFIED
50-5 . --|
50-6 . --| FILE NAME: pwr-08.c
50-7 . --|
50-8 . --| ABSTRACT:
50-9 . --| This file contains the 1 functions that do file pwr stuff.
50-10 . --|
50-11 . --| HISTORY:
50-12 . --| CCCQ_NAME:
50-13 . --| CCCQ_VER:
50-14 . --|
50-15 . --| END PROLOGUE
50-16 . ----------------------------------------------------------------------------
50-17 . */
50-18 .
50-19 . double C;
50-20 . char D;
50-21 . #define D;
50-22 . #define A;
50-23 .
50-24 .
50-25 .
50-26 . /*
50-27 . -----------------------------------------------------------------------------
50-28 . --| NAME: pwr.8.1
50-29 . --|
50-30 . --| ABSTRACT:
50-31 . --| This function does pwr stuff.
50-32 . --|
50-33 . --| RETURNS:
50-34 . --| NONE.
50-35 . --|
50-36 . ----------------------------------------------------------------------------
50-37 . */
50-38 . static void pwr.8.1(void)
50-39 . {
50-40 .
50-41 . if (A ge B)
50-42 . {
50-43 . A = B + C;
50-44 . D = E + F;
50-45 . }
50-46 .
50-47 . A = B+C;
50-48 . A = B/C;
50-49 . A = B-C;
50-50 . A = B/C;
50-51 . A = (long)B + C;
50-52 .
50-53 . if (A != B)
50-54 . {
50-55 . A = B + C;
50-56 . D = E + F;
50-57 . }
50-58 .
50-59 . A = 0x0001;
50-60 .
50-61 . if (A > = B)
50-62 . {
50-63 . A = B + C;
50-64 . D = E + F;
50-65 . }
50-66 .
50-67 . A = B+C;
50-68 . A = B+C;
50-69 . A = B/C;
50-70 .
50-71 . if (A eq B)
50-72 . {
50-73 . A = B + C;
50-74 . D = E + F;
50-75 . }
50-76 .
50-77 .
50-78 . if (A gt B)
50-79 . {
50-80 . A = B + C;
50-81 . D = E + F;
50-82 . }
50-83 .
50-84 . A = B/C;
50-85 . A = B/C;
50-86 . A = B-C;
50-87 . A = B-C;
50-88 . A = B/C;
50-89 . A = B+C;
50-90 .
50-91 . /*
50-92 . dead_block = C * D;
50-93 . dead_block = E * F;
50-94 . */
50-95 .
50-96 . A = B-C;
50-97 .
50-98 . if (A > = B)
50-99 . {
50-100 . A = B + C;
50-101 . D = E + F;
50-102 . }
50-103 .
50-104 . A = B+C;
50-105 . rcv_buffer = (U16 *) alloc(size+1);
50-106 . A = B-C;
50-107 . A = B-C;
50-108 .
50-109 . /*
50-110 . dead_code = B - C;
50-111 . dead_code = D - E;
50-112 . dead_code = F - G;
50-113 . */
50-114 .
50-115 . A = B-C;
50-116 . A = B-C;
50-117 . A = B*C;
50-118 . A = B*C;
50-119 . A = B/C;
50-120 . A = B-C;
50-121 .
50-122 . if (A gt B)
50-123 . {
50-124 . A = B + C;
50-125 . D = E + F;
50-126 . }
50-127 .
50-128 . A = B*C;
50-129 . A = B+C;
50-130 . A = B-C;
50-131 . A = B/C;
50-132 . A = B/C;
50-133 . A = B/C;
50-134 . A = 0x0001;
50-135 . A = B+C;
50-136 . A = B*C;
50-137 . A = B*C;
50-138 .
50-139 . if (A ne B)
50-140 . {
50-141 . A = B + C;
50-142 . D = E + F;
50-143 . }
50-144 .
50-145 . A = B+C;
50-146 . // ??? go see ws
50-147 .
50-148 . if (A != B)
50-149 . {
50-150 . A = B + C;
50-151 . D = E + F;
50-152 . }
50-153 .
50-154 .
50-155 . if (A lt B)
50-156 . {
50-157 . A = B + C;
50-158 . D = E + F;
50-159 . }
50-160 .
50-161 . A = B-C;
50-162 . A = B/C;
50-163 . A = B-C;
50-164 . A = B+C;
50-165 . A = B+C;
50-166 . A = B*C;
50-167 . A = B*C;
50-168 . A = B+C;
50-169 .
50-170 . if (A gt B)
50-171 . {
50-172 . A = B + C;
50-173 . D = E + F;
50-174 . }
50-175 .
50-176 .
50-177 . if (A ge B)
50-178 . {
50-179 . A = B + C;
50-180 . D = E + F;
50-181 . }
50-182 .
50-183 . A = B-C;
50-184 . A = B-C;
50-185 . A = B*C;
50-186 . /* LE SV TOC-2547 this is a pwr-08.1.57 req to set RTC*/
50-187 . A = B/C;
50-188 . A = B-C;
50-189 . A = B*C;
50-190 . A = B-C;
50-191 .
50-192 . if (A > = B)
50-193 . {
50-194 . A = B + C;
50-195 . D = E + F;
50-196 . }
50-197 .
50-198 .
50-199 . if (A le B)
50-200 . {
50-201 . A = B + C;
50-202 . D = E + F;
50-203 . }
50-204 .
50-205 .
50-206 . if (A != B)
50-207 . {
50-208 . A = B + C;
50-209 . D = E + F;
50-210 . }
50-211 .
50-212 . A = B*C;
50-213 . A = B-C;
50-214 . // max LOC 65
50-215 .
50-216 . }
50-217 .
50 50 Result: result/source/ft-app/ft-app-B1.1/pwr/pwr-08.c
51 51 Source: source/ft-app/ft-app-B1.1/rdp/rdp-01.c
51-0 . /*
51-1 . ----------------------------------------------------------------------------
51-2 . --| BEGIN PROLOGUE
51-3 . --|
51-4 . --| CLASSIFICATION: UNCLASSIFIED
51-5 . --|
51-6 . --| FILE NAME: rdp-01.c
51-7 . --|
51-8 . --| ABSTRACT:
51-9 . --| This file contains the 6 functions that do file rdp stuff.
51-10 . --|
51-11 . --| HISTORY:
51-12 . --| CCCQ_NAME:
51-13 . --| CCCQ_VER:
51-14 . --|
51-15 . --| END PROLOGUE
51-16 . ----------------------------------------------------------------------------
51-17 . */
51-18 .
51-19 . #define D;
51-20 . float B;
51-21 . #define B;
51-22 . #define B;
51-23 . float B;
51-24 .
51-25 .
51-26 .
51-27 . /*
51-28 . -----------------------------------------------------------------------------
51-29 . --| NAME: rdp.1.1
51-30 . --|
51-31 . --| ABSTRACT:
51-32 . --| This function does rdp stuff.
51-33 . --|
51-34 . --| RETURNS:
51-35 . --| NONE.
51-36 . --|
51-37 . ----------------------------------------------------------------------------
51-38 . */
51-39 . static void rdp.1.1(void)
51-40 . {
51-41 . A = B+C;
51-42 .
51-43 . if (A ne B)
51-44 . {
51-45 . A = B + C;
51-46 . D = E + F;
51-47 . }
51-48 .
51-49 . A = B+C;
51-50 .
51-51 . switch (rdp stuff)
51-52 . {
51-53 . case one:
51-54 . {
51-55 . run_this;
51-56 . break;
51-57 . }
51-58 . case two:
51-59 . {
51-60 . run_this;
51-61 . break;
51-62 . }
51-63 . default:
51-64 . {
51-65 . SwError;
51-66 . }
51-67 . }
51-68 .
51-69 . /* LE SV TOC-2601 this is a rdp-01.1.5 req to disable*/
51-70 . A = B*C;
51-71 .
51-72 . if (A == B)
51-73 . {
51-74 . A = B + C;
51-75 . D = E + F;
51-76 . }
51-77 .
51-78 .
51-79 . if (A lt B)
51-80 . {
51-81 . A = B + C;
51-82 . D = E + F;
51-83 . }
51-84 .
51-85 . // max LOC 7
51-86 .
51-87 . }
51-88 .
51-89 .
51-90 . /*
51-91 . -----------------------------------------------------------------------------
51-92 . --| NAME: rdp.1.2
51-93 . --|
51-94 . --| ABSTRACT:
51-95 . --| This function does rdp stuff.
51-96 . --|
51-97 . --| RETURNS:
51-98 . --| NONE.
51-99 . --|
51-100 . ----------------------------------------------------------------------------
51-101 . */
51-102 . static void rdp.1.2(void)
51-103 . {
51-104 . A = B*C;
51-105 . A = B+C;
51-106 . /* LE SV TOC-2602 this is a rdp-01.2.3 req to recover*/
51-107 .
51-108 . switch (rdp stuff)
51-109 . {
51-110 . case one:
51-111 . {
51-112 . run_this;
51-113 . break;
51-114 . }
51-115 . case two:
51-116 . {
51-117 . run_this;
51-118 . break;
51-119 . }
51-120 . default:
51-121 . {
51-122 . SwError;
51-123 . }
51-124 . }
51-125 .
51-126 . A = B+C;
51-127 . A = B-C;
51-128 .
51-129 . if (A > = B)
51-130 . {
51-131 . A = B + C;
51-132 . D = E + F;
51-133 . }
51-134 .
51-135 . A = B+C;
51-136 . A = B+C;
51-137 . /* LE SV TOC-2603 this is a rdp-01.2.9 req to enable*/
51-138 . A = (int)B + C;
51-139 . A = B-C;
51-140 . /* LE SV TOC-2604 this is a rdp-01.2.10 req to record*/
51-141 .
51-142 . if (A != B)
51-143 . {
51-144 . A = B + C;
51-145 . D = E + F;
51-146 . }
51-147 .
51-148 . A = B-C;
51-149 .
51-150 . if (A lt B)
51-151 . {
51-152 . A = B + C;
51-153 . D = E + F;
51-154 . }
51-155 .
51-156 .
51-157 . switch (rdp stuff)
51-158 . {
51-159 . case one:
51-160 . {
51-161 . run_this;
51-162 . break;
51-163 . }
51-164 . case two:
51-165 . {
51-166 . run_this;
51-167 . break;
51-168 . }
51-169 . default:
51-170 . {
51-171 . SwError;
51-172 . }
51-173 . }
51-174 .
51-175 .
51-176 . if (A le B)
51-177 . {
51-178 . A = B + C;
51-179 . D = E + F;
51-180 . }
51-181 .
51-182 . A = B+C;
51-183 . A = B-C;
51-184 .
51-185 . switch (rdp stuff)
51-186 . {
51-187 . case one:
51-188 . {
51-189 . run_this;
51-190 . break;
51-191 . }
51-192 . case two:
51-193 . {
51-194 . run_this;
51-195 . break;
51-196 . }
51-197 . default:
51-198 . {
51-199 . SwError;
51-200 . }
51-201 . }
51-202 .
51-203 . A = B/C;
51-204 . A = B*C;
51-205 .
51-206 . if (A == B)
51-207 . {
51-208 . A = B + C;
51-209 . D = E + F;
51-210 . }
51-211 .
51-212 . A = B-C;
51-213 . rcv_buffer = (U16 *) alloc(size+1);
51-214 . A = B-C;
51-215 .
51-216 . if (A gt B)
51-217 . {
51-218 . A = B + C;
51-219 . D = E + F;
51-220 . }
51-221 .
51-222 . A = B-C;
51-223 . A = B-C;
51-224 . A = B+C;
51-225 . A = B/C;
51-226 .
51-227 . if (A gt B)
51-228 . {
51-229 . A = B + C;
51-230 . D = E + F;
51-231 . }
51-232 .
51-233 . A = B/C;
51-234 .
51-235 . if (A == B)
51-236 . {
51-237 . A = B + C;
51-238 . D = E + F;
51-239 . }
51-240 .
51-241 . A = B*C;
51-242 . A = B*C;
51-243 .
51-244 . if (A < = B)
51-245 . {
51-246 . A = B + C;
51-247 . D = E + F;
51-248 . }
51-249 .
51-250 . A = B/C;
51-251 . A = B/C;
51-252 .
51-253 . if (A > = B)
51-254 . {
51-255 . A = B + C;
51-256 . D = E + F;
51-257 . }
51-258 .
51-259 . A = B*C;
51-260 . A = B/C;
51-261 . A = B-C;
51-262 . A = B*C;
51-263 . /* LE SV TOC-2605 this is a rdp-01.2.41 req to process*/
51-264 . A = B/C;
51-265 . A = B+C;
51-266 . A = B*C;
51-267 .
51-268 . if (A ge B)
51-269 . {
51-270 . A = B + C;
51-271 . D = E + F;
51-272 . }
51-273 .
51-274 . /* LE SV TOC-2606 this is a rdp-01.2.45 req to record*/
51-275 . A = B+C;
51-276 .
51-277 . if (A ne B)
51-278 . {
51-279 . A = B + C;
51-280 . D = E + F;
51-281 . }
51-282 .
51-283 . A = B/C;
51-284 .
51-285 . if (A > B)
51-286 . {
51-287 . A = B + C;
51-288 . D = E + F;
51-289 . }
51-290 .
51-291 . A = B*C;
51-292 .
51-293 . if (A lt B)
51-294 . {
51-295 . A = B + C;
51-296 . D = E + F;
51-297 . }
51-298 .
51-299 .
51-300 . /* dead_block = C * D;
51-301 . dead_block = E * F; */
51-302 .
51-303 . A = B+C;
51-304 .
51-305 . if (A == B)
51-306 . {
51-307 . A = B + C;
51-308 . D = E + F;
51-309 . }
51-310 .
51-311 .
51-312 . if (A > = B)
51-313 . {
51-314 . A = B + C;
51-315 . D = E + F;
51-316 . }
51-317 .
51-318 . /* LE SV TOC-2607 this is a rdp-01.2.54 req to disable*/
51-319 .
51-320 . if (A gt B)
51-321 . {
51-322 . A = B + C;
51-323 . D = E + F;
51-324 . }
51-325 .
51-326 .
51-327 . if (A > B)
51-328 . {
51-329 . A = B + C;
51-330 . D = E + F;
51-331 . }
51-332 .
51-333 . A = B/C;
51-334 . A = B*C;
51-335 . A = B+C;
51-336 .
51-337 . if (A ge B)
51-338 . {
51-339 . A = B + C;
51-340 . D = E + F;
51-341 . }
51-342 .
51-343 .
51-344 . if (A < = B)
51-345 . {
51-346 . A = B + C;
51-347 . D = E + F;
51-348 . }
51-349 .
51-350 . A = B*C;
51-351 . A = B-C;
51-352 .
51-353 . if (A lt B)
51-354 . {
51-355 . A = B + C;
51-356 . D = E + F;
51-357 . }
51-358 .
51-359 . A = B-C;
51-360 . A = B/C;
51-361 . A = B*C;
51-362 . A = B*C;
51-363 .
51-364 . if (A == B)
51-365 . {
51-366 . A = B + C;
51-367 . D = E + F;
51-368 . }
51-369 .
51-370 . A = B/C;
51-371 . A = B/C;
51-372 . A = B-C;
51-373 . // TBD - what do I do now
51-374 .
51-375 . if (A lt B)
51-376 . {
51-377 . A = B + C;
51-378 . D = E + F;
51-379 . }
51-380 .
51-381 . // max LOC 72
51-382 .
51-383 . }
51-384 .
51-385 .
51-386 . /*
51-387 . -----------------------------------------------------------------------------
51-388 . --| NAME: rdp.1.3
51-389 . --|
51-390 . --| ABSTRACT:
51-391 . --| This function does rdp stuff.
51-392 . --|
51-393 . --| RETURNS:
51-394 . --| NONE.
51-395 . --|
51-396 . ----------------------------------------------------------------------------
51-397 . */
51-398 . static void rdp.1.3(void)
51-399 . {
51-400 .
51-401 . if (A gt B)
51-402 . {
51-403 . A = B + C;
51-404 . D = E + F;
51-405 . }
51-406 .
51-407 . /* LE SV TOC-2608 this is a rdp-01.3.2 req to check pSOS*/
51-408 .
51-409 . if (A != B)
51-410 . {
51-411 . A = B + C;
51-412 . D = E + F;
51-413 . }
51-414 .
51-415 . A = B*C;
51-416 . A = B/C;
51-417 . A = B/C;
51-418 . // (P) this is really improtant
51-419 . A = B-C;
51-420 . A = B*C;
51-421 . A = B/C;
51-422 .
51-423 . if (A gt B)
51-424 . {
51-425 . A = B + C;
51-426 . D = E + F;
51-427 . }
51-428 .
51-429 .
51-430 . switch (rdp stuff)
51-431 . {
51-432 . case one:
51-433 . {
51-434 . run_this;
51-435 . break;
51-436 . }
51-437 . case two:
51-438 . {
51-439 . run_this;
51-440 . break;
51-441 . }
51-442 . default:
51-443 . {
51-444 . SwError;
51-445 . }
51-446 . }
51-447 .
51-448 . A = B/C;
51-449 . A = B/C;
51-450 . A = B/C;
51-451 . /* LE SV TOC-2609 this is a rdp-01.3.14 req to verify*/
51-452 . A = B*C;
51-453 . /* LE SV TOC-2610 this is a rdp-01.3.15 req to increment*/
51-454 .
51-455 . if (A le B)
51-456 . {
51-457 . A = B + C;
51-458 . D = E + F;
51-459 . }
51-460 .
51-461 . A = B/C;
51-462 .
51-463 . switch (rdp stuff)
51-464 . {
51-465 . case one:
51-466 . {
51-467 . switch (nested)
51-468 . {
51-469 . case:
51-470 . X = Y + Z;
51-471 . case:
51-472 . X = Y + Z;
51-473 . default:
51-474 . SwError;
51-475 . }
51-476 . }
51-477 . case two:
51-478 . {
51-479 . run_this;
51-480 . break;
51-481 . }
51-482 . default:
51-483 . {
51-484 . SwError;
51-485 . }
51-486 . }
51-487 .
51-488 . A = B/C;
51-489 . A = B/C;
51-490 .
51-491 . /* dead_block = C * D;
51-492 . dead_block = E * F; */
51-493 .
51-494 .
51-495 . if (A ne B)
51-496 . {
51-497 . A = B + C;
51-498 . D = E + F;
51-499 . }
51-500 .
51-501 . A = B+C;
51-502 . A = B*C;
51-503 . A = B+C;
51-504 .
51-505 . if (A > B)
51-506 . {
51-507 . A = B + C;
51-508 . D = E + F;
51-509 . }
51-510 .
51-511 .
51-512 . if (A < B)
51-513 . {
51-514 . A = B + C;
51-515 . D = E + F;
51-516 . }
51-517 .
51-518 . /* LE SV TOC-2611 this is a rdp-01.3.25 req to reject*/
51-519 .
51-520 . if (A != B)
51-521 . {
51-522 . A = B + C;
51-523 . D = E + F;
51-524 . }
51-525 .
51-526 . A = B/C;
51-527 .
51-528 . if (A < B)
51-529 . {
51-530 . A = B + C;
51-531 . D = E + F;
51-532 . }
51-533 .
51-534 .
51-535 . if (A gt B)
51-536 . {
51-537 . A = B + C;
51-538 . D = E + F;
51-539 . }
51-540 .
51-541 . A = B/C;
51-542 .
51-543 . if (A > = B)
51-544 . {
51-545 . A = B + C;
51-546 . D = E + F;
51-547 . }
51-548 .
51-549 .
51-550 . if (A le B)
51-551 . {
51-552 . A = B + C;
51-553 . D = E + F;
51-554 . }
51-555 .
51-556 . A = B*C;
51-557 .
51-558 . if (A eq B)
51-559 . {
51-560 . A = B + C;
51-561 . D = E + F;
51-562 . }
51-563 .
51-564 .
51-565 . if (A ge B)
51-566 . {
51-567 . A = B + C;
51-568 . D = E + F;
51-569 . }
51-570 .
51-571 . A = B*C;
51-572 .
51-573 . switch (rdp stuff)
51-574 . {
51-575 . case one:
51-576 . {
51-577 . run_this;
51-578 . break;
51-579 . }
51-580 . case two:
51-581 . {
51-582 . run_this;
51-583 . break;
51-584 . }
51-585 . default:
51-586 . {
51-587 . SwError;
51-588 . }
51-589 . }
51-590 .
51-591 . A = B/C;
51-592 . A = B-C;
51-593 . /* LE SV TOC-2612 this is a rdp-01.3.39 req to reject*/
51-594 . A = B*C;
51-595 .
51-596 . if (A == B)
51-597 . {
51-598 . A = B + C;
51-599 . D = E + F;
51-600 . }
51-601 .
51-602 .
51-603 . if (A eq B)
51-604 . {
51-605 . A = B + C;
51-606 . D = E + F;
51-607 . }
51-608 .
51-609 .
51-610 . switch (rdp stuff)
51-611 . {
51-612 . case:
51-613 . case:
51-614 . // stacked case statements but only if there is a new line in between
51-615 .
51-616 . case:
51-617 . case:
51-618 . case:
51-619 . {
51-620 . run_this;
51-621 . break;
51-622 . }
51-623 . default:
51-624 . {
51-625 . halt;
51-626 . }
51-627 . }
51-628 .
51-629 . A = B*C;
51-630 . A = B*C;
51-631 .
51-632 . if (A eq B)
51-633 . {
51-634 . A = B + C;
51-635 . D = E + F;
51-636 . }
51-637 .
51-638 . A = B+C;
51-639 . A = B*C;
51-640 . A = B-C;
51-641 .
51-642 . if (A ge B)
51-643 . {
51-644 . A = B + C;
51-645 . D = E + F;
51-646 . }
51-647 .
51-648 . A = B*C;
51-649 . A = B/C;
51-650 .
51-651 . if (A != B)
51-652 . {
51-653 . A = B + C;
51-654 . D = E + F;
51-655 . }
51-656 .
51-657 . A = B*C;
51-658 . A = B+C;
51-659 . A = B*C;
51-660 .
51-661 . if (A < B)
51-662 . {
51-663 . A = B + C;
51-664 . D = E + F;
51-665 . }
51-666 .
51-667 .
51-668 . if (A > = B)
51-669 . {
51-670 . A = B + C;
51-671 . D = E + F;
51-672 . }
51-673 .
51-674 .
51-675 . if (A < B)
51-676 . {
51-677 . A = B + C;
51-678 . D = E + F;
51-679 . }
51-680 .
51-681 .
51-682 . if (A != B)
51-683 . {
51-684 . A = B + C;
51-685 . D = E + F;
51-686 . }
51-687 .
51-688 . A = B/C;
51-689 . A = B*C;
51-690 . /* LE SV TOC-2613 this is a rdp-01.3.61 req to set RTC*/
51-691 .
51-692 . if (A gt B)
51-693 . {
51-694 . A = B + C;
51-695 . D = E + F;
51-696 . }
51-697 .
51-698 .
51-699 . if (A gt B)
51-700 . {
51-701 . A = B + C;
51-702 . D = E + F;
51-703 . }
51-704 .
51-705 . A = B/C;
51-706 . A = B-C;
51-707 .
51-708 . if (A != B)
51-709 . {
51-710 . A = B + C;
51-711 . D = E + F;
51-712 . }
51-713 .
51-714 .
51-715 . if (A < B)
51-716 . {
51-717 . A = B + C;
51-718 . D = E + F;
51-719 . }
51-720 .
51-721 . A = B-C;
51-722 . A = B/C;
51-723 . A = B*C;
51-724 .
51-725 . if (A gt B)
51-726 . {
51-727 . A = B + C;
51-728 . D = E + F;
51-729 . }
51-730 .
51-731 .
51-732 . if (A < B)
51-733 . {
51-734 . A = B + C;
51-735 . D = E + F;
51-736 . }
51-737 .
51-738 .
51-739 . if (A ne B)
51-740 . {
51-741 . A = B + C;
51-742 . D = E + F;
51-743 . }
51-744 .
51-745 . A = B/C;
51-746 . A = B-C;
51-747 . A = B/C;
51-748 . A = B-C;
51-749 . A = B/C;
51-750 .
51-751 . if (A > = B)
51-752 . {
51-753 . A = B + C;
51-754 . D = E + F;
51-755 . }
51-756 .
51-757 .
51-758 . if (A gt B)
51-759 . {
51-760 . A = B + C;
51-761 . D = E + F;
51-762 . }
51-763 .
51-764 . A = B/C;
51-765 . /* LE SV TOC-2614 this is a rdp-01.3.81 req to translate*/
51-766 . A = B+C;
51-767 . A = B/C;
51-768 . A = B/C;
51-769 . A = B-C;
51-770 . A = B/C;
51-771 . A = B-C;
51-772 . A = B/C;
51-773 .
51-774 . if (A eq B)
51-775 . {
51-776 . A = B + C;
51-777 . D = E + F;
51-778 . }
51-779 .
51-780 .
51-781 . if (A le B)
51-782 . {
51-783 . A = B + C;
51-784 . D = E + F;
51-785 . }
51-786 .
51-787 . A = B-C;
51-788 . A = B/C;
51-789 .
51-790 . if (A gt B)
51-791 . {
51-792 . A = B + C;
51-793 . D = E + F;
51-794 . }
51-795 .
51-796 .
51-797 . if (A ne B)
51-798 . {
51-799 . A = B + C;
51-800 . D = E + F;
51-801 . }
51-802 .
51-803 . A = B*C;
51-804 . A = B-C;
51-805 .
51-806 . if (A > = B)
51-807 . {
51-808 . A = B + C;
51-809 . D = E + F;
51-810 . }
51-811 .
51-812 . A = B/C;
51-813 . /* LE SV TOC-2615 this is a rdp-01.3.98 req to convert*/
51-814 . A = B+C;
51-815 . // max LOC 98
51-816 .
51-817 . }
51-818 .
51-819 .
51-820 . /*
51-821 . -----------------------------------------------------------------------------
51-822 . --| NAME: rdp.1.4
51-823 . --|
51-824 . --| ABSTRACT:
51-825 . --| This function does rdp stuff.
51-826 . --|
51-827 . --| RETURNS:
51-828 . --| NONE.
51-829 . --|
51-830 . ----------------------------------------------------------------------------
51-831 . */
51-832 . static void rdp.1.4(void)
51-833 . {
51-834 .
51-835 . if (A < B)
51-836 . {
51-837 . A = B + C;
51-838 . D = E + F;
51-839 . }
51-840 .
51-841 . A = B*C;
51-842 . A = B/C;
51-843 .
51-844 . if (A lt B)
51-845 . {
51-846 . A = B + C;
51-847 . D = E + F;
51-848 . }
51-849 .
51-850 . A = B+C;
51-851 . A = B+C;
51-852 . A = B+C;
51-853 . // (P) this is really improtant
51-854 . A = B*C;
51-855 . A = B+C;
51-856 .
51-857 . if (A > B)
51-858 . {
51-859 . A = B + C;
51-860 . D = E + F;
51-861 . }
51-862 .
51-863 .
51-864 . if (A ge B)
51-865 . {
51-866 . A = B + C;
51-867 . D = E + F;
51-868 . }
51-869 .
51-870 . A = B-C;
51-871 . A = (float)B + C;
51-872 .
51-873 . if (A ge B)
51-874 . {
51-875 . A = B + C;
51-876 . D = E + F;
51-877 . }
51-878 .
51-879 . do forever;
51-880 . A = B-C;
51-881 . A = B/C;
51-882 . /* LE SV TOC-2616 this is a rdp-01.4.16 req to detect error*/
51-883 . A = B*C;
51-884 . A = B/C;
51-885 .
51-886 . switch (rdp stuff)
51-887 . {
51-888 . case one:
51-889 . {
51-890 . run_this;
51-891 . break;
51-892 . }
51-893 . case two:
51-894 . {
51-895 . run_this;
51-896 . break;
51-897 . }
51-898 . default:
51-899 . {
51-900 . SwError;
51-901 . }
51-902 . }
51-903 .
51-904 . A = B*C;
51-905 .
51-906 . if (A > = B)
51-907 . {
51-908 . A = B + C;
51-909 . D = E + F;
51-910 . }
51-911 .
51-912 . A = B+C;
51-913 .
51-914 . if (A le B)
51-915 . {
51-916 . A = B + C;
51-917 . D = E + F;
51-918 . }
51-919 .
51-920 . A = B+C;
51-921 . A = B-C;
51-922 .
51-923 . if (A eq B)
51-924 . {
51-925 . A = B + C;
51-926 . D = E + F;
51-927 . }
51-928 .
51-929 . // max LOC 25
51-930 .
51-931 . }
51-932 .
51-933 .
51-934 . /*
51-935 . -----------------------------------------------------------------------------
51-936 . --| NAME: rdp.1.5
51-937 . --|
51-938 . --| ABSTRACT:
51-939 . --| This function does rdp stuff.
51-940 . --|
51-941 . --| RETURNS:
51-942 . --| NONE.
51-943 . --|
51-944 . ----------------------------------------------------------------------------
51-945 . */
51-946 . static void rdp.1.5(void)
51-947 . {
51-948 .
51-949 . if (A > B)
51-950 . {
51-951 . A = B + C;
51-952 . D = E + F;
51-953 . }
51-954 .
51-955 . /* LE SV TOC-2617 this is a rdp-01.5.2 req to assign*/
51-956 . A = B*C;
51-957 . /* LE SV TOC-2618 this is a rdp-01.5.3 req to process*/
51-958 . A = B/C;
51-959 . A = B/C;
51-960 . A = B-C;
51-961 . A = B-C;
51-962 . A = B-C;
51-963 . A = B*C;
51-964 .
51-965 . if (A ne B)
51-966 . {
51-967 . A = B + C;
51-968 . D = E + F;
51-969 . }
51-970 .
51-971 . A = B-C;
51-972 . A = B-C;
51-973 .
51-974 . if (A le B)
51-975 . {
51-976 . A = B + C;
51-977 . D = E + F;
51-978 . }
51-979 .
51-980 . A = B*C;
51-981 . A = B/C;
51-982 . /* LE SV TOC-2619 this is a rdp-01.5.15 req to store*/
51-983 . A = B-C;
51-984 . // max LOC 15
51-985 .
51-986 . }
51-987 .
51-988 .
51-989 . /*
51-990 . -----------------------------------------------------------------------------
51-991 . --| NAME: rdp.1.6
51-992 . --|
51-993 . --| ABSTRACT:
51-994 . --| This function does rdp stuff.
51-995 . --|
51-996 . --| RETURNS:
51-997 . --| NONE.
51-998 . --|
51-999 . ----------------------------------------------------------------------------
51-1000 . */
51-1001 . static void rdp.1.6(void)
51-1002 . {
51-1003 . // max LOC 0
51-1004 .
51-1005 . }
51-1006 .
51 51 Result: result/source/ft-app/ft-app-B1.1/rdp/rdp-01.c
52 52 Source: source/ft-app/ft-app-B1.1/rdp/rdp-02.c
52-0 . /*
52-1 . ----------------------------------------------------------------------------
52-2 . --| BEGIN PROLOGUE
52-3 . --|
52-4 . --| CLASSIFICATION: UNCLASSIFIED
52-5 . --|
52-6 . --| FILE NAME: rdp-02.c
52-7 . --|
52-8 . --| ABSTRACT:
52-9 . --| This file contains the 10 functions that do file rdp stuff.
52-10 . --|
52-11 . --| HISTORY:
52-12 . --| CCCQ_NAME:
52-13 . --| CCCQ_VER:
52-14 . --|
52-15 . --| END PROLOGUE
52-16 . ----------------------------------------------------------------------------
52-17 . */
52-18 .
52-19 . #include D;
52-20 . #define B;
52-21 . int A;
52-22 .
52-23 .
52-24 .
52-25 . /*
52-26 . -----------------------------------------------------------------------------
52-27 . --| NAME: rdp.2.1
52-28 . --|
52-29 . --| ABSTRACT:
52-30 . --| This function does rdp stuff.
52-31 . --|
52-32 . --| RETURNS:
52-33 . --| NONE.
52-34 . --|
52-35 . ----------------------------------------------------------------------------
52-36 . */
52-37 . static void rdp.2.1(void)
52-38 . {
52-39 . A = B*C;
52-40 . A = B/C;
52-41 . A = B+C;
52-42 . A = B-C;
52-43 .
52-44 . if (A != B)
52-45 . {
52-46 . A = B + C;
52-47 . D = E + F;
52-48 . }
52-49 .
52-50 . A = B*C;
52-51 .
52-52 . if (A eq B)
52-53 . {
52-54 . A = B + C;
52-55 . D = E + F;
52-56 . }
52-57 .
52-58 . A = B/C;
52-59 . A = B+C;
52-60 .
52-61 . if (A == B)
52-62 . {
52-63 . A = B + C;
52-64 . D = E + F;
52-65 . }
52-66 .
52-67 . A = B+C;
52-68 . A = B*C;
52-69 . /* LE SV TOC-2620 this is a rdp-02.1.13 req to check pSOS*/
52-70 . A = B-C;
52-71 . A = B-C;
52-72 .
52-73 . if (A ge B)
52-74 . {
52-75 . A = B + C;
52-76 . D = E + F;
52-77 . }
52-78 .
52-79 . A = B-C;
52-80 . /* LE SV TOC-2621 this is a rdp-02.1.17 req to reject*/
52-81 .
52-82 . if (A ne B)
52-83 . {
52-84 . A = B + C;
52-85 . D = E + F;
52-86 . }
52-87 .
52-88 . /* LE SV TOC-2622 this is a rdp-02.1.18 req to check unix*/
52-89 . A = B-C;
52-90 . A = B/C;
52-91 . A = 0x0008;
52-92 . A = B-C;
52-93 . A = B*C;
52-94 . A = B+C;
52-95 . /* LE SV TOC-2623 this is a rdp-02.1.23 req to update*/
52-96 . A = 0x0003;
52-97 . A = B+C;
52-98 .
52-99 . if (A > B)
52-100 . {
52-101 . A = B + C;
52-102 . D = E + F;
52-103 . }
52-104 .
52-105 . A = B+C;
52-106 .
52-107 . if (A le B)
52-108 . {
52-109 . A = B + C;
52-110 . D = E + F;
52-111 . }
52-112 .
52-113 . // (P) this is really improtant
52-114 . A = B/C;
52-115 .
52-116 . if (A < = B)
52-117 . {
52-118 . A = B + C;
52-119 . D = E + F;
52-120 . }
52-121 .
52-122 . A = B/C;
52-123 . A = B/C;
52-124 . A = B*C;
52-125 . A = B*C;
52-126 .
52-127 . if (A == B)
52-128 . {
52-129 . A = B + C;
52-130 . D = E + F;
52-131 . }
52-132 .
52-133 . A = 0x0004;
52-134 . A = B+C;
52-135 . A = B+C;
52-136 .
52-137 . if (A ne B)
52-138 . {
52-139 . A = B + C;
52-140 . D = E + F;
52-141 . }
52-142 .
52-143 . A = B-C;
52-144 . A = B-C;
52-145 . A = B*C;
52-146 . A = B+C;
52-147 . /* LE SV TOC-2624 this is a rdp-02.1.41 req to compare*/
52-148 . A = B-C;
52-149 . A = B-C;
52-150 . A = B+C;
52-151 . A = B/C;
52-152 . A = B*C;
52-153 . A = B-C;
52-154 . A = B/C;
52-155 . A = B*C;
52-156 .
52-157 . if (A gt B)
52-158 . {
52-159 . A = B + C;
52-160 . D = E + F;
52-161 . }
52-162 .
52-163 .
52-164 . if (A eq B)
52-165 . {
52-166 . A = B + C;
52-167 . D = E + F;
52-168 . }
52-169 .
52-170 . A = B+C;
52-171 . A = B+C;
52-172 .
52-173 . if (A < B)
52-174 . {
52-175 . A = B + C;
52-176 . D = E + F;
52-177 . }
52-178 .
52-179 . A = B/C;
52-180 .
52-181 . if (A le B)
52-182 . {
52-183 . A = B + C;
52-184 . D = E + F;
52-185 . }
52-186 .
52-187 . // max LOC 55
52-188 .
52-189 . }
52-190 .
52-191 .
52-192 . /*
52-193 . -----------------------------------------------------------------------------
52-194 . --| NAME: rdp.2.2
52-195 . --|
52-196 . --| ABSTRACT:
52-197 . --| This function does rdp stuff.
52-198 . --|
52-199 . --| RETURNS:
52-200 . --| NONE.
52-201 . --|
52-202 . ----------------------------------------------------------------------------
52-203 . */
52-204 . static void rdp.2.2(void)
52-205 . {
52-206 .
52-207 . if (A eq B)
52-208 . {
52-209 . A = B + C;
52-210 . D = E + F;
52-211 . }
52-212 .
52-213 . A = B+C;
52-214 . A = B/C;
52-215 .
52-216 . if (A == B)
52-217 . {
52-218 . A = B + C;
52-219 . D = E + F;
52-220 . }
52-221 .
52-222 . A = B-C;
52-223 . A = B+C;
52-224 . A = B-C;
52-225 . A = B-C;
52-226 . A = B/C;
52-227 . A = (long)B + C;
52-228 .
52-229 . if (A > B)
52-230 . {
52-231 . A = B + C;
52-232 . D = E + F;
52-233 . }
52-234 .
52-235 .
52-236 . if (A lt B)
52-237 . {
52-238 . A = B + C;
52-239 . D = E + F;
52-240 . }
52-241 .
52-242 . A = B/C;
52-243 . A = B/C;
52-244 . /* LE SV TOC-2625 this is a rdp-02.2.14 req to process*/
52-245 .
52-246 . if (A gt B)
52-247 . {
52-248 . A = B + C;
52-249 . D = E + F;
52-250 . }
52-251 .
52-252 . A = B/C;
52-253 .
52-254 . if (A gt B)
52-255 . {
52-256 . A = B + C;
52-257 . D = E + F;
52-258 . }
52-259 .
52-260 . A = B+C;
52-261 .
52-262 . if (A < B)
52-263 . {
52-264 . A = B + C;
52-265 . D = E + F;
52-266 . }
52-267 .
52-268 . /* LE SV TOC-2626 this is a rdp-02.2.19 req to audit*/
52-269 . A = B+C;
52-270 . A = B-C;
52-271 . A = B/C;
52-272 . // max LOC 21
52-273 .
52-274 . }
52-275 .
52-276 .
52-277 . /*
52-278 . -----------------------------------------------------------------------------
52-279 . --| NAME: rdp.2.3
52-280 . --|
52-281 . --| ABSTRACT:
52-282 . --| This function does rdp stuff.
52-283 . --|
52-284 . --| RETURNS:
52-285 . --| NONE.
52-286 . --|
52-287 . ----------------------------------------------------------------------------
52-288 . */
52-289 . static void rdp.2.3(void)
52-290 . {
52-291 . A = B*C;
52-292 . A = B-C;
52-293 . A = 0x0003;
52-294 . A = B+C;
52-295 . A = B*C;
52-296 . A = (long)B + C;
52-297 . A = B*C;
52-298 .
52-299 . if (A == B)
52-300 . {
52-301 . A = B + C;
52-302 . D = E + F;
52-303 . }
52-304 .
52-305 . A = B/C;
52-306 . A = B-C;
52-307 . A = B/C;
52-308 .
52-309 . if (A < = B)
52-310 . {
52-311 . A = B + C;
52-312 . D = E + F;
52-313 . }
52-314 .
52-315 .
52-316 . if (A > B)
52-317 . {
52-318 . A = B + C;
52-319 . D = E + F;
52-320 . }
52-321 .
52-322 . // max LOC 11
52-323 .
52-324 . }
52-325 .
52-326 .
52-327 . /*
52-328 . -----------------------------------------------------------------------------
52-329 . --| NAME: rdp.2.4
52-330 . --|
52-331 . --| ABSTRACT:
52-332 . --| This function does rdp stuff.
52-333 . --|
52-334 . --| RETURNS:
52-335 . --| NONE.
52-336 . --|
52-337 . ----------------------------------------------------------------------------
52-338 . */
52-339 . static void rdp.2.4(void)
52-340 . {
52-341 . A = B*C;
52-342 . A = B*C;
52-343 .
52-344 . if (A ge B)
52-345 . {
52-346 . A = B + C;
52-347 . D = E + F;
52-348 . }
52-349 .
52-350 . A = B+C;
52-351 .
52-352 . switch (rdp stuff)
52-353 . {
52-354 . case one:
52-355 . {
52-356 . run_this;
52-357 . break;
52-358 . }
52-359 . case two:
52-360 . {
52-361 . run_this;
52-362 . break;
52-363 . }
52-364 . default:
52-365 . {
52-366 . SwError;
52-367 . }
52-368 . }
52-369 .
52-370 . A = B/C;
52-371 .
52-372 . if (A lt B)
52-373 . {
52-374 . A = B + C;
52-375 . D = E + F;
52-376 . }
52-377 .
52-378 . A = B*C;
52-379 . A = B+C;
52-380 . A = B*C;
52-381 .
52-382 . if (A < B)
52-383 . {
52-384 . A = B + C;
52-385 . D = E + F;
52-386 . }
52-387 .
52-388 .
52-389 . if (A != B)
52-390 . {
52-391 . A = B + C;
52-392 . D = E + F;
52-393 . }
52-394 .
52-395 . A = B-C;
52-396 . A = B-C;
52-397 . A = B-C;
52-398 .
52-399 . if (A < B)
52-400 . {
52-401 . A = B + C;
52-402 . D = E + F;
52-403 . }
52-404 .
52-405 . A = B/C;
52-406 .
52-407 . if (A le B)
52-408 . {
52-409 . A = B + C;
52-410 . D = E + F;
52-411 . }
52-412 .
52-413 . A = B*C;
52-414 .
52-415 . if (A != B)
52-416 . {
52-417 . A = B + C;
52-418 . D = E + F;
52-419 . }
52-420 .
52-421 . A = B-C;
52-422 .
52-423 . /* dead_block = C * D;
52-424 . dead_block = E * F; */
52-425 .
52-426 . A = B+C;
52-427 . A = B/C;
52-428 . A = B+C;
52-429 . A = B*C;
52-430 . A = B*C;
52-431 . A = B-C;
52-432 . A = B/C;
52-433 .
52-434 . if (A eq B)
52-435 . {
52-436 . A = B + C;
52-437 . D = E + F;
52-438 . }
52-439 .
52-440 . A = B*C;
52-441 . // max LOC 30
52-442 .
52-443 . }
52-444 .
52-445 .
52-446 . /*
52-447 . -----------------------------------------------------------------------------
52-448 . --| NAME: rdp.2.5
52-449 . --|
52-450 . --| ABSTRACT:
52-451 . --| This function does rdp stuff.
52-452 . --|
52-453 . --| RETURNS:
52-454 . --| NONE.
52-455 . --|
52-456 . ----------------------------------------------------------------------------
52-457 . */
52-458 . static void rdp.2.5(void)
52-459 . {
52-460 .
52-461 . if (A ne B)
52-462 . {
52-463 . A = B + C;
52-464 . D = E + F;
52-465 . }
52-466 .
52-467 . A = B*C;
52-468 . /* LE SV TOC-2627 this is a rdp-02.5.3 req to set Real Time Clock*/
52-469 . // TBS - I need to figure this out
52-470 . A = B+C;
52-471 . A = B-C;
52-472 . A = B/C;
52-473 . A = B/C;
52-474 .
52-475 . if (A eq B)
52-476 . {
52-477 . A = B + C;
52-478 . D = E + F;
52-479 . }
52-480 .
52-481 .
52-482 . if (A < B)
52-483 . {
52-484 . A = B + C;
52-485 . D = E + F;
52-486 . }
52-487 .
52-488 . A = B+C;
52-489 . A = B/C;
52-490 . A = B-C;
52-491 .
52-492 . if (A < = B)
52-493 . {
52-494 . A = B + C;
52-495 . D = E + F;
52-496 . }
52-497 .
52-498 . A = B+C;
52-499 . A = B-C;
52-500 . /* LE SV TOC-2628 this is a rdp-02.5.15 req to translate*/
52-501 . A = B+C;
52-502 .
52-503 . if (A ne B)
52-504 . {
52-505 . A = B + C;
52-506 . D = E + F;
52-507 . }
52-508 .
52-509 .
52-510 . if (A eq B)
52-511 . {
52-512 . A = B + C;
52-513 . D = E + F;
52-514 . }
52-515 .
52-516 . A = B*C;
52-517 .
52-518 . if (A < B)
52-519 . {
52-520 . A = B + C;
52-521 . D = E + F;
52-522 . }
52-523 .
52-524 .
52-525 . if (A == B)
52-526 . {
52-527 . A = B + C;
52-528 . D = E + F;
52-529 . }
52-530 .
52-531 . A = B-C;
52-532 .
52-533 . if (A ge B)
52-534 . {
52-535 . A = B + C;
52-536 . D = E + F;
52-537 . }
52-538 .
52-539 . A = B/C;
52-540 . A = B+C;
52-541 . A = 0x0007;
52-542 .
52-543 . if (A le B)
52-544 . {
52-545 . A = B + C;
52-546 . D = E + F;
52-547 . }
52-548 .
52-549 . A = B-C;
52-550 . A = B/C;
52-551 .
52-552 . if (veg)
52-553 . // missing curly brace
52-554 . variable = orange;
52-555 .
52-556 .
52-557 . if (A > = B)
52-558 . {
52-559 . A = B + C;
52-560 . D = E + F;
52-561 . }
52-562 .
52-563 .
52-564 . switch (rdp stuff)
52-565 . {
52-566 . case one:
52-567 . {
52-568 . run_this;
52-569 . break;
52-570 . }
52-571 . case two:
52-572 . {
52-573 . run_this;
52-574 . break;
52-575 . }
52-576 . default:
52-577 . {
52-578 . SwError;
52-579 . }
52-580 . }
52-581 .
52-582 . A = B*C;
52-583 . /* LE SV TOC-2629 this is a rdp-02.5.31 req to inhibit*/
52-584 .
52-585 . if (A == B)
52-586 . {
52-587 . A = B + C;
52-588 . D = E + F;
52-589 . }
52-590 .
52-591 .
52-592 . if (A != B)
52-593 . {
52-594 . A = B + C;
52-595 . D = E + F;
52-596 . }
52-597 .
52-598 . A = B+C;
52-599 . A = B*C;
52-600 . /* LE SV TOC-2630 this is a rdp-02.5.35 req to call isr*/
52-601 .
52-602 . if (A < B)
52-603 . {
52-604 . A = B + C;
52-605 . D = E + F;
52-606 . }
52-607 .
52-608 .
52-609 . switch (rdp stuff)
52-610 . {
52-611 . case one:
52-612 . {
52-613 . run_this;
52-614 . break;
52-615 . }
52-616 . case two:
52-617 . {
52-618 . run_this;
52-619 . break;
52-620 . }
52-621 . default:
52-622 . {
52-623 . SwError;
52-624 . }
52-625 . }
52-626 .
52-627 .
52-628 . if (A eq B)
52-629 . {
52-630 . A = B + C;
52-631 . D = E + F;
52-632 . }
52-633 .
52-634 . A = B+C;
52-635 . A = B-C;
52-636 . /* LE SV TOC-2631 this is a rdp-02.5.40 req to assign*/
52-637 .
52-638 . if (A > B)
52-639 . {
52-640 . A = B + C;
52-641 . D = E + F;
52-642 . }
52-643 .
52-644 . A = B/C;
52-645 . A = B+C;
52-646 . A = B/C;
52-647 .
52-648 . if (A > = B)
52-649 . {
52-650 . A = B + C;
52-651 . D = E + F;
52-652 . }
52-653 .
52-654 . A = B-C;
52-655 . A = B*C;
52-656 .
52-657 . if (A le B)
52-658 . {
52-659 . A = B + C;
52-660 . D = E + F;
52-661 . }
52-662 .
52-663 . A = B/C;
52-664 . A = B+C;
52-665 . A = B+C;
52-666 . A = B*C;
52-667 . A = B+C;
52-668 . // (P) this is really improtant
52-669 . A = B-C;
52-670 . A = B/C;
52-671 . A = B*C;
52-672 . // max LOC 55
52-673 .
52-674 . }
52-675 .
52-676 .
52-677 . /*
52-678 . -----------------------------------------------------------------------------
52-679 . --| NAME: rdp.2.6
52-680 . --|
52-681 . --| ABSTRACT:
52-682 . --| This function does rdp stuff.
52-683 . --|
52-684 . --| RETURNS:
52-685 . --| NONE.
52-686 . --|
52-687 . ----------------------------------------------------------------------------
52-688 . */
52-689 . static void rdp.2.6(void)
52-690 . {
52-691 . A = B*C;
52-692 .
52-693 . switch (rdp stuff)
52-694 . {
52-695 . case one:
52-696 . {
52-697 . run_this;
52-698 . break;
52-699 . }
52-700 . case two:
52-701 . {
52-702 . run_this;
52-703 . break;
52-704 . }
52-705 . default:
52-706 . {
52-707 . SwError;
52-708 . }
52-709 . }
52-710 .
52-711 .
52-712 . if (A lt B)
52-713 . {
52-714 . A = B + C;
52-715 . D = E + F;
52-716 . }
52-717 .
52-718 . A = B+C;
52-719 .
52-720 . if (A ge B)
52-721 . {
52-722 . A = B + C;
52-723 . D = E + F;
52-724 . }
52-725 .
52-726 . A = B/C;
52-727 .
52-728 . if (A ne B)
52-729 . {
52-730 . A = B + C;
52-731 . D = E + F;
52-732 . }
52-733 .
52-734 . A = B*C;
52-735 .
52-736 . switch (rdp stuff)
52-737 . {
52-738 . case one:
52-739 . {
52-740 . run_this;
52-741 . break;
52-742 . }
52-743 . case two:
52-744 . {
52-745 . run_this;
52-746 . break;
52-747 . }
52-748 . default:
52-749 . {
52-750 . SwError;
52-751 . }
52-752 . }
52-753 .
52-754 .
52-755 . if (A ge B)
52-756 . {
52-757 . A = B + C;
52-758 . D = E + F;
52-759 . }
52-760 .
52-761 . A = B/C;
52-762 . A = B*C;
52-763 .
52-764 . if (A > B)
52-765 . {
52-766 . A = B + C;
52-767 . D = E + F;
52-768 . }
52-769 .
52-770 . A = B*C;
52-771 . A = B+C;
52-772 . A = B*C;
52-773 . A = B-C;
52-774 . A = B*C;
52-775 .
52-776 . if (A == B)
52-777 . {
52-778 . A = B + C;
52-779 . D = E + F;
52-780 . }
52-781 .
52-782 .
52-783 . switch (rdp stuff)
52-784 . {
52-785 . case one:
52-786 . {
52-787 . run_this;
52-788 . break;
52-789 . }
52-790 . case two:
52-791 . {
52-792 . run_this;
52-793 . break;
52-794 . }
52-795 . default:
52-796 . {
52-797 . SwError;
52-798 . }
52-799 . }
52-800 .
52-801 . A = B-C;
52-802 .
52-803 . if (A < B)
52-804 . {
52-805 . A = B + C;
52-806 . D = E + F;
52-807 . }
52-808 .
52-809 .
52-810 . if (A eq B)
52-811 . {
52-812 . A = B + C;
52-813 . D = E + F;
52-814 . }
52-815 .
52-816 .
52-817 . if (A < = B)
52-818 . {
52-819 . A = B + C;
52-820 . D = E + F;
52-821 . }
52-822 .
52-823 .
52-824 . /* dead_block = C * D;
52-825 . dead_block = E * F; */
52-826 .
52-827 .
52-828 . if (A lt B)
52-829 . {
52-830 . A = B + C;
52-831 . D = E + F;
52-832 . }
52-833 .
52-834 . A = B+C;
52-835 . A = B*C;
52-836 . rcv_buffer = (U16 *) alloc(size+1);
52-837 . A = B+C;
52-838 .
52-839 . if (A lt B)
52-840 . {
52-841 . A = B + C;
52-842 . D = E + F;
52-843 . }
52-844 .
52-845 . A = B/C;
52-846 . /* LE SV TOC-2632 this is a rdp-02.6.31 req to convert*/
52-847 .
52-848 . if (A < B)
52-849 . {
52-850 . A = B + C;
52-851 . D = E + F;
52-852 . }
52-853 .
52-854 .
52-855 . if (A < = B)
52-856 . {
52-857 . A = B + C;
52-858 . D = E + F;
52-859 . }
52-860 .
52-861 . A = B+C;
52-862 .
52-863 . if (A < = B)
52-864 . {
52-865 . A = B + C;
52-866 . D = E + F;
52-867 . }
52-868 .
52-869 . A = B*C;
52-870 . A = B*C;
52-871 . A = B+C;
52-872 .
52-873 . if (A ge B)
52-874 . {
52-875 . A = B + C;
52-876 . D = E + F;
52-877 . }
52-878 .
52-879 . A = B-C;
52-880 .
52-881 . if (A ne B)
52-882 . {
52-883 . A = B + C;
52-884 . D = E + F;
52-885 . }
52-886 .
52-887 . A = B/C;
52-888 .
52-889 . if (A == B)
52-890 . {
52-891 . A = B + C;
52-892 . D = E + F;
52-893 . }
52-894 .
52-895 . A = B+C;
52-896 . A = B+C;
52-897 .
52-898 . if (A > = B)
52-899 . {
52-900 . A = B + C;
52-901 . D = E + F;
52-902 . }
52-903 .
52-904 . A = B+C;
52-905 . A = B*C;
52-906 . /* LE SV TOC-2633 this is a rdp-02.6.48 req to compare*/
52-907 .
52-908 . if (A gt B)
52-909 . {
52-910 . A = B + C;
52-911 . D = E + F;
52-912 . }
52-913 .
52-914 .
52-915 . if (A < = B)
52-916 . {
52-917 . A = B + C;
52-918 . D = E + F;
52-919 . }
52-920 .
52-921 . A = B-C;
52-922 . A = B+C;
52-923 . // max LOC 51
52-924 .
52-925 . }
52-926 .
52-927 .
52-928 . /*
52-929 . -----------------------------------------------------------------------------
52-930 . --| NAME: rdp.2.7
52-931 . --|
52-932 . --| ABSTRACT:
52-933 . --| This function does rdp stuff.
52-934 . --|
52-935 . --| RETURNS:
52-936 . --| NONE.
52-937 . --|
52-938 . ----------------------------------------------------------------------------
52-939 . */
52-940 . static void rdp.2.7(void)
52-941 . {
52-942 . A = B/C;
52-943 . A = B/C;
52-944 . A = B-C;
52-945 .
52-946 . if (A == B)
52-947 . {
52-948 . A = B + C;
52-949 . D = E + F;
52-950 . }
52-951 .
52-952 . A = B*C;
52-953 . A = B+C;
52-954 .
52-955 . if (A ne B)
52-956 . {
52-957 . A = B + C;
52-958 . D = E + F;
52-959 . }
52-960 .
52-961 . A = B-C;
52-962 . A = B*C;
52-963 . A = B/C;
52-964 . A = B*C;
52-965 . A = B*C;
52-966 . A = B+C;
52-967 . A = B*C;
52-968 . A = B+C;
52-969 . A = B-C;
52-970 . A = B-C;
52-971 . A = B/C;
52-972 .
52-973 . if (A == B)
52-974 . {
52-975 . A = B + C;
52-976 . D = E + F;
52-977 . }
52-978 .
52-979 .
52-980 . if (A < B)
52-981 . {
52-982 . A = B + C;
52-983 . D = E + F;
52-984 . }
52-985 .
52-986 . FreePtr = HmiStringPtr;
52-987 . A = B/C;
52-988 . A = B*C;
52-989 . A = B*C;
52-990 . A = B-C;
52-991 . A = B/C;
52-992 . A = B/C;
52-993 . A = B+C;
52-994 . A = B+C;
52-995 . A = B/C;
52-996 . A = B*C;
52-997 . A = B/C;
52-998 .
52-999 . if (A < B)
52-1000 . {
52-1001 . A = B + C;
52-1002 . D = E + F;
52-1003 . }
52-1004 .
52-1005 . A = B/C;
52-1006 .
52-1007 . if (A > B)
52-1008 . {
52-1009 . A = B + C;
52-1010 . D = E + F;
52-1011 . }
52-1012 .
52-1013 . A = B*C;
52-1014 . A = B/C;
52-1015 . A = B/C;
52-1016 .
52-1017 . if (A == B)
52-1018 . {
52-1019 . A = B + C;
52-1020 . D = E + F;
52-1021 . }
52-1022 .
52-1023 . A = B+C;
52-1024 . A = B/C;
52-1025 . A = B/C;
52-1026 .
52-1027 . if (A > B)
52-1028 . {
52-1029 . A = B + C;
52-1030 . D = E + F;
52-1031 . }
52-1032 .
52-1033 . A = B*C;
52-1034 .
52-1035 . if (A < B)
52-1036 . {
52-1037 . A = B + C;
52-1038 . D = E + F;
52-1039 . }
52-1040 .
52-1041 .
52-1042 . if (A lt B)
52-1043 . {
52-1044 . A = B + C;
52-1045 . D = E + F;
52-1046 . }
52-1047 .
52-1048 . A = B*C;
52-1049 . A = B*C;
52-1050 . A = B+C;
52-1051 .
52-1052 . if (A > = B)
52-1053 . {
52-1054 . A = B + C;
52-1055 . D = E + F;
52-1056 . }
52-1057 .
52-1058 . A = B*C;
52-1059 . /* LE SV TOC-2634 this is a rdp-02.7.51 req to convert*/
52-1060 . A = B/C;
52-1061 .
52-1062 . if (A < B)
52-1063 . {
52-1064 . A = B + C;
52-1065 . D = E + F;
52-1066 . }
52-1067 .
52-1068 .
52-1069 . if (A < = B)
52-1070 . {
52-1071 . A = B + C;
52-1072 . D = E + F;
52-1073 . }
52-1074 .
52-1075 . /* LE SV TOC-2635 this is a rdp-02.7.54 req to assign*/
52-1076 . A = B*C;
52-1077 . A = B+C;
52-1078 .
52-1079 . if (A < B)
52-1080 . {
52-1081 . A = B + C;
52-1082 . D = E + F;
52-1083 . }
52-1084 .
52-1085 . A = B+C;
52-1086 . A = B-C;
52-1087 . /* LE SV TOC-2636 this is a rdp-02.7.59 req to disable*/
52-1088 .
52-1089 . if (A gt B)
52-1090 . {
52-1091 . A = B + C;
52-1092 . D = E + F;
52-1093 . }
52-1094 .
52-1095 . A = B*C;
52-1096 . A = B*C;
52-1097 . A = B-C;
52-1098 .
52-1099 . if (A eq B)
52-1100 . {
52-1101 . A = B + C;
52-1102 . D = E + F;
52-1103 . }
52-1104 .
52-1105 . A = B*C;
52-1106 . A = B+C;
52-1107 . A = B*C;
52-1108 .
52-1109 . if (A lt B)
52-1110 . {
52-1111 . A = B + C;
52-1112 . D = E + F;
52-1113 . }
52-1114 .
52-1115 . // ??? go see ws
52-1116 . A = B/C;
52-1117 . A = B/C;
52-1118 . A = B+C;
52-1119 . // max LOC 70
52-1120 .
52-1121 . }
52-1122 .
52-1123 .
52-1124 . /*
52-1125 . -----------------------------------------------------------------------------
52-1126 . --| NAME: rdp.2.8
52-1127 . --|
52-1128 . --| ABSTRACT:
52-1129 . --| This function does rdp stuff.
52-1130 . --|
52-1131 . --| RETURNS:
52-1132 . --| NONE.
52-1133 . --|
52-1134 . ----------------------------------------------------------------------------
52-1135 . */
52-1136 . static void rdp.2.8(void)
52-1137 . {
52-1138 . A = B/C;
52-1139 .
52-1140 . if (A ne B)
52-1141 . {
52-1142 . A = B + C;
52-1143 . D = E + F;
52-1144 . }
52-1145 .
52-1146 .
52-1147 . if (A gt B)
52-1148 . {
52-1149 . A = B + C;
52-1150 . D = E + F;
52-1151 . }
52-1152 .
52-1153 . goto error;
52-1154 . A = B-C;
52-1155 . A = B-C;
52-1156 .
52-1157 . if (A > B)
52-1158 . {
52-1159 . A = B + C;
52-1160 . D = E + F;
52-1161 . }
52-1162 .
52-1163 . A = B*C;
52-1164 . A = B/C;
52-1165 .
52-1166 . if (A > B)
52-1167 . {
52-1168 . A = B + C;
52-1169 . D = E + F;
52-1170 . }
52-1171 .
52-1172 .
52-1173 . if (A ne B)
52-1174 . {
52-1175 . A = B + C;
52-1176 . D = E + F;
52-1177 . }
52-1178 .
52-1179 . A = B*C;
52-1180 . A = B-C;
52-1181 . A = B*C;
52-1182 . A = B/C;
52-1183 .
52-1184 . if (A != B)
52-1185 . {
52-1186 . A = B + C;
52-1187 . D = E + F;
52-1188 . }
52-1189 .
52-1190 .
52-1191 . switch (rdp stuff)
52-1192 . {
52-1193 . case one:
52-1194 . {
52-1195 . run_this;
52-1196 . break;
52-1197 . }
52-1198 . case two:
52-1199 . {
52-1200 . run_this;
52-1201 . break;
52-1202 . }
52-1203 . default:
52-1204 . {
52-1205 . SwError;
52-1206 . }
52-1207 . }
52-1208 .
52-1209 . /* LE SV TOC-2637 this is a rdp-02.8.17 req to compare*/
52-1210 . A = B+C;
52-1211 .
52-1212 . if (A != B)
52-1213 . {
52-1214 . A = B + C;
52-1215 . D = E + F;
52-1216 . }
52-1217 .
52-1218 .
52-1219 . if (A le B)
52-1220 . {
52-1221 . A = B + C;
52-1222 . D = E + F;
52-1223 . }
52-1224 .
52-1225 .
52-1226 . switch (rdp stuff)
52-1227 . {
52-1228 . case one:
52-1229 . {
52-1230 . switch (nested)
52-1231 . {
52-1232 . case:
52-1233 . X = Y + Z;
52-1234 . case:
52-1235 . X = Y + Z;
52-1236 . default:
52-1237 . SwError;
52-1238 . }
52-1239 . }
52-1240 . case two:
52-1241 . {
52-1242 . run_this;
52-1243 . break;
52-1244 . }
52-1245 . default:
52-1246 . {
52-1247 . SwError;
52-1248 . }
52-1249 . }
52-1250 .
52-1251 . A = B/C;
52-1252 . A = B*C;
52-1253 . A = B-C;
52-1254 .
52-1255 . if (A < = B)
52-1256 . {
52-1257 . A = B + C;
52-1258 . D = E + F;
52-1259 . }
52-1260 .
52-1261 . A = B-C;
52-1262 . A = B-C;
52-1263 . A = B+C;
52-1264 . A = B-C;
52-1265 . A = B-C;
52-1266 . A = B/C;
52-1267 . A = B*C;
52-1268 . A = B-C;
52-1269 . /* LE SV TOC-2638 this is a rdp-02.8.32 req to disable*/
52-1270 . A = 0x0006;
52-1271 . A = B*C;
52-1272 . A = B*C;
52-1273 . A = B/C;
52-1274 . A = B*C;
52-1275 .
52-1276 . if (A lt B)
52-1277 . {
52-1278 . A = B + C;
52-1279 . D = E + F;
52-1280 . }
52-1281 .
52-1282 .
52-1283 . /* dead_code = B + C;
52-1284 . dead_code = D + E;
52-1285 . dead_code = F + G; */
52-1286 .
52-1287 . A = B+C;
52-1288 .
52-1289 . if (A ne B)
52-1290 . {
52-1291 . A = B + C;
52-1292 . D = E + F;
52-1293 . }
52-1294 .
52-1295 . A = B/C;
52-1296 . A = B/C;
52-1297 . A = B+C;
52-1298 .
52-1299 . if (A le B)
52-1300 . {
52-1301 . A = B + C;
52-1302 . D = E + F;
52-1303 . }
52-1304 .
52-1305 . A = B/C;
52-1306 . A = B/C;
52-1307 . A = B-C;
52-1308 . A = B*C;
52-1309 . A = B+C;
52-1310 . A = B-C;
52-1311 . A = B+C;
52-1312 .
52-1313 . if (A < = B)
52-1314 . {
52-1315 . A = B + C;
52-1316 . D = E + F;
52-1317 . }
52-1318 .
52-1319 . A = B+C;
52-1320 . A = B-C;
52-1321 . A = B*C;
52-1322 . A = B*C;
52-1323 . // max LOC 54
52-1324 .
52-1325 . }
52-1326 .
52-1327 .
52-1328 . /*
52-1329 . -----------------------------------------------------------------------------
52-1330 . --| NAME: rdp.2.9
52-1331 . --|
52-1332 . --| ABSTRACT:
52-1333 . --| This function does rdp stuff.
52-1334 . --|
52-1335 . --| RETURNS:
52-1336 . --| NONE.
52-1337 . --|
52-1338 . ----------------------------------------------------------------------------
52-1339 . */
52-1340 . static void rdp.2.9(void)
52-1341 . {
52-1342 . A = B/C;
52-1343 . A = B*C;
52-1344 .
52-1345 . if (A gt B)
52-1346 . {
52-1347 . A = B + C;
52-1348 . D = E + F;
52-1349 . }
52-1350 .
52-1351 . A = B+C;
52-1352 . A = B-C;
52-1353 . /* LE SV TOC-2639 this is a rdp-02.9.6 req to recover*/
52-1354 . A = B/C;
52-1355 . A = B/C;
52-1356 . A = B/C;
52-1357 . A = B+C;
52-1358 . A = B/C;
52-1359 . // max LOC 10
52-1360 .
52-1361 . }
52-1362 .
52-1363 .
52-1364 . /*
52-1365 . -----------------------------------------------------------------------------
52-1366 . --| NAME: rdp.2.10
52-1367 . --|
52-1368 . --| ABSTRACT:
52-1369 . --| This function does rdp stuff.
52-1370 . --|
52-1371 . --| RETURNS:
52-1372 . --| NONE.
52-1373 . --|
52-1374 . ----------------------------------------------------------------------------
52-1375 . */
52-1376 . static void rdp.2.10(void)
52-1377 . {
52-1378 . A = B+C;
52-1379 .
52-1380 . if (A le B)
52-1381 . {
52-1382 . A = B + C;
52-1383 . D = E + F;
52-1384 . }
52-1385 .
52-1386 . A = B*C;
52-1387 . A = B*C;
52-1388 . A = B*C;
52-1389 . A = B-C;
52-1390 . A = B*C;
52-1391 .
52-1392 . switch (rdp stuff)
52-1393 . {
52-1394 . case:
52-1395 . case:
52-1396 . // stacked case statements but only if there is a new line in between
52-1397 .
52-1398 . case:
52-1399 . case:
52-1400 . case:
52-1401 . {
52-1402 . run_this;
52-1403 . break;
52-1404 . }
52-1405 . default:
52-1406 . {
52-1407 . halt;
52-1408 . }
52-1409 . }
52-1410 .
52-1411 .
52-1412 . if (A == B)
52-1413 . {
52-1414 . A = B + C;
52-1415 . D = E + F;
52-1416 . }
52-1417 .
52-1418 . A = B-C;
52-1419 . A = B+C;
52-1420 .
52-1421 . switch (rdp stuff)
52-1422 . {
52-1423 . case one:
52-1424 . {
52-1425 . run_this;
52-1426 . break;
52-1427 . }
52-1428 . case two:
52-1429 . {
52-1430 . run_this;
52-1431 . break;
52-1432 . }
52-1433 . default:
52-1434 . {
52-1435 . SwError;
52-1436 . }
52-1437 . }
52-1438 .
52-1439 .
52-1440 . switch (rdp stuff)
52-1441 . {
52-1442 . case one:
52-1443 . {
52-1444 . run_this;
52-1445 . break;
52-1446 . }
52-1447 . case two:
52-1448 . {
52-1449 . run_this;
52-1450 . break;
52-1451 . }
52-1452 . default:
52-1453 . {
52-1454 . SwError;
52-1455 . }
52-1456 . }
52-1457 .
52-1458 .
52-1459 . if (A gt B)
52-1460 . {
52-1461 . A = B + C;
52-1462 . D = E + F;
52-1463 . }
52-1464 .
52-1465 . A = B+C;
52-1466 .
52-1467 . /* dead_block = C * D;
52-1468 . dead_block = E * F; */
52-1469 .
52-1470 . A = B*C;
52-1471 . A = B+C;
52-1472 .
52-1473 . if (A != B)
52-1474 . {
52-1475 . A = B + C;
52-1476 . D = E + F;
52-1477 . }
52-1478 .
52-1479 .
52-1480 . if (A > = B)
52-1481 . {
52-1482 . A = B + C;
52-1483 . D = E + F;
52-1484 . }
52-1485 .
52-1486 . A = B+C;
52-1487 .
52-1488 . if {
52-1489 . X = Y + Z;
52-1490 . }
52-1491 . else {
52-1492 . halt;
52-1493 . }
52-1494 .
52-1495 . A = B-C;
52-1496 .
52-1497 . switch (rdp stuff)
52-1498 . {
52-1499 . case:
52-1500 . case:
52-1501 . // stacked case statements but only if there is a new line in between
52-1502 .
52-1503 . case:
52-1504 . case:
52-1505 . case:
52-1506 . {
52-1507 . run_this;
52-1508 . break;
52-1509 . }
52-1510 . default:
52-1511 . {
52-1512 . halt;
52-1513 . }
52-1514 . }
52-1515 .
52-1516 . A = B/C;
52-1517 . A = B-C;
52-1518 . A = B/C;
52-1519 . A = B-C;
52-1520 . // max LOC 24
52-1521 .
52-1522 . }
52-1523 .
52 52 Result: result/source/ft-app/ft-app-B1.1/rdp/rdp-02.c
53 53 Source: source/ft-app/ft-app-B1.1/stp/stp-01.c
53-0 . /*
53-1 . ----------------------------------------------------------------------------
53-2 . --| BEGIN PROLOGUE
53-3 . --|
53-4 . --| CLASSIFICATION: UNCLASSIFIED
53-5 . --|
53-6 . --| FILE NAME: stp-01.c
53-7 . --|
53-8 . --| ABSTRACT:
53-9 . --| This file contains the 14 functions that do file stp stuff.
53-10 . --|
53-11 . --| HISTORY:
53-12 . --| CCCQ_NAME:
53-13 . --| CCCQ_VER:
53-14 . --|
53-15 . --| END PROLOGUE
53-16 . ----------------------------------------------------------------------------
53-17 . */
53-18 .
53-19 . #include D;
53-20 . #define A;
53-21 . char D;
53-22 . #define A;
53-23 .
53-24 .
53-25 .
53-26 . /*
53-27 . -----------------------------------------------------------------------------
53-28 . --| NAME: stp.1.1
53-29 . --|
53-30 . --| ABSTRACT:
53-31 . --| This function does stp stuff.
53-32 . --|
53-33 . --| RETURNS:
53-34 . --| NONE.
53-35 . --|
53-36 . ----------------------------------------------------------------------------
53-37 . */
53-38 . static void stp.1.1(void)
53-39 . {
53-40 . A = B*C;
53-41 .
53-42 . switch (stp stuff)
53-43 . {
53-44 . case one:
53-45 . {
53-46 . run_this;
53-47 . break;
53-48 . }
53-49 . case two:
53-50 . {
53-51 . run_this;
53-52 . break;
53-53 . }
53-54 . default:
53-55 . {
53-56 . SwError;
53-57 . }
53-58 . }
53-59 .
53-60 . A = B+C;
53-61 . A = B-C;
53-62 .
53-63 . if (A ge B)
53-64 . {
53-65 . A = B + C;
53-66 . D = E + F;
53-67 . }
53-68 .
53-69 .
53-70 . if (A != B)
53-71 . {
53-72 . A = B + C;
53-73 . D = E + F;
53-74 . }
53-75 .
53-76 . A = B*C;
53-77 .
53-78 . if (A le B)
53-79 . {
53-80 . A = B + C;
53-81 . D = E + F;
53-82 . }
53-83 .
53-84 . A = B/C;
53-85 . A = B*C;
53-86 .
53-87 . if (A lt B)
53-88 . {
53-89 . A = B + C;
53-90 . D = E + F;
53-91 . }
53-92 .
53-93 . A = B*C;
53-94 .
53-95 . if (A > B)
53-96 . {
53-97 . A = B + C;
53-98 . D = E + F;
53-99 . }
53-100 .
53-101 .
53-102 . if (A < B)
53-103 . {
53-104 . A = B + C;
53-105 . D = E + F;
53-106 . }
53-107 .
53-108 . A = B/C;
53-109 .
53-110 . if (A != B)
53-111 . {
53-112 . A = B + C;
53-113 . D = E + F;
53-114 . }
53-115 .
53-116 . A = B/C;
53-117 . A = B/C;
53-118 . A = B/C;
53-119 . A = B/C;
53-120 .
53-121 . if (A ne B)
53-122 . {
53-123 . A = B + C;
53-124 . D = E + F;
53-125 . }
53-126 .
53-127 . A = B+C;
53-128 . A = B+C;
53-129 .
53-130 . if (A == B)
53-131 . {
53-132 . A = B + C;
53-133 . D = E + F;
53-134 . }
53-135 .
53-136 . // TBD - what do I do now
53-137 . A = B-C;
53-138 . A = B+C;
53-139 . A = B-C;
53-140 . /* LE SV TOC-2801 this is a stp-01.1.28 req to store*/
53-141 .
53-142 . if (A eq B)
53-143 . {
53-144 . A = B + C;
53-145 . D = E + F;
53-146 . }
53-147 .
53-148 . A = B/C;
53-149 . A = B-C;
53-150 . A = B-C;
53-151 . /* LE SV TOC-2802 this is a stp-01.1.32 req to fail*/
53-152 . send_buffer = (U16 *) malloc(size+1);
53-153 .
53-154 . if (A > = B)
53-155 . {
53-156 . A = B + C;
53-157 . D = E + F;
53-158 . }
53-159 .
53-160 .
53-161 . if (A ge B)
53-162 . {
53-163 . A = B + C;
53-164 . D = E + F;
53-165 . }
53-166 .
53-167 .
53-168 . if (A ge B)
53-169 . {
53-170 . A = B + C;
53-171 . D = E + F;
53-172 . }
53-173 .
53-174 .
53-175 . if (A > B)
53-176 . {
53-177 . A = B + C;
53-178 . D = E + F;
53-179 . }
53-180 .
53-181 . A = B-C;
53-182 .
53-183 . if (A != B)
53-184 . {
53-185 . A = B + C;
53-186 . D = E + F;
53-187 . }
53-188 .
53-189 . A = B/C;
53-190 .
53-191 . if (A > = B)
53-192 . {
53-193 . A = B + C;
53-194 . D = E + F;
53-195 . }
53-196 .
53-197 . A = B/C;
53-198 .
53-199 . if (A > = B)
53-200 . {
53-201 . A = B + C;
53-202 . D = E + F;
53-203 . }
53-204 .
53-205 . A = B+C;
53-206 . A = B*C;
53-207 .
53-208 . if (A eq B)
53-209 . {
53-210 . A = B + C;
53-211 . D = E + F;
53-212 . }
53-213 .
53-214 . A = B*C;
53-215 .
53-216 . if (A > = B)
53-217 . {
53-218 . A = B + C;
53-219 . D = E + F;
53-220 . }
53-221 .
53-222 . A = B*C;
53-223 . A = B*C;
53-224 .
53-225 . if (A < = B)
53-226 . {
53-227 . A = B + C;
53-228 . D = E + F;
53-229 . }
53-230 .
53-231 . A = B-C;
53-232 . /* LE SV TOC-2803 this is a stp-01.1.51 req to compare*/
53-233 .
53-234 . if (A le B)
53-235 . {
53-236 . A = B + C;
53-237 . D = E + F;
53-238 . }
53-239 .
53-240 .
53-241 . if (A == B)
53-242 . {
53-243 . A = B + C;
53-244 . D = E + F;
53-245 . }
53-246 .
53-247 . A = 0x0009;
53-248 . A = B/C;
53-249 . A = B/C;
53-250 . A = B/C;
53-251 .
53-252 . switch (stp stuff)
53-253 . {
53-254 . case one:
53-255 . {
53-256 . run_this;
53-257 . // missing break
53-258 . }
53-259 . case two:
53-260 . {
53-261 . run_this;
53-262 . break;
53-263 . }
53-264 . default:
53-265 . {
53-266 . SwError;
53-267 . }
53-268 . }
53-269 .
53-270 .
53-271 . if (A != B)
53-272 . {
53-273 . A = B + C;
53-274 . D = E + F;
53-275 . }
53-276 .
53-277 . A = B+C;
53-278 . A = B/C;
53-279 . A = B-C;
53-280 . rcv_buffer = (U16 *) alloc(size+1);
53-281 . A = B*C;
53-282 . A = B*C;
53-283 . A = B+C;
53-284 .
53-285 . if (A == B)
53-286 . {
53-287 . A = B + C;
53-288 . D = E + F;
53-289 . }
53-290 .
53-291 . /* LE SV TOC-2804 this is a stp-01.1.64 req to enable*/
53-292 . A = B-C;
53-293 . A = B-C;
53-294 . A = B*C;
53-295 . A = B-C;
53-296 .
53-297 . if (A ge B)
53-298 . {
53-299 . A = B + C;
53-300 . D = E + F;
53-301 . }
53-302 .
53-303 . A = B-C;
53-304 .
53-305 . switch (stp stuff)
53-306 . {
53-307 . case one:
53-308 . {
53-309 . run_this;
53-310 . break;
53-311 . }
53-312 . case two:
53-313 . {
53-314 . run_this;
53-315 . break;
53-316 . }
53-317 . default:
53-318 . {
53-319 . SwError;
53-320 . }
53-321 . }
53-322 .
53-323 . /* LE SV TOC-2805 this is a stp-01.1.71 req to compare*/
53-324 .
53-325 . if (A gt B)
53-326 . {
53-327 . A = B + C;
53-328 . D = E + F;
53-329 . }
53-330 .
53-331 .
53-332 . if (A eq B)
53-333 . {
53-334 . A = B + C;
53-335 . D = E + F;
53-336 . }
53-337 .
53-338 . A = B*C;
53-339 . A = B*C;
53-340 . /* LE SV TOC-2806 this is a stp-01.1.75 req to disable*/
53-341 .
53-342 . if (A ne B)
53-343 . {
53-344 . A = B + C;
53-345 . D = E + F;
53-346 . }
53-347 .
53-348 . A = B-C;
53-349 . A = 0x0003;
53-350 . A = B/C;
53-351 .
53-352 . if (A lt B)
53-353 . {
53-354 . A = B + C;
53-355 . D = E + F;
53-356 . }
53-357 .
53-358 . A = B-C;
53-359 . A = B*C;
53-360 . // max LOC 80
53-361 .
53-362 . }
53-363 .
53-364 .
53-365 . /*
53-366 . -----------------------------------------------------------------------------
53-367 . --| NAME: stp.1.2
53-368 . --|
53-369 . --| ABSTRACT:
53-370 . --| This function does stp stuff.
53-371 . --|
53-372 . --| RETURNS:
53-373 . --| NONE.
53-374 . --|
53-375 . ----------------------------------------------------------------------------
53-376 . */
53-377 . static void stp.1.2(void)
53-378 . {
53-379 . A = B/C;
53-380 . A = B-C;
53-381 . A = B*C;
53-382 . A = B/C;
53-383 .
53-384 . switch (stp stuff)
53-385 . {
53-386 . case one:
53-387 . {
53-388 . run_this;
53-389 . break;
53-390 . }
53-391 . case two:
53-392 . {
53-393 . run_this;
53-394 . break;
53-395 . }
53-396 . default:
53-397 . {
53-398 . SwError;
53-399 . }
53-400 . }
53-401 .
53-402 . /* LE SV TOC-2807 this is a stp-01.2.6 req to audit*/
53-403 . A = B/C;
53-404 .
53-405 . if (A > = B)
53-406 . {
53-407 . A = B + C;
53-408 . D = E + F;
53-409 . }
53-410 .
53-411 .
53-412 . /* dead_block = C * D;
53-413 . dead_block = E * F; */
53-414 .
53-415 .
53-416 . if (A ge B)
53-417 . {
53-418 . A = B + C;
53-419 . D = E + F;
53-420 . }
53-421 .
53-422 . A = B+C;
53-423 . A = B-C;
53-424 . A = B*C;
53-425 .
53-426 . /* dead_block = C * D;
53-427 . dead_block = E * F; */
53-428 .
53-429 . A = B-C;
53-430 .
53-431 . if (A < = B)
53-432 . {
53-433 . A = B + C;
53-434 . D = E + F;
53-435 . }
53-436 .
53-437 . A = 0x0004;
53-438 . A = B/C;
53-439 .
53-440 . if (A ge B)
53-441 . {
53-442 . A = B + C;
53-443 . D = E + F;
53-444 . }
53-445 .
53-446 .
53-447 . if (A lt B)
53-448 . {
53-449 . A = B + C;
53-450 . D = E + F;
53-451 . }
53-452 .
53-453 . A = B-C;
53-454 .
53-455 . if (A < = B)
53-456 . {
53-457 . A = B + C;
53-458 . D = E + F;
53-459 . }
53-460 .
53-461 .
53-462 . if (A > B)
53-463 . {
53-464 . A = B + C;
53-465 . D = E + F;
53-466 . }
53-467 .
53-468 . A = (long)B + C;
53-469 . A = B-C;
53-470 .
53-471 . if (A < = B)
53-472 . {
53-473 . A = B + C;
53-474 . D = E + F;
53-475 . }
53-476 .
53-477 . A = B/C;
53-478 . A = B+C;
53-479 .
53-480 . if (A < = B)
53-481 . {
53-482 . A = B + C;
53-483 . D = E + F;
53-484 . }
53-485 .
53-486 .
53-487 . if (A < B)
53-488 . {
53-489 . A = B + C;
53-490 . D = E + F;
53-491 . }
53-492 .
53-493 .
53-494 . if (A > B)
53-495 . {
53-496 . A = B + C;
53-497 . D = E + F;
53-498 . }
53-499 .
53-500 .
53-501 . if (A > B)
53-502 . {
53-503 . A = B + C;
53-504 . D = E + F;
53-505 . }
53-506 .
53-507 . /* LE SV TOC-2808 this is a stp-01.2.28 req to inhibit*/
53-508 . A = B-C;
53-509 . A = B/C;
53-510 . A = B*C;
53-511 . A = B*C;
53-512 . A = B*C;
53-513 . A = B/C;
53-514 . A = B*C;
53-515 . A = B+C;
53-516 . /* LE SV TOC-2809 this is a stp-01.2.36 req to increment*/
53-517 . A = B+C;
53-518 . A = B*C;
53-519 . A = B*C;
53-520 . A = B*C;
53-521 . A = B/C;
53-522 . // ??? go see ws
53-523 . A = B*C;
53-524 . A = B-C;
53-525 .
53-526 . if (A == B)
53-527 . {
53-528 . A = B + C;
53-529 . D = E + F;
53-530 . }
53-531 .
53-532 . A = B/C;
53-533 . /* LE SV TOC-2810 this is a stp-01.2.45 req to process*/
53-534 . A = B+C;
53-535 . A = B-C;
53-536 . A = B*C;
53-537 . A = B*C;
53-538 .
53-539 . switch (stp stuff)
53-540 . {
53-541 . case one:
53-542 . {
53-543 . run_this;
53-544 . break;
53-545 . }
53-546 . case two:
53-547 . {
53-548 . run_this;
53-549 . break;
53-550 . }
53-551 . default:
53-552 . {
53-553 . SwError;
53-554 . }
53-555 . }
53-556 .
53-557 .
53-558 . if (A == B)
53-559 . {
53-560 . A = B + C;
53-561 . D = E + F;
53-562 . }
53-563 .
53-564 . A = B*C;
53-565 . A = B-C;
53-566 . A = B+C;
53-567 . A = B/C;
53-568 . A = B-C;
53-569 .
53-570 . if (A ge B)
53-571 . {
53-572 . A = B + C;
53-573 . D = E + F;
53-574 . }
53-575 .
53-576 .
53-577 . if (A ge B)
53-578 . {
53-579 . A = B + C;
53-580 . D = E + F;
53-581 . }
53-582 .
53-583 .
53-584 . if (A ge B)
53-585 . {
53-586 . A = B + C;
53-587 . D = E + F;
53-588 . }
53-589 .
53-590 . A = B+C;
53-591 .
53-592 . if (A > B)
53-593 . {
53-594 . A = B + C;
53-595 . D = E + F;
53-596 . }
53-597 .
53-598 . goto error;
53-599 . A = B-C;
53-600 .
53-601 . if (A < B)
53-602 . {
53-603 . A = B + C;
53-604 . D = E + F;
53-605 . }
53-606 .
53-607 .
53-608 . switch (stp stuff)
53-609 . {
53-610 . case:
53-611 . case:
53-612 . // stacked case statements but only if there is a new line in between
53-613 .
53-614 . case:
53-615 . case:
53-616 . case:
53-617 . {
53-618 . run_this;
53-619 . break;
53-620 . }
53-621 . default:
53-622 . {
53-623 . halt;
53-624 . }
53-625 . }
53-626 .
53-627 .
53-628 . if (A > B)
53-629 . {
53-630 . A = B + C;
53-631 . D = E + F;
53-632 . }
53-633 .
53-634 . A = B-C;
53-635 .
53-636 . if ($stp stuff > $otherstp stuff)
53-637 . /* LE SV TOC-008 we really should log all error calls */
53-638 . {
53-639 . A = B + C;
53-640 . }
53-641 .
53-642 .
53-643 . if (A ge B)
53-644 . {
53-645 . A = B + C;
53-646 . D = E + F;
53-647 . }
53-648 .
53-649 . A = B-C;
53-650 .
53-651 . if (A == B)
53-652 . {
53-653 . A = B + C;
53-654 . D = E + F;
53-655 . }
53-656 .
53-657 . A = B+C;
53-658 . A = B+C;
53-659 . A = B+C;
53-660 . A = 0x0003;
53-661 . A = B/C;
53-662 . A = B/C;
53-663 . A = B/C;
53-664 . A = B-C;
53-665 . /* LE SV TOC-2811 this is a stp-01.2.75 req to enable*/
53-666 .
53-667 . if (A eq B)
53-668 . {
53-669 . A = B + C;
53-670 . D = E + F;
53-671 . }
53-672 .
53-673 . A = B*C;
53-674 .
53-675 . if (A < B)
53-676 . {
53-677 . A = B + C;
53-678 . D = E + F;
53-679 . }
53-680 .
53-681 .
53-682 . if (A lt B)
53-683 . {
53-684 . A = B + C;
53-685 . D = E + F;
53-686 . }
53-687 .
53-688 . A = B-C;
53-689 . A = B/C;
53-690 . A = B/C;
53-691 .
53-692 . if (A eq B)
53-693 . {
53-694 . A = B + C;
53-695 . D = E + F;
53-696 . }
53-697 .
53-698 .
53-699 . if (A > = B)
53-700 . {
53-701 . A = B + C;
53-702 . D = E + F;
53-703 . }
53-704 .
53-705 . A = B-C;
53-706 .
53-707 . if (A le B)
53-708 . {
53-709 . A = B + C;
53-710 . D = E + F;
53-711 . }
53-712 .
53-713 . A = B*C;
53-714 .
53-715 . if (A lt B)
53-716 . {
53-717 . A = B + C;
53-718 . D = E + F;
53-719 . }
53-720 .
53-721 . /* LE SV TOC-2812 this is a stp-01.2.88 req to store*/
53-722 . A = B*C;
53-723 . A = B+C;
53-724 . A = B*C;
53-725 . A = B/C;
53-726 . A = B/C;
53-727 . A = B*C;
53-728 . A = B-C;
53-729 . /* LE SV TOC-2813 this is a stp-01.2.95 req to assign*/
53-730 . A = B/C;
53-731 . A = B/C;
53-732 . // max LOC 96
53-733 .
53-734 . }
53-735 .
53-736 .
53-737 . /*
53-738 . -----------------------------------------------------------------------------
53-739 . --| NAME: stp.1.3
53-740 . --|
53-741 . --| ABSTRACT:
53-742 . --| This function does stp stuff.
53-743 . --|
53-744 . --| RETURNS:
53-745 . --| NONE.
53-746 . --|
53-747 . ----------------------------------------------------------------------------
53-748 . */
53-749 . static void stp.1.3(void)
53-750 . {
53-751 .
53-752 . if (A gt B)
53-753 . {
53-754 . A = B + C;
53-755 . D = E + F;
53-756 . }
53-757 .
53-758 . A = B*C;
53-759 . A = B+C;
53-760 . A = B-C;
53-761 .
53-762 . if (A eq B)
53-763 . {
53-764 . A = B + C;
53-765 . D = E + F;
53-766 . }
53-767 .
53-768 .
53-769 . if (A eq B)
53-770 . {
53-771 . A = B + C;
53-772 . D = E + F;
53-773 . }
53-774 .
53-775 . A = B-C;
53-776 . A = B*C;
53-777 . A = B/C;
53-778 . /* LE SV TOC-2814 this is a stp-01.3.10 req to audit*/
53-779 . A = B*C;
53-780 . A = B/C;
53-781 . A = B/C;
53-782 . A = B/C;
53-783 . A = B-C;
53-784 .
53-785 . if (A > B)
53-786 . {
53-787 . A = B + C;
53-788 . D = E + F;
53-789 . }
53-790 .
53-791 . A = B-C;
53-792 . A = B-C;
53-793 .
53-794 . if (A le B)
53-795 . {
53-796 . A = B + C;
53-797 . D = E + F;
53-798 . }
53-799 .
53-800 . A = B-C;
53-801 . /* LE SV TOC-2815 this is a stp-01.3.20 req to process*/
53-802 .
53-803 . if (A != B)
53-804 . {
53-805 . A = B + C;
53-806 . D = E + F;
53-807 . }
53-808 .
53-809 .
53-810 . if (A gt B)
53-811 . {
53-812 . A = B + C;
53-813 . D = E + F;
53-814 . }
53-815 .
53-816 . /* LE SV TOC-2816 this is a stp-01.3.22 req to compare*/
53-817 . A = B/C;
53-818 . A = B*C;
53-819 . A = B/C;
53-820 . A = B-C;
53-821 . A = B/C;
53-822 . /* LE SV TOC-2817 this is a stp-01.3.27 req to store*/
53-823 .
53-824 . switch (stp stuff)
53-825 . {
53-826 . case one:
53-827 . {
53-828 . run_this;
53-829 . break;
53-830 . }
53-831 . case two:
53-832 . {
53-833 . run_this;
53-834 . break;
53-835 . }
53-836 . default:
53-837 . {
53-838 . SwError;
53-839 . }
53-840 . }
53-841 .
53-842 . A = B*C;
53-843 .
53-844 . if (A < = B)
53-845 . {
53-846 . A = B + C;
53-847 . D = E + F;
53-848 . }
53-849 .
53-850 . A = B-C;
53-851 . A = B-C;
53-852 . A = B*C;
53-853 . A = B-C;
53-854 .
53-855 . switch (stp stuff)
53-856 . {
53-857 . case one:
53-858 . {
53-859 . run_this;
53-860 . break;
53-861 . }
53-862 . case two:
53-863 . {
53-864 . run_this;
53-865 . break;
53-866 . }
53-867 . // missing default
53-868 . }
53-869 .
53-870 . A = B-C;
53-871 . A = B-C;
53-872 .
53-873 . switch (stp stuff)
53-874 . {
53-875 . case one:
53-876 . {
53-877 . run_this;
53-878 . // missing break
53-879 . }
53-880 . case two:
53-881 . {
53-882 . run_this;
53-883 . break;
53-884 . }
53-885 . default:
53-886 . {
53-887 . SwError;
53-888 . }
53-889 . }
53-890 .
53-891 .
53-892 . if (A > B)
53-893 . {
53-894 . A = B + C;
53-895 . D = E + F;
53-896 . }
53-897 .
53-898 . A = B/C;
53-899 . /* LE SV TOC-2818 this is a stp-01.3.38 req to process*/
53-900 . // ??? go see ws
53-901 . A = B+C;
53-902 .
53-903 . if (A gt B)
53-904 . {
53-905 . A = B + C;
53-906 . D = E + F;
53-907 . }
53-908 .
53-909 . /* LE SV TOC-2819 this is a stp-01.3.40 req to detect error*/
53-910 . A = B*C;
53-911 . A = 0x0008;
53-912 .
53-913 . switch (stp stuff)
53-914 . {
53-915 . case one:
53-916 . {
53-917 . run_this;
53-918 . break;
53-919 . }
53-920 . case two:
53-921 . {
53-922 . run_this;
53-923 . break;
53-924 . }
53-925 . default:
53-926 . {
53-927 . SwError;
53-928 . }
53-929 . }
53-930 .
53-931 .
53-932 . if (A > = B)
53-933 . {
53-934 . A = B + C;
53-935 . D = E + F;
53-936 . }
53-937 .
53-938 . A = B/C;
53-939 . A = B+C;
53-940 . A = B+C;
53-941 . A = B*C;
53-942 .
53-943 . switch (stp stuff)
53-944 . {
53-945 . case one:
53-946 . {
53-947 . run_this;
53-948 . break;
53-949 . }
53-950 . case two:
53-951 . {
53-952 . run_this;
53-953 . break;
53-954 . }
53-955 . default:
53-956 . {
53-957 . SwError;
53-958 . }
53-959 . }
53-960 .
53-961 . A = B+C;
53-962 . A = B+C;
53-963 .
53-964 . if (A < = B)
53-965 . {
53-966 . A = B + C;
53-967 . D = E + F;
53-968 . }
53-969 .
53-970 . /* LE SV TOC-2820 this is a stp-01.3.51 req to detect error*/
53-971 . A = B*C;
53-972 . /* LE SV TOC-2821 this is a stp-01.3.52 req to reject*/
53-973 . A = B/C;
53-974 . /* LE SV TOC-2822 this is a stp-01.3.53 req to recover*/
53-975 . A = B+C;
53-976 .
53-977 . if (A gt B)
53-978 . {
53-979 . A = B + C;
53-980 . D = E + F;
53-981 . }
53-982 .
53-983 . A = B*C;
53-984 .
53-985 . if (A le B)
53-986 . {
53-987 . A = B + C;
53-988 . D = E + F;
53-989 . }
53-990 .
53-991 . A = B*C;
53-992 .
53-993 . if (A eq B)
53-994 . {
53-995 . A = B + C;
53-996 . D = E + F;
53-997 . }
53-998 .
53-999 . A = B/C;
53-1000 . // max LOC 59
53-1001 .
53-1002 . }
53-1003 .
53-1004 .
53-1005 . /*
53-1006 . -----------------------------------------------------------------------------
53-1007 . --| NAME: stp.1.4
53-1008 . --|
53-1009 . --| ABSTRACT:
53-1010 . --| This function does stp stuff.
53-1011 . --|
53-1012 . --| RETURNS:
53-1013 . --| NONE.
53-1014 . --|
53-1015 . ----------------------------------------------------------------------------
53-1016 . */
53-1017 . static void stp.1.4(void)
53-1018 . {
53-1019 . A = B+C;
53-1020 . A = B/C;
53-1021 . A = B*C;
53-1022 . A = B/C;
53-1023 . A = B-C;
53-1024 . A = B-C;
53-1025 . /* LE SV TOC-2823 this is a stp-01.4.7 req to disable*/
53-1026 . A = B-C;
53-1027 . A = B+C;
53-1028 .
53-1029 . #ifdef LAZY
53-1030 . // this is not nice
53-1031 . A = B + C;
53-1032 . A = B + C;
53-1033 . #endif
53-1034 .
53-1035 .
53-1036 . if (A lt B)
53-1037 . {
53-1038 . A = B + C;
53-1039 . D = E + F;
53-1040 . }
53-1041 .
53-1042 .
53-1043 . if (A eq B)
53-1044 . {
53-1045 . A = B + C;
53-1046 . D = E + F;
53-1047 . }
53-1048 .
53-1049 . A = B-C;
53-1050 . A = B*C;
53-1051 . A = B*C;
53-1052 . A = B+C;
53-1053 . A = B*C;
53-1054 .
53-1055 . /*
53-1056 . dead_code = B - C;
53-1057 . dead_code = D - E;
53-1058 . dead_code = F - G;
53-1059 . */
53-1060 .
53-1061 .
53-1062 . if (A lt B)
53-1063 . {
53-1064 . A = B + C;
53-1065 . D = E + F;
53-1066 . }
53-1067 .
53-1068 . A = B/C;
53-1069 .
53-1070 . /*
53-1071 . dead_code = B - C;
53-1072 . dead_code = D - E;
53-1073 . dead_code = F - G;
53-1074 . */
53-1075 .
53-1076 . A = B/C;
53-1077 . A = B/C;
53-1078 . A = B*C;
53-1079 .
53-1080 . if (A < B)
53-1081 . {
53-1082 . A = B + C;
53-1083 . D = E + F;
53-1084 . }
53-1085 .
53-1086 . A = B*C;
53-1087 . A = B*C;
53-1088 .
53-1089 . if (A < B)
53-1090 . {
53-1091 . A = B + C;
53-1092 . D = E + F;
53-1093 . }
53-1094 .
53-1095 . /* LE SV TOC-2824 this is a stp-01.4.25 req to fail*/
53-1096 .
53-1097 . if (A > = B)
53-1098 . {
53-1099 . A = B + C;
53-1100 . D = E + F;
53-1101 . }
53-1102 .
53-1103 . A = B+C;
53-1104 .
53-1105 . if (A ne B)
53-1106 . {
53-1107 . A = B + C;
53-1108 . D = E + F;
53-1109 . }
53-1110 .
53-1111 . /* LE SV TOC-2825 this is a stp-01.4.28 req to call admin*/
53-1112 .
53-1113 . if (A eq B)
53-1114 . {
53-1115 . A = B + C;
53-1116 . D = E + F;
53-1117 . }
53-1118 .
53-1119 .
53-1120 . if (A eq B)
53-1121 . {
53-1122 . A = B + C;
53-1123 . D = E + F;
53-1124 . }
53-1125 .
53-1126 . A = B/C;
53-1127 .
53-1128 . if (A ge B)
53-1129 . {
53-1130 . A = B + C;
53-1131 . D = E + F;
53-1132 . }
53-1133 .
53-1134 . A = B*C;
53-1135 . A = B/C;
53-1136 . A = B-C;
53-1137 .
53-1138 . if (A != B)
53-1139 . {
53-1140 . A = B + C;
53-1141 . D = E + F;
53-1142 . }
53-1143 .
53-1144 . do forever;
53-1145 . A = B/C;
53-1146 .
53-1147 . switch (stp stuff)
53-1148 . {
53-1149 . case one:
53-1150 . {
53-1151 . run_this;
53-1152 . break;
53-1153 . }
53-1154 . case two:
53-1155 . {
53-1156 . run_this;
53-1157 . break;
53-1158 . }
53-1159 . default:
53-1160 . {
53-1161 . SwError;
53-1162 . }
53-1163 . }
53-1164 .
53-1165 . A = B-C;
53-1166 . A = B/C;
53-1167 .
53-1168 . if (A eq B)
53-1169 . {
53-1170 . A = B + C;
53-1171 . D = E + F;
53-1172 . }
53-1173 .
53-1174 . A = B-C;
53-1175 . A = B+C;
53-1176 . A = B*C;
53-1177 .
53-1178 . if (A ge B)
53-1179 . {
53-1180 . A = B + C;
53-1181 . D = E + F;
53-1182 . }
53-1183 .
53-1184 .
53-1185 . if (A < B)
53-1186 . {
53-1187 . A = B + C;
53-1188 . D = E + F;
53-1189 . }
53-1190 .
53-1191 .
53-1192 . if (A ge B)
53-1193 . {
53-1194 . A = B + C;
53-1195 . D = E + F;
53-1196 . }
53-1197 .
53-1198 . rcv_buffer = (U16 *) alloc(size+1);
53-1199 . A = B*C;
53-1200 . A = B/C;
53-1201 . A = B-C;
53-1202 .
53-1203 . switch (stp stuff)
53-1204 . {
53-1205 . case:
53-1206 . case:
53-1207 . // stacked case statements but only if there is a new line in between
53-1208 .
53-1209 . case:
53-1210 . case:
53-1211 . case:
53-1212 . {
53-1213 . run_this;
53-1214 . break;
53-1215 . }
53-1216 . default:
53-1217 . {
53-1218 . halt;
53-1219 . }
53-1220 . }
53-1221 .
53-1222 . A = B/C;
53-1223 . A = B/C;
53-1224 . A = B*C;
53-1225 . A = B*C;
53-1226 . A = B*C;
53-1227 . A = B+C;
53-1228 . A = B*C;
53-1229 .
53-1230 . if (A ne B)
53-1231 . {
53-1232 . A = B + C;
53-1233 . D = E + F;
53-1234 . }
53-1235 .
53-1236 . A = B*C;
53-1237 . A = B+C;
53-1238 . A = B*C;
53-1239 .
53-1240 . if ($stp stuff > $otherstp stuff)
53-1241 . /* LE SV TOC-008 we really should log all error calls */
53-1242 . {
53-1243 . A = B + C;
53-1244 . }
53-1245 .
53-1246 . A = B/C;
53-1247 . A = B+C;
53-1248 . A = B/C;
53-1249 .
53-1250 . switch (stp stuff)
53-1251 . {
53-1252 . case one:
53-1253 . {
53-1254 . run_this;
53-1255 . // missing break
53-1256 . }
53-1257 . case two:
53-1258 . {
53-1259 . run_this;
53-1260 . break;
53-1261 . }
53-1262 . default:
53-1263 . {
53-1264 . SwError;
53-1265 . }
53-1266 . }
53-1267 .
53-1268 . A = B*C;
53-1269 . A = B*C;
53-1270 .
53-1271 . if (A lt B)
53-1272 . {
53-1273 . A = B + C;
53-1274 . D = E + F;
53-1275 . }
53-1276 .
53-1277 . A = B-C;
53-1278 . // max LOC 67
53-1279 .
53-1280 . }
53-1281 .
53-1282 .
53-1283 . /*
53-1284 . -----------------------------------------------------------------------------
53-1285 . --| NAME: stp.1.5
53-1286 . --|
53-1287 . --| ABSTRACT:
53-1288 . --| This function does stp stuff.
53-1289 . --|
53-1290 . --| RETURNS:
53-1291 . --| NONE.
53-1292 . --|
53-1293 . ----------------------------------------------------------------------------
53-1294 . */
53-1295 . static void stp.1.5(void)
53-1296 . {
53-1297 .
53-1298 . if (A ne B)
53-1299 . {
53-1300 . A = B + C;
53-1301 . D = E + F;
53-1302 . }
53-1303 .
53-1304 . A = B-C;
53-1305 .
53-1306 . if (A ne B)
53-1307 . {
53-1308 . A = B + C;
53-1309 . D = E + F;
53-1310 . }
53-1311 .
53-1312 . A = B/C;
53-1313 . A = B/C;
53-1314 . goto error;
53-1315 . A = B+C;
53-1316 . A = B/C;
53-1317 . A = B/C;
53-1318 . A = B/C;
53-1319 . A = B/C;
53-1320 .
53-1321 . if (A eq B)
53-1322 . {
53-1323 . A = B + C;
53-1324 . D = E + F;
53-1325 . }
53-1326 .
53-1327 . A = B/C;
53-1328 .
53-1329 . if (A < = B)
53-1330 . {
53-1331 . A = B + C;
53-1332 . D = E + F;
53-1333 . }
53-1334 .
53-1335 . A = B+C;
53-1336 . A = B+C;
53-1337 . A = B-C;
53-1338 . A = B/C;
53-1339 . A = B/C;
53-1340 . A = B-C;
53-1341 . A = 0x0004;
53-1342 . A = B-C;
53-1343 . A = B*C;
53-1344 .
53-1345 . if (A == B)
53-1346 . {
53-1347 . A = B + C;
53-1348 . D = E + F;
53-1349 . }
53-1350 .
53-1351 . A = B+C;
53-1352 . A = B*C;
53-1353 . A = B*C;
53-1354 . A = B/C;
53-1355 . A = B*C;
53-1356 .
53-1357 . if (A > = B)
53-1358 . {
53-1359 . A = B + C;
53-1360 . D = E + F;
53-1361 . }
53-1362 .
53-1363 . A = 0x0004;
53-1364 . A = B-C;
53-1365 . A = B*C;
53-1366 . A = B+C;
53-1367 . A = B-C;
53-1368 . A = B-C;
53-1369 . A = B/C;
53-1370 . A = B-C;
53-1371 . // max LOC 35
53-1372 .
53-1373 . }
53-1374 .
53-1375 .
53-1376 . /*
53-1377 . -----------------------------------------------------------------------------
53-1378 . --| NAME: stp.1.6
53-1379 . --|
53-1380 . --| ABSTRACT:
53-1381 . --| This function does stp stuff.
53-1382 . --|
53-1383 . --| RETURNS:
53-1384 . --| NONE.
53-1385 . --|
53-1386 . ----------------------------------------------------------------------------
53-1387 . */
53-1388 . static void stp.1.6(void)
53-1389 . {
53-1390 . /* LE SV TOC-2826 this is a stp-01.6.1 req to call isr*/
53-1391 . A = B*C;
53-1392 . A = B/C;
53-1393 . A = B-C;
53-1394 . /* LE SV TOC-2827 this is a stp-01.6.4 req to reject*/
53-1395 .
53-1396 . if (A ne B)
53-1397 . {
53-1398 . A = B + C;
53-1399 . D = E + F;
53-1400 . }
53-1401 .
53-1402 .
53-1403 . if (A > B)
53-1404 . {
53-1405 . A = B + C;
53-1406 . D = E + F;
53-1407 . }
53-1408 .
53-1409 .
53-1410 . if (A eq B)
53-1411 . {
53-1412 . A = B + C;
53-1413 . D = E + F;
53-1414 . }
53-1415 .
53-1416 . A = 0x0009;
53-1417 .
53-1418 . if (A != B)
53-1419 . {
53-1420 . A = B + C;
53-1421 . D = E + F;
53-1422 . }
53-1423 .
53-1424 . A = B+C;
53-1425 . A = B*C;
53-1426 . A = B+C;
53-1427 .
53-1428 . if (A == B)
53-1429 . {
53-1430 . A = B + C;
53-1431 . D = E + F;
53-1432 . }
53-1433 .
53-1434 . A = B*C;
53-1435 .
53-1436 . if (A lt B)
53-1437 . {
53-1438 . A = B + C;
53-1439 . D = E + F;
53-1440 . }
53-1441 .
53-1442 . A = B*C;
53-1443 .
53-1444 . if (A gt B)
53-1445 . {
53-1446 . A = B + C;
53-1447 . D = E + F;
53-1448 . }
53-1449 .
53-1450 . A = B-C;
53-1451 . A = B-C;
53-1452 . A = B-C;
53-1453 . A = B/C;
53-1454 .
53-1455 . if (A > B)
53-1456 . {
53-1457 . A = B + C;
53-1458 . D = E + F;
53-1459 . }
53-1460 .
53-1461 . A = B/C;
53-1462 . A = B*C;
53-1463 . A = B-C;
53-1464 . A = B-C;
53-1465 . A = B*C;
53-1466 . A = B+C;
53-1467 . A = B-C;
53-1468 . A = B*C;
53-1469 . A = B*C;
53-1470 .
53-1471 . switch (stp stuff)
53-1472 . {
53-1473 . case one:
53-1474 . {
53-1475 . run_this;
53-1476 . break;
53-1477 . }
53-1478 . case two:
53-1479 . {
53-1480 . run_this;
53-1481 . break;
53-1482 . }
53-1483 . default:
53-1484 . {
53-1485 . SwError;
53-1486 . }
53-1487 . }
53-1488 .
53-1489 . A = B*C;
53-1490 .
53-1491 . if (A != B)
53-1492 . {
53-1493 . A = B + C;
53-1494 . D = E + F;
53-1495 . }
53-1496 .
53-1497 . A = B*C;
53-1498 . A = B-C;
53-1499 .
53-1500 . switch (stp stuff)
53-1501 . {
53-1502 . case one:
53-1503 . {
53-1504 . run_this;
53-1505 . break;
53-1506 . }
53-1507 . case two:
53-1508 . {
53-1509 . run_this;
53-1510 . break;
53-1511 . }
53-1512 . default:
53-1513 . {
53-1514 . SwError;
53-1515 . }
53-1516 . }
53-1517 .
53-1518 . A = 0x0003;
53-1519 . A = B+C;
53-1520 . A = B+C;
53-1521 . send_buffer = (U16 *) malloc(size+1);
53-1522 . A = B+C;
53-1523 . A = B+C;
53-1524 .
53-1525 . if (A < = B)
53-1526 . {
53-1527 . A = B + C;
53-1528 . D = E + F;
53-1529 . }
53-1530 .
53-1531 . A = B+C;
53-1532 . A = B+C;
53-1533 . A = B*C;
53-1534 .
53-1535 . if (A eq B)
53-1536 . {
53-1537 . A = B + C;
53-1538 . D = E + F;
53-1539 . }
53-1540 .
53-1541 .
53-1542 . if (A ne B)
53-1543 . {
53-1544 . A = B + C;
53-1545 . D = E + F;
53-1546 . }
53-1547 .
53-1548 . A = B-C;
53-1549 .
53-1550 . if (A < = B)
53-1551 . {
53-1552 . A = B + C;
53-1553 . D = E + F;
53-1554 . }
53-1555 .
53-1556 . // max LOC 47
53-1557 .
53-1558 . }
53-1559 .
53-1560 .
53-1561 . /*
53-1562 . -----------------------------------------------------------------------------
53-1563 . --| NAME: stp.1.7
53-1564 . --|
53-1565 . --| ABSTRACT:
53-1566 . --| This function does stp stuff.
53-1567 . --|
53-1568 . --| RETURNS:
53-1569 . --| NONE.
53-1570 . --|
53-1571 . ----------------------------------------------------------------------------
53-1572 . */
53-1573 . static void stp.1.7(void)
53-1574 . {
53-1575 . A = B-C;
53-1576 . A = B+C;
53-1577 . send_buffer = (U16 *) malloc(size+1);
53-1578 . A = B*C;
53-1579 .
53-1580 . if (A > B)
53-1581 . {
53-1582 . A = B + C;
53-1583 . D = E + F;
53-1584 . }
53-1585 .
53-1586 . A = B-C;
53-1587 .
53-1588 . if (A ne B)
53-1589 . {
53-1590 . A = B + C;
53-1591 . D = E + F;
53-1592 . }
53-1593 .
53-1594 . A = B*C;
53-1595 . A = B/C;
53-1596 . A = B*C;
53-1597 .
53-1598 . if (A < = B)
53-1599 . {
53-1600 . A = B + C;
53-1601 . D = E + F;
53-1602 . }
53-1603 .
53-1604 . A = B+C;
53-1605 . A = B-C;
53-1606 . A = B-C;
53-1607 . A = B-C;
53-1608 .
53-1609 . if (A < B)
53-1610 . {
53-1611 . A = B + C;
53-1612 . D = E + F;
53-1613 . }
53-1614 .
53-1615 .
53-1616 . if ($stp stuff > $otherstp stuff)
53-1617 . /* LE SV TOC-008 we really should log all error calls */
53-1618 . {
53-1619 . A = B + C;
53-1620 . }
53-1621 .
53-1622 .
53-1623 . if (A > = B)
53-1624 . {
53-1625 . A = B + C;
53-1626 . D = E + F;
53-1627 . }
53-1628 .
53-1629 .
53-1630 . if (A < B)
53-1631 . {
53-1632 . A = B + C;
53-1633 . D = E + F;
53-1634 . }
53-1635 .
53-1636 . A = B*C;
53-1637 . A = B/C;
53-1638 . A = B-C;
53-1639 . /* LE SV TOC-2828 this is a stp-01.7.21 req to increment*/
53-1640 . A = B-C;
53-1641 . // max LOC 21
53-1642 .
53-1643 . }
53-1644 .
53-1645 .
53-1646 . /*
53-1647 . -----------------------------------------------------------------------------
53-1648 . --| NAME: stp.1.8
53-1649 . --|
53-1650 . --| ABSTRACT:
53-1651 . --| This function does stp stuff.
53-1652 . --|
53-1653 . --| RETURNS:
53-1654 . --| NONE.
53-1655 . --|
53-1656 . ----------------------------------------------------------------------------
53-1657 . */
53-1658 . static void stp.1.8(void)
53-1659 . {
53-1660 .
53-1661 . if (A le B)
53-1662 . {
53-1663 . A = B + C;
53-1664 . D = E + F;
53-1665 . }
53-1666 .
53-1667 . A = B-C;
53-1668 .
53-1669 . switch (stp stuff)
53-1670 . {
53-1671 . case one:
53-1672 . {
53-1673 . switch (nested)
53-1674 . {
53-1675 . case:
53-1676 . X = Y + Z;
53-1677 . case:
53-1678 . X = Y + Z;
53-1679 . default:
53-1680 . SwError;
53-1681 . }
53-1682 . }
53-1683 . case two:
53-1684 . {
53-1685 . run_this;
53-1686 . break;
53-1687 . }
53-1688 . default:
53-1689 . {
53-1690 . SwError;
53-1691 . }
53-1692 . }
53-1693 .
53-1694 . A = B*C;
53-1695 . /* LE SV TOC-2829 this is a stp-01.8.4 req to verify*/
53-1696 . A = B/C;
53-1697 .
53-1698 . if (A != B)
53-1699 . {
53-1700 . A = B + C;
53-1701 . D = E + F;
53-1702 . }
53-1703 .
53-1704 . A = B-C;
53-1705 . A = B*C;
53-1706 . /* LE SV TOC-2830 this is a stp-01.8.8 req to transform*/
53-1707 . A = B-C;
53-1708 .
53-1709 . if ($stp stuff > $otherstp stuff)
53-1710 . /* LE SV TOC-008 we really should log all error calls */
53-1711 . {
53-1712 . A = B + C;
53-1713 . }
53-1714 .
53-1715 . A = B+C;
53-1716 . A = B*C;
53-1717 . A = B*C;
53-1718 . /* LE SV TOC-2831 this is a stp-01.8.12 req to validate*/
53-1719 .
53-1720 . if (A != B)
53-1721 . {
53-1722 . A = B + C;
53-1723 . D = E + F;
53-1724 . }
53-1725 .
53-1726 .
53-1727 . if (A le B)
53-1728 . {
53-1729 . A = B + C;
53-1730 . D = E + F;
53-1731 . }
53-1732 .
53-1733 . A = B/C;
53-1734 . A = B+C;
53-1735 .
53-1736 . if (A eq B)
53-1737 . {
53-1738 . A = B + C;
53-1739 . D = E + F;
53-1740 . }
53-1741 .
53-1742 .
53-1743 . if (A le B)
53-1744 . {
53-1745 . A = B + C;
53-1746 . D = E + F;
53-1747 . }
53-1748 .
53-1749 . A = B-C;
53-1750 . A = B/C;
53-1751 . A = B-C;
53-1752 . A = B/C;
53-1753 . A = B-C;
53-1754 . A = B-C;
53-1755 . A = B/C;
53-1756 .
53-1757 . if (A > = B)
53-1758 . {
53-1759 . A = B + C;
53-1760 . D = E + F;
53-1761 . }
53-1762 .
53-1763 .
53-1764 . switch (stp stuff)
53-1765 . {
53-1766 . case one:
53-1767 . {
53-1768 . run_this;
53-1769 . break;
53-1770 . }
53-1771 . case two:
53-1772 . {
53-1773 . run_this;
53-1774 . break;
53-1775 . }
53-1776 . default:
53-1777 . {
53-1778 . SwError;
53-1779 . }
53-1780 . }
53-1781 .
53-1782 . A = B-C;
53-1783 . A = B/C;
53-1784 .
53-1785 . if (A eq B)
53-1786 . {
53-1787 . A = B + C;
53-1788 . D = E + F;
53-1789 . }
53-1790 .
53-1791 . A = B/C;
53-1792 . A = B+C;
53-1793 . A = B*C;
53-1794 . A = B-C;
53-1795 . A = B/C;
53-1796 .
53-1797 . if (A > B)
53-1798 . {
53-1799 . A = B + C;
53-1800 . D = E + F;
53-1801 . }
53-1802 .
53-1803 . A = B/C;
53-1804 . A = B/C;
53-1805 . // max LOC 37
53-1806 .
53-1807 . }
53-1808 .
53-1809 .
53-1810 . /*
53-1811 . -----------------------------------------------------------------------------
53-1812 . --| NAME: stp.1.9
53-1813 . --|
53-1814 . --| ABSTRACT:
53-1815 . --| This function does stp stuff.
53-1816 . --|
53-1817 . --| RETURNS:
53-1818 . --| NONE.
53-1819 . --|
53-1820 . ----------------------------------------------------------------------------
53-1821 . */
53-1822 . static void stp.1.9(void)
53-1823 . {
53-1824 . goto error;
53-1825 . A = B/C;
53-1826 . A = B+C;
53-1827 . A = B+C;
53-1828 .
53-1829 . switch (stp stuff)
53-1830 . {
53-1831 . case one:
53-1832 . {
53-1833 . run_this;
53-1834 . break;
53-1835 . }
53-1836 . case two:
53-1837 . {
53-1838 . run_this;
53-1839 . break;
53-1840 . }
53-1841 . default:
53-1842 . {
53-1843 . SwError;
53-1844 . }
53-1845 . }
53-1846 .
53-1847 . A = B/C;
53-1848 . A = B+C;
53-1849 . A = B+C;
53-1850 . A = B/C;
53-1851 . A = B+C;
53-1852 . A = B+C;
53-1853 . A = B-C;
53-1854 . A = B/C;
53-1855 . A = B-C;
53-1856 .
53-1857 . #ifdef LAZY
53-1858 . // this is not nice
53-1859 . A = B + C;
53-1860 . A = B + C;
53-1861 . #endif
53-1862 .
53-1863 . A = B*C;
53-1864 .
53-1865 . if (A ne B)
53-1866 . {
53-1867 . A = B + C;
53-1868 . D = E + F;
53-1869 . }
53-1870 .
53-1871 . A = B-C;
53-1872 . A = B+C;
53-1873 .
53-1874 . if (A > B)
53-1875 . {
53-1876 . A = B + C;
53-1877 . D = E + F;
53-1878 . }
53-1879 .
53-1880 . // max LOC 18
53-1881 .
53-1882 . }
53-1883 .
53-1884 .
53-1885 . /*
53-1886 . -----------------------------------------------------------------------------
53-1887 . --| NAME: stp.1.10
53-1888 . --|
53-1889 . --| ABSTRACT:
53-1890 . --| This function does stp stuff.
53-1891 . --|
53-1892 . --| RETURNS:
53-1893 . --| NONE.
53-1894 . --|
53-1895 . ----------------------------------------------------------------------------
53-1896 . */
53-1897 . static void stp.1.10(void)
53-1898 . {
53-1899 . A = B+C;
53-1900 . A = B*C;
53-1901 . A = B+C;
53-1902 . A = B-C;
53-1903 . A = B+C;
53-1904 . A = B-C;
53-1905 . A = B*C;
53-1906 . /* LE SV TOC-2832 this is a stp-01.10.8 req to detect error*/
53-1907 . A = B-C;
53-1908 . A = B+C;
53-1909 . A = B/C;
53-1910 . A = B+C;
53-1911 . A = 0x0006;
53-1912 . A = B+C;
53-1913 . A = B/C;
53-1914 . A = B-C;
53-1915 . send_buffer = (U16 *) malloc(size+1);
53-1916 . A = B*C;
53-1917 . A = B+C;
53-1918 .
53-1919 . if (A le B)
53-1920 . {
53-1921 . A = B + C;
53-1922 . D = E + F;
53-1923 . }
53-1924 .
53-1925 .
53-1926 . if (A > B)
53-1927 . {
53-1928 . A = B + C;
53-1929 . D = E + F;
53-1930 . }
53-1931 .
53-1932 . A = B-C;
53-1933 . A = B*C;
53-1934 . A = B-C;
53-1935 . /* LE SV TOC-2833 this is a stp-01.10.22 req to set Real Time Clock*/
53-1936 .
53-1937 . if (A gt B)
53-1938 . {
53-1939 . A = B + C;
53-1940 . D = E + F;
53-1941 . }
53-1942 .
53-1943 .
53-1944 . if (A == B)
53-1945 . {
53-1946 . A = B + C;
53-1947 . D = E + F;
53-1948 . }
53-1949 .
53-1950 . A = B*C;
53-1951 . /* LE SV TOC-2834 this is a stp-01.10.25 req to enable*/
53-1952 . A = B/C;
53-1953 .
53-1954 . if (A < B)
53-1955 . {
53-1956 . A = B + C;
53-1957 . D = E + F;
53-1958 . }
53-1959 .
53-1960 . A = B-C;
53-1961 . A = B/C;
53-1962 . A = 0x0004;
53-1963 . A = B-C;
53-1964 . A = B+C;
53-1965 .
53-1966 . if (A < = B)
53-1967 . {
53-1968 . A = B + C;
53-1969 . D = E + F;
53-1970 . }
53-1971 .
53-1972 . A = B*C;
53-1973 . A = B-C;
53-1974 . /* LE SV TOC-2835 this is a stp-01.10.34 req to audit*/
53-1975 .
53-1976 . if (A eq B)
53-1977 . {
53-1978 . A = B + C;
53-1979 . D = E + F;
53-1980 . }
53-1981 .
53-1982 . A = B*C;
53-1983 .
53-1984 . if (A eq B)
53-1985 . {
53-1986 . A = B + C;
53-1987 . D = E + F;
53-1988 . }
53-1989 .
53-1990 . A = B/C;
53-1991 .
53-1992 . if (A > = B)
53-1993 . {
53-1994 . A = B + C;
53-1995 . D = E + F;
53-1996 . }
53-1997 .
53-1998 . A = B*C;
53-1999 . A = B/C;
53-2000 .
53-2001 . switch (stp stuff)
53-2002 . {
53-2003 . case one:
53-2004 . {
53-2005 . run_this;
53-2006 . break;
53-2007 . }
53-2008 . case two:
53-2009 . {
53-2010 . run_this;
53-2011 . break;
53-2012 . }
53-2013 . default:
53-2014 . {
53-2015 . SwError;
53-2016 . }
53-2017 . }
53-2018 .
53-2019 .
53-2020 . if (A eq B)
53-2021 . {
53-2022 . A = B + C;
53-2023 . D = E + F;
53-2024 . }
53-2025 .
53-2026 . A = 0x0006;
53-2027 . A = B-C;
53-2028 . A = B-C;
53-2029 .
53-2030 . switch (stp stuff)
53-2031 . {
53-2032 . case one:
53-2033 . {
53-2034 . run_this;
53-2035 . break;
53-2036 . }
53-2037 . case two:
53-2038 . {
53-2039 . run_this;
53-2040 . break;
53-2041 . }
53-2042 . default:
53-2043 . {
53-2044 . SwError;
53-2045 . }
53-2046 . }
53-2047 .
53-2048 . A = B*C;
53-2049 . A = B*C;
53-2050 .
53-2051 . if (A lt B)
53-2052 . {
53-2053 . A = B + C;
53-2054 . D = E + F;
53-2055 . }
53-2056 .
53-2057 .
53-2058 . if (A gt B)
53-2059 . {
53-2060 . A = B + C;
53-2061 . D = E + F;
53-2062 . }
53-2063 .
53-2064 . A = B/C;
53-2065 .
53-2066 . if (A == B)
53-2067 . {
53-2068 . A = B + C;
53-2069 . D = E + F;
53-2070 . }
53-2071 .
53-2072 . A = B*C;
53-2073 . A = B/C;
53-2074 . A = B-C;
53-2075 . // max LOC 54
53-2076 .
53-2077 . }
53-2078 .
53-2079 .
53-2080 . /*
53-2081 . -----------------------------------------------------------------------------
53-2082 . --| NAME: stp.1.11
53-2083 . --|
53-2084 . --| ABSTRACT:
53-2085 . --| This function does stp stuff.
53-2086 . --|
53-2087 . --| RETURNS:
53-2088 . --| NONE.
53-2089 . --|
53-2090 . ----------------------------------------------------------------------------
53-2091 . */
53-2092 . static void stp.1.11(void)
53-2093 . {
53-2094 . A = (int)B + C;
53-2095 . A = B+C;
53-2096 . A = B/C;
53-2097 . A = B/C;
53-2098 . A = B-C;
53-2099 .
53-2100 . if (A > = B)
53-2101 . {
53-2102 . A = B + C;
53-2103 . D = E + F;
53-2104 . }
53-2105 .
53-2106 . // max LOC 5
53-2107 .
53-2108 . }
53-2109 .
53-2110 .
53-2111 . /*
53-2112 . -----------------------------------------------------------------------------
53-2113 . --| NAME: stp.1.12
53-2114 . --|
53-2115 . --| ABSTRACT:
53-2116 . --| This function does stp stuff.
53-2117 . --|
53-2118 . --| RETURNS:
53-2119 . --| NONE.
53-2120 . --|
53-2121 . ----------------------------------------------------------------------------
53-2122 . */
53-2123 . static void stp.1.12(void)
53-2124 . {
53-2125 . A = B-C;
53-2126 .
53-2127 . switch (stp stuff)
53-2128 . {
53-2129 . case one:
53-2130 . {
53-2131 . run_this;
53-2132 . break;
53-2133 . }
53-2134 . case two:
53-2135 . {
53-2136 . run_this;
53-2137 . break;
53-2138 . }
53-2139 . default:
53-2140 . {
53-2141 . SwError;
53-2142 . }
53-2143 . }
53-2144 .
53-2145 .
53-2146 . if (A le B)
53-2147 . {
53-2148 . A = B + C;
53-2149 . D = E + F;
53-2150 . }
53-2151 .
53-2152 . A = B*C;
53-2153 .
53-2154 . if (A ge B)
53-2155 . {
53-2156 . A = B + C;
53-2157 . D = E + F;
53-2158 . }
53-2159 .
53-2160 . A = B+C;
53-2161 . A = B-C;
53-2162 .
53-2163 . if (A eq B)
53-2164 . {
53-2165 . A = B + C;
53-2166 . D = E + F;
53-2167 . }
53-2168 .
53-2169 . A = B*C;
53-2170 . /* LE SV TOC-2836 this is a stp-01.12.10 req to validate*/
53-2171 . A = B-C;
53-2172 . A = B/C;
53-2173 . A = B*C;
53-2174 . A = B*C;
53-2175 . A = B*C;
53-2176 . A = 0x0002;
53-2177 . A = B/C;
53-2178 . A = B+C;
53-2179 . A = B*C;
53-2180 . A = B/C;
53-2181 . /* LE SV TOC-2837 this is a stp-01.12.19 req to reject*/
53-2182 .
53-2183 . if (A gt B)
53-2184 . {
53-2185 . A = B + C;
53-2186 . D = E + F;
53-2187 . }
53-2188 .
53-2189 . A = B*C;
53-2190 . A = B/C;
53-2191 . A = B+C;
53-2192 .
53-2193 . if (A eq B)
53-2194 . {
53-2195 . A = B + C;
53-2196 . D = E + F;
53-2197 . }
53-2198 .
53-2199 . A = B/C;
53-2200 . A = B*C;
53-2201 .
53-2202 . if (A gt B)
53-2203 . {
53-2204 . A = B + C;
53-2205 . D = E + F;
53-2206 . }
53-2207 .
53-2208 . A = B/C;
53-2209 . /* LE SV TOC-2838 this is a stp-01.12.28 req to fail*/
53-2210 . A = B-C;
53-2211 . A = B*C;
53-2212 . A = B/C;
53-2213 . A = B-C;
53-2214 . A = B-C;
53-2215 . A = 0x0008;
53-2216 . A = B-C;
53-2217 .
53-2218 . if (A ne B)
53-2219 . {
53-2220 . A = B + C;
53-2221 . D = E + F;
53-2222 . }
53-2223 .
53-2224 . /* LE SV TOC-2839 this is a stp-01.12.35 req to verify*/
53-2225 .
53-2226 . if (A > = B)
53-2227 . {
53-2228 . A = B + C;
53-2229 . D = E + F;
53-2230 . }
53-2231 .
53-2232 . A = (float)B + C;
53-2233 . A = B+C;
53-2234 . A = B/C;
53-2235 . /* LE SV TOC-2840 this is a stp-01.12.38 req to set RTC*/
53-2236 .
53-2237 . if (A > = B)
53-2238 . {
53-2239 . A = B + C;
53-2240 . D = E + F;
53-2241 . }
53-2242 .
53-2243 . /* LE SV TOC-2841 this is a stp-01.12.39 req to increment*/
53-2244 . A = B*C;
53-2245 . A = B-C;
53-2246 . // max LOC 40
53-2247 .
53-2248 . }
53-2249 .
53-2250 .
53-2251 . /*
53-2252 . -----------------------------------------------------------------------------
53-2253 . --| NAME: stp.1.13
53-2254 . --|
53-2255 . --| ABSTRACT:
53-2256 . --| This function does stp stuff.
53-2257 . --|
53-2258 . --| RETURNS:
53-2259 . --| NONE.
53-2260 . --|
53-2261 . ----------------------------------------------------------------------------
53-2262 . */
53-2263 . static void stp.1.13(void)
53-2264 . {
53-2265 . A = B-C;
53-2266 . /* LE SV TOC-2842 this is a stp-01.13.2 req to set RTC*/
53-2267 . A = B*C;
53-2268 . A = B*C;
53-2269 .
53-2270 . if (A > = B)
53-2271 . {
53-2272 . A = B + C;
53-2273 . D = E + F;
53-2274 . }
53-2275 .
53-2276 . A = B+C;
53-2277 . A = B*C;
53-2278 .
53-2279 . if (A ge B)
53-2280 . {
53-2281 . A = B + C;
53-2282 . D = E + F;
53-2283 . }
53-2284 .
53-2285 . A = B-C;
53-2286 .
53-2287 . if (A le B)
53-2288 . {
53-2289 . A = B + C;
53-2290 . D = E + F;
53-2291 . }
53-2292 .
53-2293 . A = B/C;
53-2294 .
53-2295 . if (A gt B)
53-2296 . {
53-2297 . A = B + C;
53-2298 . D = E + F;
53-2299 . }
53-2300 .
53-2301 . A = B*C;
53-2302 . A = B/C;
53-2303 . A = B+C;
53-2304 . A = B*C;
53-2305 .
53-2306 . if (A > = B)
53-2307 . {
53-2308 . A = B + C;
53-2309 . D = E + F;
53-2310 . }
53-2311 .
53-2312 . A = B+C;
53-2313 . A = B-C;
53-2314 .
53-2315 . if (A ge B)
53-2316 . {
53-2317 . A = B + C;
53-2318 . D = E + F;
53-2319 . }
53-2320 .
53-2321 .
53-2322 . if (A eq B)
53-2323 . {
53-2324 . A = B + C;
53-2325 . D = E + F;
53-2326 . }
53-2327 .
53-2328 .
53-2329 . if (A gt B)
53-2330 . {
53-2331 . A = B + C;
53-2332 . D = E + F;
53-2333 . }
53-2334 .
53-2335 .
53-2336 . if (A == B)
53-2337 . {
53-2338 . A = B + C;
53-2339 . D = E + F;
53-2340 . }
53-2341 .
53-2342 .
53-2343 . /*
53-2344 . dead_block = C * D;
53-2345 . dead_block = E * F;
53-2346 . */
53-2347 .
53-2348 . A = B+C;
53-2349 . // max LOC 23
53-2350 .
53-2351 . }
53-2352 .
53-2353 .
53-2354 . /*
53-2355 . -----------------------------------------------------------------------------
53-2356 . --| NAME: stp.1.14
53-2357 . --|
53-2358 . --| ABSTRACT:
53-2359 . --| This function does stp stuff.
53-2360 . --|
53-2361 . --| RETURNS:
53-2362 . --| NONE.
53-2363 . --|
53-2364 . ----------------------------------------------------------------------------
53-2365 . */
53-2366 . static void stp.1.14(void)
53-2367 . {
53-2368 .
53-2369 . /*
53-2370 . dead_block = C * D;
53-2371 . dead_block = E * F;
53-2372 . */
53-2373 .
53-2374 . A = B-C;
53-2375 . A = B/C;
53-2376 . /* LE SV TOC-2843 this is a stp-01.14.3 req to disable*/
53-2377 . A = B-C;
53-2378 .
53-2379 . /*
53-2380 . dead_code = B - C;
53-2381 . dead_code = D - E;
53-2382 . dead_code = F - G;
53-2383 . */
53-2384 .
53-2385 . A = B*C;
53-2386 . A = B/C;
53-2387 .
53-2388 . if (A lt B)
53-2389 . {
53-2390 . A = B + C;
53-2391 . D = E + F;
53-2392 . }
53-2393 .
53-2394 .
53-2395 . if (A ge B)
53-2396 . {
53-2397 . A = B + C;
53-2398 . D = E + F;
53-2399 . }
53-2400 .
53-2401 .
53-2402 . if {
53-2403 . X = Y + Z;
53-2404 . }
53-2405 . else {
53-2406 . halt;
53-2407 . }
53-2408 .
53-2409 .
53-2410 . if (A > B)
53-2411 . {
53-2412 . A = B + C;
53-2413 . D = E + F;
53-2414 . }
53-2415 .
53-2416 . A = B/C;
53-2417 . /* LE SV TOC-2844 this is a stp-01.14.10 req to call isr*/
53-2418 .
53-2419 . switch (stp stuff)
53-2420 . {
53-2421 . case one:
53-2422 . {
53-2423 . run_this;
53-2424 . break;
53-2425 . }
53-2426 . case two:
53-2427 . {
53-2428 . run_this;
53-2429 . break;
53-2430 . }
53-2431 . default:
53-2432 . {
53-2433 . SwError;
53-2434 . }
53-2435 . }
53-2436 .
53-2437 . // max LOC 10
53-2438 .
53-2439 . }
53-2440 .
53 53 Result: result/source/ft-app/ft-app-B1.1/stp/stp-01.c
54 54 Source: source/ft-app/ft-app-B1.1/stp/stp-02.c
54-0 . /*
54-1 . ----------------------------------------------------------------------------
54-2 . --| BEGIN PROLOGUE
54-3 . --|
54-4 . --| CLASSIFICATION: UNCLASSIFIED
54-5 . --|
54-6 . --| FILE NAME: stp-02.c
54-7 . --|
54-8 . --| ABSTRACT:
54-9 . --| This file contains the 12 functions that do file stp stuff.
54-10 . --|
54-11 . --| HISTORY:
54-12 . --| CCCQ_NAME:
54-13 . --| CCCQ_VER:
54-14 . --|
54-15 . --| END PROLOGUE
54-16 . ----------------------------------------------------------------------------
54-17 . */
54-18 .
54-19 . #define D;
54-20 . #include D;
54-21 . #define C;
54-22 . #include C;
54-23 . #include D;
54-24 . int A;
54-25 . #define D;
54-26 . double C;
54-27 . #define B;
54-28 .
54-29 .
54-30 .
54-31 . /*
54-32 . -----------------------------------------------------------------------------
54-33 . --| NAME: stp.2.1
54-34 . --|
54-35 . --| ABSTRACT:
54-36 . --| This function does stp stuff.
54-37 . --|
54-38 . --| RETURNS:
54-39 . --| NONE.
54-40 . --|
54-41 . ----------------------------------------------------------------------------
54-42 . */
54-43 . static void stp.2.1(void)
54-44 . {
54-45 .
54-46 . switch (stp stuff)
54-47 . {
54-48 . case:
54-49 . case:
54-50 . // stacked case statements but only if there is a new line in between
54-51 .
54-52 . case:
54-53 . case:
54-54 . case:
54-55 . {
54-56 . run_this;
54-57 . break;
54-58 . }
54-59 . default:
54-60 . {
54-61 . halt;
54-62 . }
54-63 . }
54-64 .
54-65 . A = B/C;
54-66 .
54-67 . if (A > B)
54-68 . {
54-69 . A = B + C;
54-70 . D = E + F;
54-71 . }
54-72 .
54-73 .
54-74 . if (A < = B)
54-75 . {
54-76 . A = B + C;
54-77 . D = E + F;
54-78 . }
54-79 .
54-80 .
54-81 . switch (stp stuff)
54-82 . {
54-83 . case one:
54-84 . {
54-85 . run_this;
54-86 . break;
54-87 . }
54-88 . case two:
54-89 . {
54-90 . run_this;
54-91 . break;
54-92 . }
54-93 . default:
54-94 . {
54-95 . SwError;
54-96 . }
54-97 . }
54-98 .
54-99 .
54-100 . if (A > = B)
54-101 . {
54-102 . A = B + C;
54-103 . D = E + F;
54-104 . }
54-105 .
54-106 . A = B+C;
54-107 . A = B/C;
54-108 . A = B/C;
54-109 .
54-110 . if (A eq B)
54-111 . {
54-112 . A = B + C;
54-113 . D = E + F;
54-114 . }
54-115 .
54-116 . // max LOC 9
54-117 .
54-118 . }
54-119 .
54-120 .
54-121 . /*
54-122 . -----------------------------------------------------------------------------
54-123 . --| NAME: stp.2.2
54-124 . --|
54-125 . --| ABSTRACT:
54-126 . --| This function does stp stuff.
54-127 . --|
54-128 . --| RETURNS:
54-129 . --| NONE.
54-130 . --|
54-131 . ----------------------------------------------------------------------------
54-132 . */
54-133 . static void stp.2.2(void)
54-134 . {
54-135 .
54-136 . if (A lt B)
54-137 . {
54-138 . A = B + C;
54-139 . D = E + F;
54-140 . }
54-141 .
54-142 . A = B+C;
54-143 .
54-144 . if (A lt B)
54-145 . {
54-146 . A = B + C;
54-147 . D = E + F;
54-148 . }
54-149 .
54-150 .
54-151 . if (A < = B)
54-152 . {
54-153 . A = B + C;
54-154 . D = E + F;
54-155 . }
54-156 .
54-157 .
54-158 . if (A lt B)
54-159 . {
54-160 . A = B + C;
54-161 . D = E + F;
54-162 . }
54-163 .
54-164 . A = B+C;
54-165 . A = B-C;
54-166 . A = B*C;
54-167 .
54-168 . /*
54-169 . dead_block = C * D;
54-170 . dead_block = E * F;
54-171 . */
54-172 .
54-173 . A = B+C;
54-174 . A = B-C;
54-175 . A = B*C;
54-176 . A = B-C;
54-177 . A = B*C;
54-178 . A = B+C;
54-179 . A = B/C;
54-180 . A = B/C;
54-181 . A = B+C;
54-182 . A = B/C;
54-183 . A = B+C;
54-184 .
54-185 . switch (stp stuff)
54-186 . {
54-187 . case one:
54-188 . {
54-189 . run_this;
54-190 . break;
54-191 . }
54-192 . case two:
54-193 . {
54-194 . run_this;
54-195 . break;
54-196 . }
54-197 . default:
54-198 . {
54-199 . SwError;
54-200 . }
54-201 . }
54-202 .
54-203 .
54-204 . if (A > = B)
54-205 . {
54-206 . A = B + C;
54-207 . D = E + F;
54-208 . }
54-209 .
54-210 .
54-211 . if {
54-212 . X = Y + Z;
54-213 . }
54-214 . else {
54-215 . halt;
54-216 . }
54-217 .
54-218 .
54-219 . if (A eq B)
54-220 . {
54-221 . A = B + C;
54-222 . D = E + F;
54-223 . }
54-224 .
54-225 . A = B+C;
54-226 . A = B/C;
54-227 .
54-228 . if (A le B)
54-229 . {
54-230 . A = B + C;
54-231 . D = E + F;
54-232 . }
54-233 .
54-234 . A = B/C;
54-235 .
54-236 . if (A > B)
54-237 . {
54-238 . A = B + C;
54-239 . D = E + F;
54-240 . }
54-241 .
54-242 . A = B/C;
54-243 . A = B+C;
54-244 .
54-245 . switch (stp stuff)
54-246 . {
54-247 . case one:
54-248 . {
54-249 . run_this;
54-250 . break;
54-251 . }
54-252 . case two:
54-253 . {
54-254 . run_this;
54-255 . break;
54-256 . }
54-257 . default:
54-258 . {
54-259 . SwError;
54-260 . }
54-261 . }
54-262 .
54-263 . A = B+C;
54-264 .
54-265 . if (A < B)
54-266 . {
54-267 . A = B + C;
54-268 . D = E + F;
54-269 . }
54-270 .
54-271 . A = B*C;
54-272 .
54-273 . if (A ge B)
54-274 . {
54-275 . A = B + C;
54-276 . D = E + F;
54-277 . }
54-278 .
54-279 .
54-280 . if (A == B)
54-281 . {
54-282 . A = B + C;
54-283 . D = E + F;
54-284 . }
54-285 .
54-286 . A = B-C;
54-287 .
54-288 . if (A > = B)
54-289 . {
54-290 . A = B + C;
54-291 . D = E + F;
54-292 . }
54-293 .
54-294 . A = B-C;
54-295 . A = B-C;
54-296 . FreePtr = HmiStringPtr;
54-297 .
54-298 . if (A > B)
54-299 . {
54-300 . A = B + C;
54-301 . D = E + F;
54-302 . }
54-303 .
54-304 . A = B/C;
54-305 .
54-306 . /* dead_code = B + C;
54-307 . dead_code = D + E;
54-308 . dead_code = F + G; */
54-309 .
54-310 . A = B*C;
54-311 . // max LOC 42
54-312 .
54-313 . }
54-314 .
54-315 .
54-316 . /*
54-317 . -----------------------------------------------------------------------------
54-318 . --| NAME: stp.2.3
54-319 . --|
54-320 . --| ABSTRACT:
54-321 . --| This function does stp stuff.
54-322 . --|
54-323 . --| RETURNS:
54-324 . --| NONE.
54-325 . --|
54-326 . ----------------------------------------------------------------------------
54-327 . */
54-328 . static void stp.2.3(void)
54-329 . {
54-330 .
54-331 . if (A > B)
54-332 . {
54-333 . A = B + C;
54-334 . D = E + F;
54-335 . }
54-336 .
54-337 . A = B/C;
54-338 . A = B/C;
54-339 . A = B*C;
54-340 . A = B/C;
54-341 .
54-342 . if (A != B)
54-343 . {
54-344 . A = B + C;
54-345 . D = E + F;
54-346 . }
54-347 .
54-348 . A = 0x0003;
54-349 . A = B/C;
54-350 . A = B*C;
54-351 . A = B+C;
54-352 . A = B+C;
54-353 . A = B*C;
54-354 . A = B*C;
54-355 . A = B/C;
54-356 . A = B*C;
54-357 .
54-358 . if (A gt B)
54-359 . {
54-360 . A = B + C;
54-361 . D = E + F;
54-362 . }
54-363 .
54-364 . A = B-C;
54-365 . A = B/C;
54-366 . A = B+C;
54-367 . A = B-C;
54-368 . A = B/C;
54-369 . A = (float)B + C;
54-370 .
54-371 . if (A eq B)
54-372 . {
54-373 . A = B + C;
54-374 . D = E + F;
54-375 . }
54-376 .
54-377 . A = B*C;
54-378 . A = B-C;
54-379 . /* LE SV TOC-2845 this is a stp-02.3.24 req to call isr*/
54-380 . A = B+C;
54-381 .
54-382 . if (A le B)
54-383 . {
54-384 . A = B + C;
54-385 . D = E + F;
54-386 . }
54-387 .
54-388 . A = B/C;
54-389 . A = B-C;
54-390 .
54-391 . if (A != B)
54-392 . {
54-393 . A = B + C;
54-394 . D = E + F;
54-395 . }
54-396 .
54-397 .
54-398 . if (A gt B)
54-399 . {
54-400 . A = B + C;
54-401 . D = E + F;
54-402 . }
54-403 .
54-404 . A = B+C;
54-405 . A = B*C;
54-406 . A = B*C;
54-407 .
54-408 . if (A == B)
54-409 . {
54-410 . A = B + C;
54-411 . D = E + F;
54-412 . }
54-413 .
54-414 . A = B/C;
54-415 . A = B/C;
54-416 .
54-417 . if (A eq B)
54-418 . {
54-419 . A = B + C;
54-420 . D = E + F;
54-421 . }
54-422 .
54-423 . A = B+C;
54-424 . A = B-C;
54-425 .
54-426 . if (A > B)
54-427 . {
54-428 . A = B + C;
54-429 . D = E + F;
54-430 . }
54-431 .
54-432 . A = 0x0002;
54-433 . A = B+C;
54-434 . A = B/C;
54-435 .
54-436 . if (A eq B)
54-437 . {
54-438 . A = B + C;
54-439 . D = E + F;
54-440 . }
54-441 .
54-442 . // max LOC 42
54-443 .
54-444 . }
54-445 .
54-446 .
54-447 . /*
54-448 . -----------------------------------------------------------------------------
54-449 . --| NAME: stp.2.4
54-450 . --|
54-451 . --| ABSTRACT:
54-452 . --| This function does stp stuff.
54-453 . --|
54-454 . --| RETURNS:
54-455 . --| NONE.
54-456 . --|
54-457 . ----------------------------------------------------------------------------
54-458 . */
54-459 . static void stp.2.4(void)
54-460 . {
54-461 .
54-462 . switch (stp stuff)
54-463 . {
54-464 . case:
54-465 . case:
54-466 . // stacked case statements but only if there is a new line in between
54-467 .
54-468 . case:
54-469 . case:
54-470 . case:
54-471 . {
54-472 . run_this;
54-473 . break;
54-474 . }
54-475 . default:
54-476 . {
54-477 . halt;
54-478 . }
54-479 . }
54-480 .
54-481 . A = B*C;
54-482 . A = B/C;
54-483 . A = B*C;
54-484 .
54-485 . if (A ge B)
54-486 . {
54-487 . A = B + C;
54-488 . D = E + F;
54-489 . }
54-490 .
54-491 . A = B-C;
54-492 .
54-493 . if (A gt B)
54-494 . {
54-495 . A = B + C;
54-496 . D = E + F;
54-497 . }
54-498 .
54-499 . A = B/C;
54-500 .
54-501 . /* dead_block = C * D;
54-502 . dead_block = E * F; */
54-503 .
54-504 . A = B-C;
54-505 . A = B+C;
54-506 . A = B+C;
54-507 .
54-508 . if (A lt B)
54-509 . {
54-510 . A = B + C;
54-511 . D = E + F;
54-512 . }
54-513 .
54-514 . A = B+C;
54-515 . A = B-C;
54-516 .
54-517 . if (A ge B)
54-518 . {
54-519 . A = B + C;
54-520 . D = E + F;
54-521 . }
54-522 .
54-523 .
54-524 . #ifdef LAZY
54-525 . // this is not nice
54-526 . A = B + C;
54-527 . A = B + C;
54-528 . #endif
54-529 .
54-530 . A = B-C;
54-531 . A = B/C;
54-532 . A = B*C;
54-533 . A = B/C;
54-534 . A = B-C;
54-535 .
54-536 . if (A ne B)
54-537 . {
54-538 . A = B + C;
54-539 . D = E + F;
54-540 . }
54-541 .
54-542 . A = B+C;
54-543 . A = B+C;
54-544 . A = B/C;
54-545 . A = B-C;
54-546 .
54-547 . /*
54-548 . dead_block = C * D;
54-549 . dead_block = E * F;
54-550 . */
54-551 .
54-552 . A = B*C;
54-553 .
54-554 . if (A ge B)
54-555 . {
54-556 . A = B + C;
54-557 . D = E + F;
54-558 . }
54-559 .
54-560 . A = B/C;
54-561 . A = B+C;
54-562 . A = B+C;
54-563 . A = B+C;
54-564 . // max LOC 30
54-565 .
54-566 . }
54-567 .
54-568 .
54-569 . /*
54-570 . -----------------------------------------------------------------------------
54-571 . --| NAME: stp.2.5
54-572 . --|
54-573 . --| ABSTRACT:
54-574 . --| This function does stp stuff.
54-575 . --|
54-576 . --| RETURNS:
54-577 . --| NONE.
54-578 . --|
54-579 . ----------------------------------------------------------------------------
54-580 . */
54-581 . static void stp.2.5(void)
54-582 . {
54-583 .
54-584 . if (A != B)
54-585 . {
54-586 . A = B + C;
54-587 . D = E + F;
54-588 . }
54-589 .
54-590 . A = B-C;
54-591 .
54-592 . if (A != B)
54-593 . {
54-594 . A = B + C;
54-595 . D = E + F;
54-596 . }
54-597 .
54-598 . A = B*C;
54-599 . A = B+C;
54-600 . A = B/C;
54-601 .
54-602 . switch (stp stuff)
54-603 . {
54-604 . case one:
54-605 . {
54-606 . run_this;
54-607 . break;
54-608 . }
54-609 . case two:
54-610 . {
54-611 . run_this;
54-612 . break;
54-613 . }
54-614 . default:
54-615 . {
54-616 . // missing error call
54-617 . }
54-618 . }
54-619 .
54-620 . A = B*C;
54-621 . A = B/C;
54-622 . A = B-C;
54-623 . A = B/C;
54-624 .
54-625 . if (A < = B)
54-626 . {
54-627 . A = B + C;
54-628 . D = E + F;
54-629 . }
54-630 .
54-631 .
54-632 . if (A == B)
54-633 . {
54-634 . A = B + C;
54-635 . D = E + F;
54-636 . }
54-637 .
54-638 .
54-639 . if (A > = B)
54-640 . {
54-641 . A = B + C;
54-642 . D = E + F;
54-643 . }
54-644 .
54-645 .
54-646 . if (A lt B)
54-647 . {
54-648 . A = B + C;
54-649 . D = E + F;
54-650 . }
54-651 .
54-652 . A = 0x0004;
54-653 . A = B*C;
54-654 . A = B+C;
54-655 . A = B-C;
54-656 . A = B+C;
54-657 . A = B+C;
54-658 .
54-659 . if (A lt B)
54-660 . {
54-661 . A = B + C;
54-662 . D = E + F;
54-663 . }
54-664 .
54-665 .
54-666 . if (A == B)
54-667 . {
54-668 . A = B + C;
54-669 . D = E + F;
54-670 . }
54-671 .
54-672 . A = B*C;
54-673 .
54-674 . if (A < = B)
54-675 . {
54-676 . A = B + C;
54-677 . D = E + F;
54-678 . }
54-679 .
54-680 .
54-681 . if (A > B)
54-682 . {
54-683 . A = B + C;
54-684 . D = E + F;
54-685 . }
54-686 .
54-687 .
54-688 . if (A < = B)
54-689 . {
54-690 . A = B + C;
54-691 . D = E + F;
54-692 . }
54-693 .
54-694 .
54-695 . switch (stp stuff)
54-696 . {
54-697 . case one:
54-698 . {
54-699 . run_this;
54-700 . break;
54-701 . }
54-702 . case two:
54-703 . {
54-704 . run_this;
54-705 . break;
54-706 . }
54-707 . default:
54-708 . {
54-709 . SwError;
54-710 . }
54-711 . }
54-712 .
54-713 . A = B+C;
54-714 . A = B/C;
54-715 . A = B+C;
54-716 . A = B+C;
54-717 . A = B-C;
54-718 . A = 0x0003;
54-719 .
54-720 . switch (stp stuff)
54-721 . {
54-722 . case one:
54-723 . {
54-724 . run_this;
54-725 . break;
54-726 . }
54-727 . case two:
54-728 . {
54-729 . run_this;
54-730 . break;
54-731 . }
54-732 . default:
54-733 . {
54-734 . SwError;
54-735 . }
54-736 . }
54-737 .
54-738 . A = B+C;
54-739 . A = B*C;
54-740 . A = B+C;
54-741 . A = B*C;
54-742 .
54-743 . if (A < B)
54-744 . {
54-745 . A = B + C;
54-746 . D = E + F;
54-747 . }
54-748 .
54-749 .
54-750 . if (A > B)
54-751 . {
54-752 . A = B + C;
54-753 . D = E + F;
54-754 . }
54-755 .
54-756 . A = B-C;
54-757 . A = B-C;
54-758 . A = B+C;
54-759 . A = B/C;
54-760 . A = B*C;
54-761 . A = B+C;
54-762 .
54-763 . if (A < = B)
54-764 . {
54-765 . A = B + C;
54-766 . D = E + F;
54-767 . }
54-768 .
54-769 .
54-770 . if (A ge B)
54-771 . {
54-772 . A = B + C;
54-773 . D = E + F;
54-774 . }
54-775 .
54-776 . /* LE SV TOC-2846 this is a stp-02.5.47 req to set Real Time Clock*/
54-777 . A = B/C;
54-778 .
54-779 . if (A lt B)
54-780 . {
54-781 . A = B + C;
54-782 . D = E + F;
54-783 . }
54-784 .
54-785 . A = B-C;
54-786 . // max LOC 49
54-787 .
54-788 . }
54-789 .
54-790 .
54-791 . /*
54-792 . -----------------------------------------------------------------------------
54-793 . --| NAME: stp.2.6
54-794 . --|
54-795 . --| ABSTRACT:
54-796 . --| This function does stp stuff.
54-797 . --|
54-798 . --| RETURNS:
54-799 . --| NONE.
54-800 . --|
54-801 . ----------------------------------------------------------------------------
54-802 . */
54-803 . static void stp.2.6(void)
54-804 . {
54-805 . A = B/C;
54-806 . A = B*C;
54-807 .
54-808 . if (A > = B)
54-809 . {
54-810 . A = B + C;
54-811 . D = E + F;
54-812 . }
54-813 .
54-814 .
54-815 . if (A > = B)
54-816 . {
54-817 . A = B + C;
54-818 . D = E + F;
54-819 . }
54-820 .
54-821 .
54-822 . if (A != B)
54-823 . {
54-824 . A = B + C;
54-825 . D = E + F;
54-826 . }
54-827 .
54-828 . A = B*C;
54-829 .
54-830 . if (A ge B)
54-831 . {
54-832 . A = B + C;
54-833 . D = E + F;
54-834 . }
54-835 .
54-836 . /* LE SV TOC-2847 this is a stp-02.6.8 req to audit*/
54-837 .
54-838 . if (A == B)
54-839 . {
54-840 . A = B + C;
54-841 . D = E + F;
54-842 . }
54-843 .
54-844 .
54-845 . if (A lt B)
54-846 . {
54-847 . A = B + C;
54-848 . D = E + F;
54-849 . }
54-850 .
54-851 . A = B/C;
54-852 .
54-853 . if (A > = B)
54-854 . {
54-855 . A = B + C;
54-856 . D = E + F;
54-857 . }
54-858 .
54-859 . A = 0x0006;
54-860 . A = B/C;
54-861 .
54-862 . if (A ne B)
54-863 . {
54-864 . A = B + C;
54-865 . D = E + F;
54-866 . }
54-867 .
54-868 . A = B*C;
54-869 . A = B/C;
54-870 . A = B-C;
54-871 . A = B*C;
54-872 .
54-873 . if (A le B)
54-874 . {
54-875 . A = B + C;
54-876 . D = E + F;
54-877 . }
54-878 .
54-879 . A = B/C;
54-880 . // max LOC 19
54-881 .
54-882 . }
54-883 .
54-884 .
54-885 . /*
54-886 . -----------------------------------------------------------------------------
54-887 . --| NAME: stp.2.7
54-888 . --|
54-889 . --| ABSTRACT:
54-890 . --| This function does stp stuff.
54-891 . --|
54-892 . --| RETURNS:
54-893 . --| NONE.
54-894 . --|
54-895 . ----------------------------------------------------------------------------
54-896 . */
54-897 . static void stp.2.7(void)
54-898 . {
54-899 . A = B/C;
54-900 .
54-901 . if (A < B)
54-902 . {
54-903 . A = B + C;
54-904 . D = E + F;
54-905 . }
54-906 .
54-907 .
54-908 . if (A ne B)
54-909 . {
54-910 . A = B + C;
54-911 . D = E + F;
54-912 . }
54-913 .
54-914 .
54-915 . if (A lt B)
54-916 . {
54-917 . A = B + C;
54-918 . D = E + F;
54-919 . }
54-920 .
54-921 . A = B-C;
54-922 .
54-923 . if (A > B)
54-924 . {
54-925 . A = B + C;
54-926 . D = E + F;
54-927 . }
54-928 .
54-929 . A = B+C;
54-930 .
54-931 . switch (stp stuff)
54-932 . {
54-933 . case one:
54-934 . {
54-935 . run_this;
54-936 . break;
54-937 . }
54-938 . case two:
54-939 . {
54-940 . run_this;
54-941 . break;
54-942 . }
54-943 . default:
54-944 . {
54-945 . SwError;
54-946 . }
54-947 . }
54-948 .
54-949 . A = B*C;
54-950 .
54-951 . if (A ge B)
54-952 . {
54-953 . A = B + C;
54-954 . D = E + F;
54-955 . }
54-956 .
54-957 . A = B-C;
54-958 . A = B*C;
54-959 . /* LE SV TOC-2848 this is a stp-02.7.13 req to call admin*/
54-960 .
54-961 . if (A != B)
54-962 . {
54-963 . A = B + C;
54-964 . D = E + F;
54-965 . }
54-966 .
54-967 . A = B*C;
54-968 . send_buffer = (U16 *) malloc(size+1);
54-969 . A = B*C;
54-970 .
54-971 . if (A le B)
54-972 . {
54-973 . A = B + C;
54-974 . D = E + F;
54-975 . }
54-976 .
54-977 . A = B+C;
54-978 .
54-979 . if (A ge B)
54-980 . {
54-981 . A = B + C;
54-982 . D = E + F;
54-983 . }
54-984 .
54-985 . A = B/C;
54-986 . A = B+C;
54-987 .
54-988 . if (A gt B)
54-989 . {
54-990 . A = B + C;
54-991 . D = E + F;
54-992 . }
54-993 .
54-994 .
54-995 . if (A ge B)
54-996 . {
54-997 . A = B + C;
54-998 . D = E + F;
54-999 . }
54-1000 .
54-1001 . A = B/C;
54-1002 . A = B/C;
54-1003 . A = B+C;
54-1004 .
54-1005 . if (A == B)
54-1006 . {
54-1007 . A = B + C;
54-1008 . D = E + F;
54-1009 . }
54-1010 .
54-1011 . A = B+C;
54-1012 . /* LE SV TOC-2849 this is a stp-02.7.28 req to translate*/
54-1013 . A = B/C;
54-1014 .
54-1015 . if (A lt B)
54-1016 . {
54-1017 . A = B + C;
54-1018 . D = E + F;
54-1019 . }
54-1020 .
54-1021 .
54-1022 . if (A == B)
54-1023 . {
54-1024 . A = B + C;
54-1025 . D = E + F;
54-1026 . }
54-1027 .
54-1028 . A = B-C;
54-1029 . A = B/C;
54-1030 . A = B/C;
54-1031 . A = B+C;
54-1032 .
54-1033 . if (A != B)
54-1034 . {
54-1035 . A = B + C;
54-1036 . D = E + F;
54-1037 . }
54-1038 .
54-1039 . A = B-C;
54-1040 . A = B/C;
54-1041 . /* LE SV TOC-2850 this is a stp-02.7.38 req to call isr*/
54-1042 .
54-1043 . if (A > B)
54-1044 . {
54-1045 . A = B + C;
54-1046 . D = E + F;
54-1047 . }
54-1048 .
54-1049 . A = B/C;
54-1050 .
54-1051 . if (A != B)
54-1052 . {
54-1053 . A = B + C;
54-1054 . D = E + F;
54-1055 . }
54-1056 .
54-1057 .
54-1058 . switch (stp stuff)
54-1059 . {
54-1060 . case one:
54-1061 . {
54-1062 . run_this;
54-1063 . break;
54-1064 . }
54-1065 . case two:
54-1066 . {
54-1067 . run_this;
54-1068 . break;
54-1069 . }
54-1070 . // missing default
54-1071 . }
54-1072 .
54-1073 . A = B-C;
54-1074 . A = B-C;
54-1075 . A = B+C;
54-1076 . A = B/C;
54-1077 . A = B+C;
54-1078 . A = B*C;
54-1079 .
54-1080 . switch (stp stuff)
54-1081 . {
54-1082 . case one:
54-1083 . {
54-1084 . run_this;
54-1085 . break;
54-1086 . }
54-1087 . case two:
54-1088 . {
54-1089 . run_this;
54-1090 . break;
54-1091 . }
54-1092 . default:
54-1093 . {
54-1094 . SwError;
54-1095 . }
54-1096 . }
54-1097 .
54-1098 . A = B/C;
54-1099 . A = B/C;
54-1100 . A = B+C;
54-1101 . A = B*C;
54-1102 . A = B+C;
54-1103 . A = B/C;
54-1104 .
54-1105 . if (A lt B)
54-1106 . {
54-1107 . A = B + C;
54-1108 . D = E + F;
54-1109 . }
54-1110 .
54-1111 .
54-1112 . if (A ge B)
54-1113 . {
54-1114 . A = B + C;
54-1115 . D = E + F;
54-1116 . }
54-1117 .
54-1118 . A = B+C;
54-1119 . A = B*C;
54-1120 .
54-1121 . if (A < B)
54-1122 . {
54-1123 . A = B + C;
54-1124 . D = E + F;
54-1125 . }
54-1126 .
54-1127 . A = B*C;
54-1128 . A = B+C;
54-1129 . A = B-C;
54-1130 .
54-1131 . if (A == B)
54-1132 . {
54-1133 . A = B + C;
54-1134 . D = E + F;
54-1135 . }
54-1136 .
54-1137 . A = B*C;
54-1138 . A = B-C;
54-1139 . A = B+C;
54-1140 . A = B/C;
54-1141 . A = B+C;
54-1142 . A = B-C;
54-1143 .
54-1144 . if (A le B)
54-1145 . {
54-1146 . A = B + C;
54-1147 . D = E + F;
54-1148 . }
54-1149 .
54-1150 . A = B-C;
54-1151 . A = B-C;
54-1152 . A = B-C;
54-1153 . A = B-C;
54-1154 .
54-1155 . if (A < = B)
54-1156 . {
54-1157 . A = B + C;
54-1158 . D = E + F;
54-1159 . }
54-1160 .
54-1161 . A = B/C;
54-1162 . // max LOC 75
54-1163 .
54-1164 . }
54-1165 .
54-1166 .
54-1167 . /*
54-1168 . -----------------------------------------------------------------------------
54-1169 . --| NAME: stp.2.8
54-1170 . --|
54-1171 . --| ABSTRACT:
54-1172 . --| This function does stp stuff.
54-1173 . --|
54-1174 . --| RETURNS:
54-1175 . --| NONE.
54-1176 . --|
54-1177 . ----------------------------------------------------------------------------
54-1178 . */
54-1179 . static void stp.2.8(void)
54-1180 . {
54-1181 . /* LE SV TOC-2851 this is a stp-02.8.1 req to enable*/
54-1182 . A = B*C;
54-1183 . A = B*C;
54-1184 . A = B*C;
54-1185 . A = B*C;
54-1186 . // TBS - I need to figure this out
54-1187 .
54-1188 . if (A ge B)
54-1189 . {
54-1190 . A = B + C;
54-1191 . D = E + F;
54-1192 . }
54-1193 .
54-1194 . A = B/C;
54-1195 . /* LE SV TOC-2852 this is a stp-02.8.7 req to enable*/
54-1196 .
54-1197 . if (A > B)
54-1198 . {
54-1199 . A = B + C;
54-1200 . D = E + F;
54-1201 . }
54-1202 .
54-1203 .
54-1204 . if (A < B)
54-1205 . {
54-1206 . A = B + C;
54-1207 . D = E + F;
54-1208 . }
54-1209 .
54-1210 . A = B/C;
54-1211 .
54-1212 . switch (stp stuff)
54-1213 . {
54-1214 . case one:
54-1215 . {
54-1216 . run_this;
54-1217 . break;
54-1218 . }
54-1219 . case two:
54-1220 . {
54-1221 . run_this;
54-1222 . break;
54-1223 . }
54-1224 . default:
54-1225 . {
54-1226 . SwError;
54-1227 . }
54-1228 . }
54-1229 .
54-1230 .
54-1231 . if (A gt B)
54-1232 . {
54-1233 . A = B + C;
54-1234 . D = E + F;
54-1235 . }
54-1236 .
54-1237 . A = B-C;
54-1238 . A = B*C;
54-1239 . A = B+C;
54-1240 . A = B/C;
54-1241 . A = B/C;
54-1242 . A = B*C;
54-1243 . A = B/C;
54-1244 . A = B/C;
54-1245 . A = B*C;
54-1246 . A = B/C;
54-1247 . /* LE SV TOC-2853 this is a stp-02.8.22 req to compare*/
54-1248 . A = B*C;
54-1249 .
54-1250 . switch (stp stuff)
54-1251 . {
54-1252 . case one:
54-1253 . {
54-1254 . run_this;
54-1255 . break;
54-1256 . }
54-1257 . case two:
54-1258 . {
54-1259 . run_this;
54-1260 . break;
54-1261 . }
54-1262 . default:
54-1263 . {
54-1264 . SwError;
54-1265 . }
54-1266 . }
54-1267 .
54-1268 .
54-1269 . if (A == B)
54-1270 . {
54-1271 . A = B + C;
54-1272 . D = E + F;
54-1273 . }
54-1274 .
54-1275 .
54-1276 . if (A gt B)
54-1277 . {
54-1278 . A = B + C;
54-1279 . D = E + F;
54-1280 . }
54-1281 .
54-1282 . A = B+C;
54-1283 . A = B/C;
54-1284 . A = B-C;
54-1285 . A = B/C;
54-1286 .
54-1287 . if (A > B)
54-1288 . {
54-1289 . A = B + C;
54-1290 . D = E + F;
54-1291 . }
54-1292 .
54-1293 . A = B+C;
54-1294 . A = B*C;
54-1295 .
54-1296 . switch (stp stuff)
54-1297 . {
54-1298 . case one:
54-1299 . {
54-1300 . run_this;
54-1301 . break;
54-1302 . }
54-1303 . case two:
54-1304 . {
54-1305 . run_this;
54-1306 . break;
54-1307 . }
54-1308 . default:
54-1309 . {
54-1310 . SwError;
54-1311 . }
54-1312 . }
54-1313 .
54-1314 .
54-1315 . if (A ne B)
54-1316 . {
54-1317 . A = B + C;
54-1318 . D = E + F;
54-1319 . }
54-1320 .
54-1321 . A = 0x0003;
54-1322 .
54-1323 . if (A eq B)
54-1324 . {
54-1325 . A = B + C;
54-1326 . D = E + F;
54-1327 . }
54-1328 .
54-1329 . A = B-C;
54-1330 . A = B+C;
54-1331 . // max LOC 37
54-1332 .
54-1333 . }
54-1334 .
54-1335 .
54-1336 . /*
54-1337 . -----------------------------------------------------------------------------
54-1338 . --| NAME: stp.2.9
54-1339 . --|
54-1340 . --| ABSTRACT:
54-1341 . --| This function does stp stuff.
54-1342 . --|
54-1343 . --| RETURNS:
54-1344 . --| NONE.
54-1345 . --|
54-1346 . ----------------------------------------------------------------------------
54-1347 . */
54-1348 . static void stp.2.9(void)
54-1349 . {
54-1350 . A = B+C;
54-1351 . A = B*C;
54-1352 . A = B+C;
54-1353 . A = B/C;
54-1354 .
54-1355 . if (A ne B)
54-1356 . {
54-1357 . A = B + C;
54-1358 . D = E + F;
54-1359 . }
54-1360 .
54-1361 . A = B+C;
54-1362 .
54-1363 . if (A > B)
54-1364 . {
54-1365 . A = B + C;
54-1366 . D = E + F;
54-1367 . }
54-1368 .
54-1369 . A = B*C;
54-1370 .
54-1371 . if (A lt B)
54-1372 . {
54-1373 . A = B + C;
54-1374 . D = E + F;
54-1375 . }
54-1376 .
54-1377 . A = B/C;
54-1378 . A = B*C;
54-1379 . A = B-C;
54-1380 . A = B-C;
54-1381 . A = 0x0004;
54-1382 .
54-1383 . if (A != B)
54-1384 . {
54-1385 . A = B + C;
54-1386 . D = E + F;
54-1387 . }
54-1388 .
54-1389 . A = B-C;
54-1390 . A = B/C;
54-1391 . A = B-C;
54-1392 . A = B*C;
54-1393 . A = B/C;
54-1394 .
54-1395 . if (A == B)
54-1396 . {
54-1397 . A = B + C;
54-1398 . D = E + F;
54-1399 . }
54-1400 .
54-1401 . A = B+C;
54-1402 . A = B+C;
54-1403 . goto error;
54-1404 . A = B*C;
54-1405 . A = B-C;
54-1406 . A = 0x0007;
54-1407 .
54-1408 . if (A gt B)
54-1409 . {
54-1410 . A = B + C;
54-1411 . D = E + F;
54-1412 . }
54-1413 .
54-1414 .
54-1415 . if (A ge B)
54-1416 . {
54-1417 . A = B + C;
54-1418 . D = E + F;
54-1419 . }
54-1420 .
54-1421 . A = B-C;
54-1422 .
54-1423 . if (A ge B)
54-1424 . {
54-1425 . A = B + C;
54-1426 . D = E + F;
54-1427 . }
54-1428 .
54-1429 .
54-1430 . if (A ne B)
54-1431 . {
54-1432 . A = B + C;
54-1433 . D = E + F;
54-1434 . }
54-1435 .
54-1436 .
54-1437 . if (A eq B)
54-1438 . {
54-1439 . A = B + C;
54-1440 . D = E + F;
54-1441 . }
54-1442 .
54-1443 .
54-1444 . if (A > = B)
54-1445 . {
54-1446 . A = B + C;
54-1447 . D = E + F;
54-1448 . }
54-1449 .
54-1450 . A = B/C;
54-1451 . A = B*C;
54-1452 . A = B/C;
54-1453 . /* LE SV TOC-2854 this is a stp-02.9.35 req to halt*/
54-1454 .
54-1455 . if (A ge B)
54-1456 . {
54-1457 . A = B + C;
54-1458 . D = E + F;
54-1459 . }
54-1460 .
54-1461 . A = B-C;
54-1462 .
54-1463 . if (A le B)
54-1464 . {
54-1465 . A = B + C;
54-1466 . D = E + F;
54-1467 . }
54-1468 .
54-1469 . /* LE SV TOC-2855 this is a stp-02.9.38 req to enable*/
54-1470 . A = B-C;
54-1471 . A = B-C;
54-1472 . A = 0x0003;
54-1473 . A = B+C;
54-1474 . // max LOC 40
54-1475 .
54-1476 . }
54-1477 .
54-1478 .
54-1479 . /*
54-1480 . -----------------------------------------------------------------------------
54-1481 . --| NAME: stp.2.10
54-1482 . --|
54-1483 . --| ABSTRACT:
54-1484 . --| This function does stp stuff.
54-1485 . --|
54-1486 . --| RETURNS:
54-1487 . --| NONE.
54-1488 . --|
54-1489 . ----------------------------------------------------------------------------
54-1490 . */
54-1491 . static void stp.2.10(void)
54-1492 . {
54-1493 .
54-1494 . if (A < = B)
54-1495 . {
54-1496 . A = B + C;
54-1497 . D = E + F;
54-1498 . }
54-1499 .
54-1500 . A = B*C;
54-1501 .
54-1502 . if (A ge B)
54-1503 . {
54-1504 . A = B + C;
54-1505 . D = E + F;
54-1506 . }
54-1507 .
54-1508 .
54-1509 . switch (stp stuff)
54-1510 . {
54-1511 . case one:
54-1512 . {
54-1513 . run_this;
54-1514 . // missing break
54-1515 . }
54-1516 . case two:
54-1517 . {
54-1518 . run_this;
54-1519 . break;
54-1520 . }
54-1521 . default:
54-1522 . {
54-1523 . SwError;
54-1524 . }
54-1525 . }
54-1526 .
54-1527 .
54-1528 . if (A le B)
54-1529 . {
54-1530 . A = B + C;
54-1531 . D = E + F;
54-1532 . }
54-1533 .
54-1534 . A = B/C;
54-1535 . A = B*C;
54-1536 . A = B/C;
54-1537 . A = B-C;
54-1538 . A = B/C;
54-1539 . A = B+C;
54-1540 . A = B+C;
54-1541 . A = B-C;
54-1542 .
54-1543 . switch (stp stuff)
54-1544 . {
54-1545 . case one:
54-1546 . {
54-1547 . run_this;
54-1548 . break;
54-1549 . }
54-1550 . case two:
54-1551 . {
54-1552 . run_this;
54-1553 . break;
54-1554 . }
54-1555 . default:
54-1556 . {
54-1557 . SwError;
54-1558 . }
54-1559 . }
54-1560 .
54-1561 . A = B*C;
54-1562 . A = B-C;
54-1563 .
54-1564 . if (A != B)
54-1565 . {
54-1566 . A = B + C;
54-1567 . D = E + F;
54-1568 . }
54-1569 .
54-1570 . A = B+C;
54-1571 . A = B-C;
54-1572 . A = B*C;
54-1573 . A = B-C;
54-1574 . A = B-C;
54-1575 .
54-1576 . if (A < B)
54-1577 . {
54-1578 . A = B + C;
54-1579 . D = E + F;
54-1580 . }
54-1581 .
54-1582 . A = B/C;
54-1583 . A = B-C;
54-1584 .
54-1585 . if (A < B)
54-1586 . {
54-1587 . A = B + C;
54-1588 . D = E + F;
54-1589 . }
54-1590 .
54-1591 . A = B-C;
54-1592 . A = B+C;
54-1593 . // max LOC 27
54-1594 .
54-1595 . }
54-1596 .
54-1597 .
54-1598 . /*
54-1599 . -----------------------------------------------------------------------------
54-1600 . --| NAME: stp.2.11
54-1601 . --|
54-1602 . --| ABSTRACT:
54-1603 . --| This function does stp stuff.
54-1604 . --|
54-1605 . --| RETURNS:
54-1606 . --| NONE.
54-1607 . --|
54-1608 . ----------------------------------------------------------------------------
54-1609 . */
54-1610 . static void stp.2.11(void)
54-1611 . {
54-1612 .
54-1613 . if (A lt B)
54-1614 . {
54-1615 . A = B + C;
54-1616 . D = E + F;
54-1617 . }
54-1618 .
54-1619 . A = B*C;
54-1620 . A = B/C;
54-1621 . A = B*C;
54-1622 . /* dead_code = A * B; */
54-1623 . A = B*C;
54-1624 . /* dead_code = A * B; */
54-1625 . A = B*C;
54-1626 . A = B+C;
54-1627 . A = B-C;
54-1628 . A = B-C;
54-1629 . A = B-C;
54-1630 . /* LE SV TOC-2856 this is a stp-02.11.11 req to store*/
54-1631 . A = B-C;
54-1632 . A = B/C;
54-1633 .
54-1634 . if (A == B)
54-1635 . {
54-1636 . A = B + C;
54-1637 . D = E + F;
54-1638 . }
54-1639 .
54-1640 . A = B-C;
54-1641 .
54-1642 . if (A le B)
54-1643 . {
54-1644 . A = B + C;
54-1645 . D = E + F;
54-1646 . }
54-1647 .
54-1648 .
54-1649 . if (A == B)
54-1650 . {
54-1651 . A = B + C;
54-1652 . D = E + F;
54-1653 . }
54-1654 .
54-1655 . A = B*C;
54-1656 . A = B/C;
54-1657 .
54-1658 . if (A > = B)
54-1659 . {
54-1660 . A = B + C;
54-1661 . D = E + F;
54-1662 . }
54-1663 .
54-1664 . A = B+C;
54-1665 . A = B+C;
54-1666 . A = B/C;
54-1667 . A = B-C;
54-1668 .
54-1669 . /*
54-1670 . dead_block = C * D;
54-1671 . dead_block = E * F;
54-1672 . */
54-1673 .
54-1674 . A = B+C;
54-1675 . A = B-C;
54-1676 . A = B/C;
54-1677 .
54-1678 . if (A eq B)
54-1679 . {
54-1680 . A = B + C;
54-1681 . D = E + F;
54-1682 . }
54-1683 .
54-1684 .
54-1685 . if (A lt B)
54-1686 . {
54-1687 . A = B + C;
54-1688 . D = E + F;
54-1689 . }
54-1690 .
54-1691 . A = B-C;
54-1692 .
54-1693 . if (A > = B)
54-1694 . {
54-1695 . A = B + C;
54-1696 . D = E + F;
54-1697 . }
54-1698 .
54-1699 .
54-1700 . if (A < = B)
54-1701 . {
54-1702 . A = B + C;
54-1703 . D = E + F;
54-1704 . }
54-1705 .
54-1706 . A = B-C;
54-1707 . A = B-C;
54-1708 .
54-1709 . if (A > B)
54-1710 . {
54-1711 . A = B + C;
54-1712 . D = E + F;
54-1713 . }
54-1714 .
54-1715 .
54-1716 . if (A < = B)
54-1717 . {
54-1718 . A = B + C;
54-1719 . D = E + F;
54-1720 . }
54-1721 .
54-1722 . A = B/C;
54-1723 . /* LE SV TOC-2857 this is a stp-02.11.37 req to update*/
54-1724 . A = B-C;
54-1725 . A = B-C;
54-1726 . A = B*C;
54-1727 . A = B*C;
54-1728 . A = B-C;
54-1729 . // max LOC 41
54-1730 .
54-1731 . }
54-1732 .
54-1733 .
54-1734 . /*
54-1735 . -----------------------------------------------------------------------------
54-1736 . --| NAME: stp.2.12
54-1737 . --|
54-1738 . --| ABSTRACT:
54-1739 . --| This function does stp stuff.
54-1740 . --|
54-1741 . --| RETURNS:
54-1742 . --| NONE.
54-1743 . --|
54-1744 . ----------------------------------------------------------------------------
54-1745 . */
54-1746 . static void stp.2.12(void)
54-1747 . {
54-1748 . A = B+C;
54-1749 . A = B+C;
54-1750 . A = B+C;
54-1751 .
54-1752 . if (A < B)
54-1753 . {
54-1754 . A = B + C;
54-1755 . D = E + F;
54-1756 . }
54-1757 .
54-1758 .
54-1759 . if (A gt B)
54-1760 . {
54-1761 . A = B + C;
54-1762 . D = E + F;
54-1763 . }
54-1764 .
54-1765 . A = B-C;
54-1766 . A = B*C;
54-1767 . A = B*C;
54-1768 .
54-1769 . if (A le B)
54-1770 . {
54-1771 . A = B + C;
54-1772 . D = E + F;
54-1773 . }
54-1774 .
54-1775 . A = B/C;
54-1776 . A = B+C;
54-1777 . goto error;
54-1778 . A = B/C;
54-1779 . A = B*C;
54-1780 .
54-1781 . if (A lt B)
54-1782 . {
54-1783 . A = B + C;
54-1784 . D = E + F;
54-1785 . }
54-1786 .
54-1787 . A = B/C;
54-1788 . A = B+C;
54-1789 . A = B+C;
54-1790 . A = B-C;
54-1791 . A = B-C;
54-1792 . /* LE SV TOC-2858 this is a stp-02.12.20 req to set Real Time Clock*/
54-1793 . A = B/C;
54-1794 . A = B-C;
54-1795 .
54-1796 . if (A < B)
54-1797 . {
54-1798 . A = B + C;
54-1799 . D = E + F;
54-1800 . }
54-1801 .
54-1802 .
54-1803 . if (A gt B)
54-1804 . {
54-1805 . A = B + C;
54-1806 . D = E + F;
54-1807 . }
54-1808 .
54-1809 . A = B-C;
54-1810 . A = B+C;
54-1811 . A = B-C;
54-1812 . A = B/C;
54-1813 .
54-1814 . if (A gt B)
54-1815 . {
54-1816 . A = B + C;
54-1817 . D = E + F;
54-1818 . }
54-1819 .
54-1820 . A = B/C;
54-1821 .
54-1822 . if (A ge B)
54-1823 . {
54-1824 . A = B + C;
54-1825 . D = E + F;
54-1826 . }
54-1827 .
54-1828 . A = B/C;
54-1829 . A = B/C;
54-1830 . A = B*C;
54-1831 . A = B-C;
54-1832 .
54-1833 . if (A < = B)
54-1834 . {
54-1835 . A = B + C;
54-1836 . D = E + F;
54-1837 . }
54-1838 .
54-1839 . A = B+C;
54-1840 .
54-1841 . if (A ge B)
54-1842 . {
54-1843 . A = B + C;
54-1844 . D = E + F;
54-1845 . }
54-1846 .
54-1847 . A = B-C;
54-1848 . /* LE SV TOC-2859 this is a stp-02.12.39 req to convert*/
54-1849 . A = B+C;
54-1850 . A = B+C;
54-1851 . A = B/C;
54-1852 . send_buffer = (U16 *) malloc(size+1);
54-1853 .
54-1854 . if (A < B)
54-1855 . {
54-1856 . A = B + C;
54-1857 . D = E + F;
54-1858 . }
54-1859 .
54-1860 . A = B-C;
54-1861 . A = B*C;
54-1862 . A = B+C;
54-1863 . A = B-C;
54-1864 .
54-1865 . switch (stp stuff)
54-1866 . {
54-1867 . case one:
54-1868 . {
54-1869 . run_this;
54-1870 . break;
54-1871 . }
54-1872 . case two:
54-1873 . {
54-1874 . run_this;
54-1875 . break;
54-1876 . }
54-1877 . default:
54-1878 . {
54-1879 . SwError;
54-1880 . }
54-1881 . }
54-1882 .
54-1883 .
54-1884 . /* dead_block = C * D;
54-1885 . dead_block = E * F; */
54-1886 .
54-1887 . A = B-C;
54-1888 .
54-1889 . if (A gt B)
54-1890 . {
54-1891 . A = B + C;
54-1892 . D = E + F;
54-1893 . }
54-1894 .
54-1895 . A = (float)B + C;
54-1896 . A = B-C;
54-1897 .
54-1898 . if (A ne B)
54-1899 . {
54-1900 . A = B + C;
54-1901 . D = E + F;
54-1902 . }
54-1903 .
54-1904 . A = B*C;
54-1905 .
54-1906 . if (A < B)
54-1907 . {
54-1908 . A = B + C;
54-1909 . D = E + F;
54-1910 . }
54-1911 .
54-1912 .
54-1913 . switch (stp stuff)
54-1914 . {
54-1915 . case one:
54-1916 . {
54-1917 . run_this;
54-1918 . break;
54-1919 . }
54-1920 . case two:
54-1921 . {
54-1922 . run_this;
54-1923 . break;
54-1924 . }
54-1925 . default:
54-1926 . {
54-1927 . SwError;
54-1928 . }
54-1929 . }
54-1930 .
54-1931 .
54-1932 . if (A < B)
54-1933 . {
54-1934 . A = B + C;
54-1935 . D = E + F;
54-1936 . }
54-1937 .
54-1938 . A = B/C;
54-1939 .
54-1940 . if (A lt B)
54-1941 . {
54-1942 . A = B + C;
54-1943 . D = E + F;
54-1944 . }
54-1945 .
54-1946 . // max LOC 57
54-1947 .
54-1948 . }
54-1949 .
54 54 Result: result/source/ft-app/ft-app-B1.1/stp/stp-02.c
55 55 Source: source/ft-app/ft-app-B1.1/stp/stp-03.c
55-0 . /*
55-1 . ----------------------------------------------------------------------------
55-2 . --| BEGIN PROLOGUE
55-3 . --|
55-4 . --| CLASSIFICATION: UNCLASSIFIED
55-5 . --|
55-6 . --| FILE NAME: stp-03.c
55-7 . --|
55-8 . --| ABSTRACT:
55-9 . --| This file contains the 9 functions that do file stp stuff.
55-10 . --|
55-11 . --| HISTORY:
55-12 . --| CCCQ_NAME:
55-13 . --| CCCQ_VER:
55-14 . --|
55-15 . --| END PROLOGUE
55-16 . ----------------------------------------------------------------------------
55-17 . */
55-18 .
55-19 . float B;
55-20 . #define C;
55-21 . char D;
55-22 . #include C;
55-23 . #define B;
55-24 . #define D;
55-25 . #define B;
55-26 . #include A;
55-27 . #include B;
55-28 .
55-29 .
55-30 .
55-31 . /*
55-32 . -----------------------------------------------------------------------------
55-33 . --| NAME: stp.3.1
55-34 . --|
55-35 . --| ABSTRACT:
55-36 . --| This function does stp stuff.
55-37 . --|
55-38 . --| RETURNS:
55-39 . --| NONE.
55-40 . --|
55-41 . ----------------------------------------------------------------------------
55-42 . */
55-43 . static void stp.3.1(void)
55-44 . {
55-45 .
55-46 . if (A ne B)
55-47 . {
55-48 . A = B + C;
55-49 . D = E + F;
55-50 . }
55-51 .
55-52 . A = B+C;
55-53 . A = B/C;
55-54 . A = B+C;
55-55 . A = B*C;
55-56 . A = B*C;
55-57 .
55-58 . if (A lt B)
55-59 . {
55-60 . A = B + C;
55-61 . D = E + F;
55-62 . }
55-63 .
55-64 . A = B/C;
55-65 . A = B*C;
55-66 . A = B+C;
55-67 .
55-68 . if ($stp stuff > $otherstp stuff)
55-69 . /* LE SV TOC-008 we really should log all error calls */
55-70 . {
55-71 . A = B + C;
55-72 . }
55-73 .
55-74 . A = B*C;
55-75 . A = B*C;
55-76 .
55-77 . if (A != B)
55-78 . {
55-79 . A = B + C;
55-80 . D = E + F;
55-81 . }
55-82 .
55-83 .
55-84 . if (A lt B)
55-85 . {
55-86 . A = B + C;
55-87 . D = E + F;
55-88 . }
55-89 .
55-90 . A = B-C;
55-91 . A = B/C;
55-92 .
55-93 . switch (stp stuff)
55-94 . {
55-95 . case one:
55-96 . {
55-97 . run_this;
55-98 . break;
55-99 . }
55-100 . case two:
55-101 . {
55-102 . run_this;
55-103 . break;
55-104 . }
55-105 . // missing default
55-106 . }
55-107 .
55-108 . A = B*C;
55-109 . /* LE SV TOC-2860 this is a stp-03.1.18 req to reject*/
55-110 . A = 0x0002;
55-111 . A = B+C;
55-112 . // TBD - what do I do now
55-113 .
55-114 . if (A == B)
55-115 . {
55-116 . A = B + C;
55-117 . D = E + F;
55-118 . }
55-119 .
55-120 .
55-121 . if (A > B)
55-122 . {
55-123 . A = B + C;
55-124 . D = E + F;
55-125 . }
55-126 .
55-127 .
55-128 . if (A < B)
55-129 . {
55-130 . A = B + C;
55-131 . D = E + F;
55-132 . }
55-133 .
55-134 . A = B-C;
55-135 . /* LE SV TOC-2861 this is a stp-03.1.23 req to fail*/
55-136 .
55-137 . switch (stp stuff)
55-138 . {
55-139 . case one:
55-140 . {
55-141 . run_this;
55-142 . break;
55-143 . }
55-144 . case two:
55-145 . {
55-146 . run_this;
55-147 . break;
55-148 . }
55-149 . default:
55-150 . {
55-151 . SwError;
55-152 . }
55-153 . }
55-154 .
55-155 .
55-156 . if (A eq B)
55-157 . {
55-158 . A = B + C;
55-159 . D = E + F;
55-160 . }
55-161 .
55-162 . A = B*C;
55-163 . A = B+C;
55-164 . A = B*C;
55-165 . A = B+C;
55-166 . A = B*C;
55-167 . /* LE SV TOC-2862 this is a stp-03.1.30 req to reject*/
55-168 .
55-169 . if (A == B)
55-170 . {
55-171 . A = B + C;
55-172 . D = E + F;
55-173 . }
55-174 .
55-175 . A = B-C;
55-176 .
55-177 . if (A < = B)
55-178 . {
55-179 . A = B + C;
55-180 . D = E + F;
55-181 . }
55-182 .
55-183 .
55-184 . if (A lt B)
55-185 . {
55-186 . A = B + C;
55-187 . D = E + F;
55-188 . }
55-189 .
55-190 .
55-191 . if (A == B)
55-192 . {
55-193 . A = B + C;
55-194 . D = E + F;
55-195 . }
55-196 .
55-197 . /* LE SV TOC-2863 this is a stp-03.1.35 req to inhibit*/
55-198 . A = B-C;
55-199 . A = B/C;
55-200 . A = B/C;
55-201 . rcv_buffer = (U16 *) alloc(size+1);
55-202 .
55-203 . if (A eq B)
55-204 . {
55-205 . A = B + C;
55-206 . D = E + F;
55-207 . }
55-208 .
55-209 . A = B*C;
55-210 . /* LE SV TOC-2864 this is a stp-03.1.40 req to process*/
55-211 . do forever;
55-212 . A = B*C;
55-213 . A = B*C;
55-214 . A = B+C;
55-215 .
55-216 . switch (stp stuff)
55-217 . {
55-218 . case one:
55-219 . {
55-220 . run_this;
55-221 . break;
55-222 . }
55-223 . case two:
55-224 . {
55-225 . run_this;
55-226 . break;
55-227 . }
55-228 . default:
55-229 . {
55-230 . SwError;
55-231 . }
55-232 . }
55-233 .
55-234 .
55-235 . if (A ne B)
55-236 . {
55-237 . A = B + C;
55-238 . D = E + F;
55-239 . }
55-240 .
55-241 . A = B+C;
55-242 . A = B+C;
55-243 . A = B-C;
55-244 .
55-245 . if (A < = B)
55-246 . {
55-247 . A = B + C;
55-248 . D = E + F;
55-249 . }
55-250 .
55-251 . A = B-C;
55-252 . A = B-C;
55-253 .
55-254 . if (A ge B)
55-255 . {
55-256 . A = B + C;
55-257 . D = E + F;
55-258 . }
55-259 .
55-260 . A = B/C;
55-261 .
55-262 . if (A le B)
55-263 . {
55-264 . A = B + C;
55-265 . D = E + F;
55-266 . }
55-267 .
55-268 . // max LOC 53
55-269 .
55-270 . }
55-271 .
55-272 .
55-273 . /*
55-274 . -----------------------------------------------------------------------------
55-275 . --| NAME: stp.3.2
55-276 . --|
55-277 . --| ABSTRACT:
55-278 . --| This function does stp stuff.
55-279 . --|
55-280 . --| RETURNS:
55-281 . --| NONE.
55-282 . --|
55-283 . ----------------------------------------------------------------------------
55-284 . */
55-285 . static void stp.3.2(void)
55-286 . {
55-287 . A = B+C;
55-288 . // max LOC 1
55-289 .
55-290 . }
55-291 .
55-292 .
55-293 . /*
55-294 . -----------------------------------------------------------------------------
55-295 . --| NAME: stp.3.3
55-296 . --|
55-297 . --| ABSTRACT:
55-298 . --| This function does stp stuff.
55-299 . --|
55-300 . --| RETURNS:
55-301 . --| NONE.
55-302 . --|
55-303 . ----------------------------------------------------------------------------
55-304 . */
55-305 . static void stp.3.3(void)
55-306 . {
55-307 . A = B+C;
55-308 .
55-309 . if (A > B)
55-310 . {
55-311 . A = B + C;
55-312 . D = E + F;
55-313 . }
55-314 .
55-315 . A = B+C;
55-316 .
55-317 . if (A gt B)
55-318 . {
55-319 . A = B + C;
55-320 . D = E + F;
55-321 . }
55-322 .
55-323 .
55-324 . if (A gt B)
55-325 . {
55-326 . A = B + C;
55-327 . D = E + F;
55-328 . }
55-329 .
55-330 . A = B/C;
55-331 .
55-332 . if (A le B)
55-333 . {
55-334 . A = B + C;
55-335 . D = E + F;
55-336 . }
55-337 .
55-338 . A = B-C;
55-339 .
55-340 . if (A le B)
55-341 . {
55-342 . A = B + C;
55-343 . D = E + F;
55-344 . }
55-345 .
55-346 . A = B/C;
55-347 . A = B/C;
55-348 . A = B*C;
55-349 . A = B*C;
55-350 .
55-351 . if (A < = B)
55-352 . {
55-353 . A = B + C;
55-354 . D = E + F;
55-355 . }
55-356 .
55-357 . A = B/C;
55-358 . A = B-C;
55-359 .
55-360 . /* dead_block = C * D;
55-361 . dead_block = E * F; */
55-362 .
55-363 .
55-364 . if (A lt B)
55-365 . {
55-366 . A = B + C;
55-367 . D = E + F;
55-368 . }
55-369 .
55-370 . /* LE SV TOC-2865 this is a stp-03.3.18 req to disable*/
55-371 .
55-372 . switch (stp stuff)
55-373 . {
55-374 . case one:
55-375 . {
55-376 . run_this;
55-377 . break;
55-378 . }
55-379 . case two:
55-380 . {
55-381 . run_this;
55-382 . break;
55-383 . }
55-384 . default:
55-385 . {
55-386 . // missing error call
55-387 . }
55-388 . }
55-389 .
55-390 . A = B+C;
55-391 . /* dead_code = A * B; */
55-392 .
55-393 . if (A < B)
55-394 . {
55-395 . A = B + C;
55-396 . D = E + F;
55-397 . }
55-398 .
55-399 . A = B/C;
55-400 . A = B*C;
55-401 . A = B+C;
55-402 . // max LOC 22
55-403 .
55-404 . }
55-405 .
55-406 .
55-407 . /*
55-408 . -----------------------------------------------------------------------------
55-409 . --| NAME: stp.3.4
55-410 . --|
55-411 . --| ABSTRACT:
55-412 . --| This function does stp stuff.
55-413 . --|
55-414 . --| RETURNS:
55-415 . --| NONE.
55-416 . --|
55-417 . ----------------------------------------------------------------------------
55-418 . */
55-419 . static void stp.3.4(void)
55-420 . {
55-421 .
55-422 . if (A le B)
55-423 . {
55-424 . A = B + C;
55-425 . D = E + F;
55-426 . }
55-427 .
55-428 .
55-429 . if (A > = B)
55-430 . {
55-431 . A = B + C;
55-432 . D = E + F;
55-433 . }
55-434 .
55-435 . A = B-C;
55-436 . A = B+C;
55-437 . A = B/C;
55-438 . A = B*C;
55-439 . A = B*C;
55-440 . A = B*C;
55-441 . A = (long)B + C;
55-442 .
55-443 . if (A != B)
55-444 . {
55-445 . A = B + C;
55-446 . D = E + F;
55-447 . }
55-448 .
55-449 . // max LOC 9
55-450 .
55-451 . }
55-452 .
55-453 .
55-454 . /*
55-455 . -----------------------------------------------------------------------------
55-456 . --| NAME: stp.3.5
55-457 . --|
55-458 . --| ABSTRACT:
55-459 . --| This function does stp stuff.
55-460 . --|
55-461 . --| RETURNS:
55-462 . --| NONE.
55-463 . --|
55-464 . ----------------------------------------------------------------------------
55-465 . */
55-466 . static void stp.3.5(void)
55-467 . {
55-468 . /* LE SV TOC-2866 this is a stp-03.5.1 req to audit*/
55-469 .
55-470 . if (A ge B)
55-471 . {
55-472 . A = B + C;
55-473 . D = E + F;
55-474 . }
55-475 .
55-476 . // ??? go see ws
55-477 . A = B-C;
55-478 . /* LE SV TOC-2867 this is a stp-03.5.3 req to set Real Time Clock*/
55-479 . A = B/C;
55-480 . A = B*C;
55-481 .
55-482 . if (A lt B)
55-483 . {
55-484 . A = B + C;
55-485 . D = E + F;
55-486 . }
55-487 .
55-488 .
55-489 . if (A gt B)
55-490 . {
55-491 . A = B + C;
55-492 . D = E + F;
55-493 . }
55-494 .
55-495 . A = B+C;
55-496 .
55-497 . if (A < = B)
55-498 . {
55-499 . A = B + C;
55-500 . D = E + F;
55-501 . }
55-502 .
55-503 . A = B/C;
55-504 . A = B*C;
55-505 . A = B+C;
55-506 .
55-507 . if (A gt B)
55-508 . {
55-509 . A = B + C;
55-510 . D = E + F;
55-511 . }
55-512 .
55-513 . /* LE SV TOC-2868 this is a stp-03.5.13 req to reject*/
55-514 . A = B+C;
55-515 . A = B/C;
55-516 . A = 0x0002;
55-517 . A = B-C;
55-518 . A = B-C;
55-519 .
55-520 . if (veg)
55-521 . // missing curly brace
55-522 . variable = orange;
55-523 .
55-524 . A = B/C;
55-525 . A = B+C;
55-526 . // ??? go see ws
55-527 . A = B-C;
55-528 . A = B*C;
55-529 .
55-530 . if (A ge B)
55-531 . {
55-532 . A = B + C;
55-533 . D = E + F;
55-534 . }
55-535 .
55-536 . A = 0x0004;
55-537 . A = B*C;
55-538 . A = B/C;
55-539 . A = B+C;
55-540 .
55-541 . if (A ge B)
55-542 . {
55-543 . A = B + C;
55-544 . D = E + F;
55-545 . }
55-546 .
55-547 . A = B*C;
55-548 . A = B*C;
55-549 . A = B+C;
55-550 . send_buffer = (U16 *) malloc(size+1);
55-551 . A = B+C;
55-552 . A = B-C;
55-553 . A = B*C;
55-554 .
55-555 . if (A lt B)
55-556 . {
55-557 . A = B + C;
55-558 . D = E + F;
55-559 . }
55-560 .
55-561 . A = B/C;
55-562 . A = B-C;
55-563 . A = B+C;
55-564 .
55-565 . if ($stp stuff > $otherstp stuff)
55-566 . /* LE SV TOC-008 we really should log all error calls */
55-567 . {
55-568 . A = B + C;
55-569 . }
55-570 .
55-571 .
55-572 . switch (stp stuff)
55-573 . {
55-574 . case one:
55-575 . {
55-576 . run_this;
55-577 . break;
55-578 . }
55-579 . case two:
55-580 . {
55-581 . run_this;
55-582 . break;
55-583 . }
55-584 . default:
55-585 . {
55-586 . SwError;
55-587 . }
55-588 . }
55-589 .
55-590 .
55-591 . if (A le B)
55-592 . {
55-593 . A = B + C;
55-594 . D = E + F;
55-595 . }
55-596 .
55-597 .
55-598 . if (A le B)
55-599 . {
55-600 . A = B + C;
55-601 . D = E + F;
55-602 . }
55-603 .
55-604 .
55-605 . if (A eq B)
55-606 . {
55-607 . A = B + C;
55-608 . D = E + F;
55-609 . }
55-610 .
55-611 . A = B-C;
55-612 . A = B-C;
55-613 . A = B+C;
55-614 . A = B+C;
55-615 .
55-616 . if (A > B)
55-617 . {
55-618 . A = B + C;
55-619 . D = E + F;
55-620 . }
55-621 .
55-622 . /* LE SV TOC-2869 this is a stp-03.5.45 req to set RTC*/
55-623 . A = B*C;
55-624 . A = B/C;
55-625 . A = B+C;
55-626 . A = B*C;
55-627 .
55-628 . if (A > B)
55-629 . {
55-630 . A = B + C;
55-631 . D = E + F;
55-632 . }
55-633 .
55-634 . A = B-C;
55-635 .
55-636 . if (A ge B)
55-637 . {
55-638 . A = B + C;
55-639 . D = E + F;
55-640 . }
55-641 .
55-642 . A = B-C;
55-643 .
55-644 . if (A ge B)
55-645 . {
55-646 . A = B + C;
55-647 . D = E + F;
55-648 . }
55-649 .
55-650 . /* LE SV TOC-2870 this is a stp-03.5.54 req to record*/
55-651 . A = B/C;
55-652 . A = B*C;
55-653 . A = B/C;
55-654 . A = B/C;
55-655 . A = B-C;
55-656 .
55-657 . if (A lt B)
55-658 . {
55-659 . A = B + C;
55-660 . D = E + F;
55-661 . }
55-662 .
55-663 .
55-664 . if (A < B)
55-665 . {
55-666 . A = B + C;
55-667 . D = E + F;
55-668 . }
55-669 .
55-670 . // max LOC 60
55-671 .
55-672 . }
55-673 .
55-674 .
55-675 . /*
55-676 . -----------------------------------------------------------------------------
55-677 . --| NAME: stp.3.6
55-678 . --|
55-679 . --| ABSTRACT:
55-680 . --| This function does stp stuff.
55-681 . --|
55-682 . --| RETURNS:
55-683 . --| NONE.
55-684 . --|
55-685 . ----------------------------------------------------------------------------
55-686 . */
55-687 . static void stp.3.6(void)
55-688 . {
55-689 . A = B-C;
55-690 .
55-691 . if (A ne B)
55-692 . {
55-693 . A = B + C;
55-694 . D = E + F;
55-695 . }
55-696 .
55-697 . /* LE SV TOC-2871 this is a stp-03.6.3 req to validate*/
55-698 .
55-699 . if (A < = B)
55-700 . {
55-701 . A = B + C;
55-702 . D = E + F;
55-703 . }
55-704 .
55-705 . // TBS - I need to figure this out
55-706 . A = B/C;
55-707 . A = B-C;
55-708 . /* LE SV TOC-2872 this is a stp-03.6.6 req to check pSOS*/
55-709 . A = B/C;
55-710 .
55-711 . if (A > = B)
55-712 . {
55-713 . A = B + C;
55-714 . D = E + F;
55-715 . }
55-716 .
55-717 . A = B+C;
55-718 . A = B-C;
55-719 .
55-720 . switch (stp stuff)
55-721 . {
55-722 . case one:
55-723 . {
55-724 . run_this;
55-725 . break;
55-726 . }
55-727 . case two:
55-728 . {
55-729 . run_this;
55-730 . break;
55-731 . }
55-732 . default:
55-733 . {
55-734 . SwError;
55-735 . }
55-736 . }
55-737 .
55-738 . A = B-C;
55-739 . A = B/C;
55-740 . A = 0x0008;
55-741 . A = B-C;
55-742 . A = B/C;
55-743 .
55-744 . if (A == B)
55-745 . {
55-746 . A = B + C;
55-747 . D = E + F;
55-748 . }
55-749 .
55-750 . A = B-C;
55-751 . A = B-C;
55-752 . A = B+C;
55-753 .
55-754 . if (A > B)
55-755 . {
55-756 . A = B + C;
55-757 . D = E + F;
55-758 . }
55-759 .
55-760 . A = B*C;
55-761 . A = B*C;
55-762 . A = B+C;
55-763 . A = B-C;
55-764 . A = B-C;
55-765 .
55-766 . switch (stp stuff)
55-767 . {
55-768 . case one:
55-769 . {
55-770 . run_this;
55-771 . break;
55-772 . }
55-773 . case two:
55-774 . {
55-775 . run_this;
55-776 . break;
55-777 . }
55-778 . default:
55-779 . {
55-780 . // missing error call
55-781 . }
55-782 . }
55-783 .
55-784 . A = B+C;
55-785 .
55-786 . if (A ge B)
55-787 . {
55-788 . A = B + C;
55-789 . D = E + F;
55-790 . }
55-791 .
55-792 . A = B-C;
55-793 . A = B+C;
55-794 . A = B*C;
55-795 .
55-796 . switch (stp stuff)
55-797 . {
55-798 . case one:
55-799 . {
55-800 . run_this;
55-801 . // missing break
55-802 . }
55-803 . case two:
55-804 . {
55-805 . run_this;
55-806 . break;
55-807 . }
55-808 . default:
55-809 . {
55-810 . SwError;
55-811 . }
55-812 . }
55-813 .
55-814 . A = B+C;
55-815 . // max LOC 30
55-816 .
55-817 . }
55-818 .
55-819 .
55-820 . /*
55-821 . -----------------------------------------------------------------------------
55-822 . --| NAME: stp.3.7
55-823 . --|
55-824 . --| ABSTRACT:
55-825 . --| This function does stp stuff.
55-826 . --|
55-827 . --| RETURNS:
55-828 . --| NONE.
55-829 . --|
55-830 . ----------------------------------------------------------------------------
55-831 . */
55-832 . static void stp.3.7(void)
55-833 . {
55-834 . A = B-C;
55-835 .
55-836 . if (A > = B)
55-837 . {
55-838 . A = B + C;
55-839 . D = E + F;
55-840 . }
55-841 .
55-842 .
55-843 . if (A le B)
55-844 . {
55-845 . A = B + C;
55-846 . D = E + F;
55-847 . }
55-848 .
55-849 . A = B*C;
55-850 . /* LE SV TOC-2873 this is a stp-03.7.5 req to process*/
55-851 . A = B+C;
55-852 .
55-853 . if (A > = B)
55-854 . {
55-855 . A = B + C;
55-856 . D = E + F;
55-857 . }
55-858 .
55-859 .
55-860 . if (A != B)
55-861 . {
55-862 . A = B + C;
55-863 . D = E + F;
55-864 . }
55-865 .
55-866 . A = B/C;
55-867 . A = B*C;
55-868 . A = B/C;
55-869 . A = 0x0001;
55-870 .
55-871 . if (A < B)
55-872 . {
55-873 . A = B + C;
55-874 . D = E + F;
55-875 . }
55-876 .
55-877 . A = B/C;
55-878 .
55-879 . if (A eq B)
55-880 . {
55-881 . A = B + C;
55-882 . D = E + F;
55-883 . }
55-884 .
55-885 . A = B*C;
55-886 .
55-887 . if (A > B)
55-888 . {
55-889 . A = B + C;
55-890 . D = E + F;
55-891 . }
55-892 .
55-893 . A = B-C;
55-894 . A = B*C;
55-895 . A = B*C;
55-896 . // max LOC 18
55-897 .
55-898 . }
55-899 .
55-900 .
55-901 . /*
55-902 . -----------------------------------------------------------------------------
55-903 . --| NAME: stp.3.8
55-904 . --|
55-905 . --| ABSTRACT:
55-906 . --| This function does stp stuff.
55-907 . --|
55-908 . --| RETURNS:
55-909 . --| NONE.
55-910 . --|
55-911 . ----------------------------------------------------------------------------
55-912 . */
55-913 . static void stp.3.8(void)
55-914 . {
55-915 . A = B*C;
55-916 . A = B-C;
55-917 . A = B/C;
55-918 . do forever;
55-919 .
55-920 . if (A == B)
55-921 . {
55-922 . A = B + C;
55-923 . D = E + F;
55-924 . }
55-925 .
55-926 .
55-927 . if (A > = B)
55-928 . {
55-929 . A = B + C;
55-930 . D = E + F;
55-931 . }
55-932 .
55-933 . /* LE SV TOC-2874 this is a stp-03.8.6 req to compare*/
55-934 . A = B+C;
55-935 .
55-936 . if (A != B)
55-937 . {
55-938 . A = B + C;
55-939 . D = E + F;
55-940 . }
55-941 .
55-942 . A = B-C;
55-943 .
55-944 . if (A < B)
55-945 . {
55-946 . A = B + C;
55-947 . D = E + F;
55-948 . }
55-949 .
55-950 . A = 0x0008;
55-951 . A = B/C;
55-952 . /* LE SV TOC-2875 this is a stp-03.8.11 req to call isr*/
55-953 .
55-954 . if (A < = B)
55-955 . {
55-956 . A = B + C;
55-957 . D = E + F;
55-958 . }
55-959 .
55-960 . A = B/C;
55-961 . A = B-C;
55-962 . A = B-C;
55-963 . A = B-C;
55-964 .
55-965 . if (A gt B)
55-966 . {
55-967 . A = B + C;
55-968 . D = E + F;
55-969 . }
55-970 .
55-971 . A = B+C;
55-972 . A = B-C;
55-973 . A = B/C;
55-974 . A = B-C;
55-975 .
55-976 . if (A gt B)
55-977 . {
55-978 . A = B + C;
55-979 . D = E + F;
55-980 . }
55-981 .
55-982 . /* LE SV TOC-2876 this is a stp-03.8.22 req to record*/
55-983 .
55-984 . if (A < = B)
55-985 . {
55-986 . A = B + C;
55-987 . D = E + F;
55-988 . }
55-989 .
55-990 .
55-991 . if (A gt B)
55-992 . {
55-993 . A = B + C;
55-994 . D = E + F;
55-995 . }
55-996 .
55-997 . A = B*C;
55-998 . /* LE SV TOC-2877 this is a stp-03.8.25 req to verify*/
55-999 . A = B-C;
55-1000 . A = B-C;
55-1001 . A = B-C;
55-1002 . A = B-C;
55-1003 . A = B-C;
55-1004 .
55-1005 . if (A lt B)
55-1006 . {
55-1007 . A = B + C;
55-1008 . D = E + F;
55-1009 . }
55-1010 .
55-1011 .
55-1012 . if (A > B)
55-1013 . {
55-1014 . A = B + C;
55-1015 . D = E + F;
55-1016 . }
55-1017 .
55-1018 . A = B*C;
55-1019 . A = B/C;
55-1020 . A = B/C;
55-1021 . /* LE SV TOC-2878 this is a stp-03.8.35 req to assign*/
55-1022 .
55-1023 . if (A le B)
55-1024 . {
55-1025 . A = B + C;
55-1026 . D = E + F;
55-1027 . }
55-1028 .
55-1029 . A = B*C;
55-1030 . A = B*C;
55-1031 .
55-1032 . if (A gt B)
55-1033 . {
55-1034 . A = B + C;
55-1035 . D = E + F;
55-1036 . }
55-1037 .
55-1038 . A = B-C;
55-1039 . A = B*C;
55-1040 . A = B/C;
55-1041 . A = B+C;
55-1042 . A = B*C;
55-1043 . A = B+C;
55-1044 . A = B/C;
55-1045 . A = B/C;
55-1046 . A = B/C;
55-1047 . A = B+C;
55-1048 . A = B+C;
55-1049 . A = B+C;
55-1050 . // TBD - what do I do now
55-1051 . A = B/C;
55-1052 . free(FreePtr);
55-1053 .
55-1054 . if (A < = B)
55-1055 . {
55-1056 . A = B + C;
55-1057 . D = E + F;
55-1058 . }
55-1059 .
55-1060 . // max LOC 52
55-1061 .
55-1062 . }
55-1063 .
55-1064 .
55-1065 . /*
55-1066 . -----------------------------------------------------------------------------
55-1067 . --| NAME: stp.3.9
55-1068 . --|
55-1069 . --| ABSTRACT:
55-1070 . --| This function does stp stuff.
55-1071 . --|
55-1072 . --| RETURNS:
55-1073 . --| NONE.
55-1074 . --|
55-1075 . ----------------------------------------------------------------------------
55-1076 . */
55-1077 . static void stp.3.9(void)
55-1078 . {
55-1079 . A = B-C;
55-1080 .
55-1081 . if (A lt B)
55-1082 . {
55-1083 . A = B + C;
55-1084 . D = E + F;
55-1085 . }
55-1086 .
55-1087 . A = B+C;
55-1088 .
55-1089 . if (A lt B)
55-1090 . {
55-1091 . A = B + C;
55-1092 . D = E + F;
55-1093 . }
55-1094 .
55-1095 .
55-1096 . if (A lt B)
55-1097 . {
55-1098 . A = B + C;
55-1099 . D = E + F;
55-1100 . }
55-1101 .
55-1102 . A = B*C;
55-1103 .
55-1104 . if (A < B)
55-1105 . {
55-1106 . A = B + C;
55-1107 . D = E + F;
55-1108 . }
55-1109 .
55-1110 . A = B+C;
55-1111 . A = B+C;
55-1112 . /* LE SV TOC-2879 this is a stp-03.9.10 req to call isr*/
55-1113 .
55-1114 . if (A != B)
55-1115 . {
55-1116 . A = B + C;
55-1117 . D = E + F;
55-1118 . }
55-1119 .
55-1120 . A = B+C;
55-1121 .
55-1122 . if (A < = B)
55-1123 . {
55-1124 . A = B + C;
55-1125 . D = E + F;
55-1126 . }
55-1127 .
55-1128 .
55-1129 . if (A != B)
55-1130 . {
55-1131 . A = B + C;
55-1132 . D = E + F;
55-1133 . }
55-1134 .
55-1135 . A = B/C;
55-1136 . /* LE SV TOC-2880 this is a stp-03.9.15 req to increment*/
55-1137 .
55-1138 . if (A ge B)
55-1139 . {
55-1140 . A = B + C;
55-1141 . D = E + F;
55-1142 . }
55-1143 .
55-1144 .
55-1145 . /* dead_block = C * D;
55-1146 . dead_block = E * F; */
55-1147 .
55-1148 . A = B*C;
55-1149 . A = B/C;
55-1150 . /* LE SV TOC-2881 this is a stp-03.9.18 req to reject*/
55-1151 . A = B/C;
55-1152 .
55-1153 . switch (stp stuff)
55-1154 . {
55-1155 . case one:
55-1156 . {
55-1157 . run_this;
55-1158 . break;
55-1159 . }
55-1160 . case two:
55-1161 . {
55-1162 . run_this;
55-1163 . break;
55-1164 . }
55-1165 . default:
55-1166 . {
55-1167 . SwError;
55-1168 . }
55-1169 . }
55-1170 .
55-1171 . A = B*C;
55-1172 . // max LOC 20
55-1173 .
55-1174 . }
55-1175 .
55 55 Result: result/source/ft-app/ft-app-B1.1/stp/stp-03.c
56 56 Source: source/ft-app/ft-app-B1.1/stp/stp-04.c
56-0 . /*
56-1 . ----------------------------------------------------------------------------
56-2 . --| BEGIN PROLOGUE
56-3 . --|
56-4 . --| CLASSIFICATION: UNCLASSIFIED
56-5 . --|
56-6 . --| FILE NAME: stp-04.c
56-7 . --|
56-8 . --| ABSTRACT:
56-9 . --| This file contains the 7 functions that do file stp stuff.
56-10 . --|
56-11 . --| HISTORY:
56-12 . --| CCCQ_NAME:
56-13 . --| CCCQ_VER:
56-14 . --|
56-15 . --| END PROLOGUE
56-16 . ----------------------------------------------------------------------------
56-17 . */
56-18 .
56-19 . #define B;
56-20 . #include C;
56-21 . #define B;
56-22 . #include D;
56-23 . #include D;
56-24 . #define A;
56-25 .
56-26 .
56-27 .
56-28 . /*
56-29 . -----------------------------------------------------------------------------
56-30 . --| NAME: stp.4.1
56-31 . --|
56-32 . --| ABSTRACT:
56-33 . --| This function does stp stuff.
56-34 . --|
56-35 . --| RETURNS:
56-36 . --| NONE.
56-37 . --|
56-38 . ----------------------------------------------------------------------------
56-39 . */
56-40 . static void stp.4.1(void)
56-41 . {
56-42 . A = B+C;
56-43 . A = B/C;
56-44 . A = B+C;
56-45 . A = B*C;
56-46 . A = B-C;
56-47 . A = B/C;
56-48 . A = B/C;
56-49 .
56-50 . if (A == B)
56-51 . {
56-52 . A = B + C;
56-53 . D = E + F;
56-54 . }
56-55 .
56-56 .
56-57 . if (A < = B)
56-58 . {
56-59 . A = B + C;
56-60 . D = E + F;
56-61 . }
56-62 .
56-63 .
56-64 . if (A > B)
56-65 . {
56-66 . A = B + C;
56-67 . D = E + F;
56-68 . }
56-69 .
56-70 . A = B/C;
56-71 . A = B*C;
56-72 . A = B-C;
56-73 . A = B-C;
56-74 . A = 0x0003;
56-75 .
56-76 . if (A ne B)
56-77 . {
56-78 . A = B + C;
56-79 . D = E + F;
56-80 . }
56-81 .
56-82 . A = B+C;
56-83 .
56-84 . switch (stp stuff)
56-85 . {
56-86 . case one:
56-87 . {
56-88 . run_this;
56-89 . break;
56-90 . }
56-91 . case two:
56-92 . {
56-93 . run_this;
56-94 . break;
56-95 . }
56-96 . default:
56-97 . {
56-98 . SwError;
56-99 . }
56-100 . }
56-101 .
56-102 . A = B/C;
56-103 .
56-104 . if (A le B)
56-105 . {
56-106 . A = B + C;
56-107 . D = E + F;
56-108 . }
56-109 .
56-110 . A = (long)B + C;
56-111 . A = B-C;
56-112 .
56-113 . if (A le B)
56-114 . {
56-115 . A = B + C;
56-116 . D = E + F;
56-117 . }
56-118 .
56-119 .
56-120 . switch (stp stuff)
56-121 . {
56-122 . case one:
56-123 . {
56-124 . run_this;
56-125 . break;
56-126 . }
56-127 . case two:
56-128 . {
56-129 . run_this;
56-130 . break;
56-131 . }
56-132 . default:
56-133 . {
56-134 . SwError;
56-135 . }
56-136 . }
56-137 .
56-138 . A = B-C;
56-139 .
56-140 . if (A le B)
56-141 . {
56-142 . A = B + C;
56-143 . D = E + F;
56-144 . }
56-145 .
56-146 . A = B+C;
56-147 . A = B-C;
56-148 .
56-149 . if (A != B)
56-150 . {
56-151 . A = B + C;
56-152 . D = E + F;
56-153 . }
56-154 .
56-155 . // max LOC 27
56-156 .
56-157 . }
56-158 .
56-159 .
56-160 . /*
56-161 . -----------------------------------------------------------------------------
56-162 . --| NAME: stp.4.2
56-163 . --|
56-164 . --| ABSTRACT:
56-165 . --| This function does stp stuff.
56-166 . --|
56-167 . --| RETURNS:
56-168 . --| NONE.
56-169 . --|
56-170 . ----------------------------------------------------------------------------
56-171 . */
56-172 . static void stp.4.2(void)
56-173 . {
56-174 . A = B/C;
56-175 .
56-176 . if (A ne B)
56-177 . {
56-178 . A = B + C;
56-179 . D = E + F;
56-180 . }
56-181 .
56-182 . /* LE SV TOC-2882 this is a stp-04.2.3 req to set RTC*/
56-183 . A = B+C;
56-184 . A = B-C;
56-185 . A = B+C;
56-186 .
56-187 . if (A gt B)
56-188 . {
56-189 . A = B + C;
56-190 . D = E + F;
56-191 . }
56-192 .
56-193 .
56-194 . if (A < = B)
56-195 . {
56-196 . A = B + C;
56-197 . D = E + F;
56-198 . }
56-199 .
56-200 . A = B*C;
56-201 .
56-202 . if (A le B)
56-203 . {
56-204 . A = B + C;
56-205 . D = E + F;
56-206 . }
56-207 .
56-208 . A = B+C;
56-209 .
56-210 . if (A lt B)
56-211 . {
56-212 . A = B + C;
56-213 . D = E + F;
56-214 . }
56-215 .
56-216 . A = B*C;
56-217 . A = B-C;
56-218 . A = B/C;
56-219 . A = B-C;
56-220 . A = B*C;
56-221 . A = B+C;
56-222 . A = B-C;
56-223 .
56-224 . if (A lt B)
56-225 . {
56-226 . A = B + C;
56-227 . D = E + F;
56-228 . }
56-229 .
56-230 . A = B+C;
56-231 .
56-232 . if (A > = B)
56-233 . {
56-234 . A = B + C;
56-235 . D = E + F;
56-236 . }
56-237 .
56-238 . A = B-C;
56-239 .
56-240 . if (A lt B)
56-241 . {
56-242 . A = B + C;
56-243 . D = E + F;
56-244 . }
56-245 .
56-246 .
56-247 . if (A == B)
56-248 . {
56-249 . A = B + C;
56-250 . D = E + F;
56-251 . }
56-252 .
56-253 .
56-254 . if (A == B)
56-255 . {
56-256 . A = B + C;
56-257 . D = E + F;
56-258 . }
56-259 .
56-260 . A = B*C;
56-261 . A = B*C;
56-262 . A = B*C;
56-263 .
56-264 . if (A == B)
56-265 . {
56-266 . A = B + C;
56-267 . D = E + F;
56-268 . }
56-269 .
56-270 .
56-271 . if (A ne B)
56-272 . {
56-273 . A = B + C;
56-274 . D = E + F;
56-275 . }
56-276 .
56-277 . A = B+C;
56-278 . A = B*C;
56-279 . A = B/C;
56-280 .
56-281 . if (A ge B)
56-282 . {
56-283 . A = B + C;
56-284 . D = E + F;
56-285 . }
56-286 .
56-287 . A = B/C;
56-288 . A = B*C;
56-289 . A = B-C;
56-290 . A = B-C;
56-291 . A = B-C;
56-292 . A = B+C;
56-293 . A = B+C;
56-294 . A = B/C;
56-295 .
56-296 . switch (stp stuff)
56-297 . {
56-298 . case one:
56-299 . {
56-300 . run_this;
56-301 . break;
56-302 . }
56-303 . case two:
56-304 . {
56-305 . run_this;
56-306 . break;
56-307 . }
56-308 . default:
56-309 . {
56-310 . SwError;
56-311 . }
56-312 . }
56-313 .
56-314 . A = B/C;
56-315 . A = B-C;
56-316 . /* LE SV TOC-2883 this is a stp-04.2.46 req to compare*/
56-317 . A = B/C;
56-318 .
56-319 . switch (stp stuff)
56-320 . {
56-321 . case one:
56-322 . {
56-323 . run_this;
56-324 . break;
56-325 . }
56-326 . case two:
56-327 . {
56-328 . run_this;
56-329 . break;
56-330 . }
56-331 . default:
56-332 . {
56-333 . SwError;
56-334 . }
56-335 . }
56-336 .
56-337 . A = B/C;
56-338 . A = B+C;
56-339 . A = B*C;
56-340 . A = B-C;
56-341 .
56-342 . if (A > B)
56-343 . {
56-344 . A = B + C;
56-345 . D = E + F;
56-346 . }
56-347 .
56-348 . A = B+C;
56-349 . A = B-C;
56-350 . A = B-C;
56-351 . // max LOC 55
56-352 .
56-353 . }
56-354 .
56-355 .
56-356 . /*
56-357 . -----------------------------------------------------------------------------
56-358 . --| NAME: stp.4.3
56-359 . --|
56-360 . --| ABSTRACT:
56-361 . --| This function does stp stuff.
56-362 . --|
56-363 . --| RETURNS:
56-364 . --| NONE.
56-365 . --|
56-366 . ----------------------------------------------------------------------------
56-367 . */
56-368 . static void stp.4.3(void)
56-369 . {
56-370 . A = B+C;
56-371 . A = B+C;
56-372 .
56-373 . if (A ge B)
56-374 . {
56-375 . A = B + C;
56-376 . D = E + F;
56-377 . }
56-378 .
56-379 . A = B+C;
56-380 . A = B*C;
56-381 . A = B/C;
56-382 . A = B-C;
56-383 . A = 0x0007;
56-384 . A = B/C;
56-385 . // max LOC 8
56-386 .
56-387 . }
56-388 .
56-389 .
56-390 . /*
56-391 . -----------------------------------------------------------------------------
56-392 . --| NAME: stp.4.4
56-393 . --|
56-394 . --| ABSTRACT:
56-395 . --| This function does stp stuff.
56-396 . --|
56-397 . --| RETURNS:
56-398 . --| NONE.
56-399 . --|
56-400 . ----------------------------------------------------------------------------
56-401 . */
56-402 . static void stp.4.4(void)
56-403 . {
56-404 . /* LE SV TOC-2884 this is a stp-04.4.1 req to increment*/
56-405 .
56-406 . if (A eq B)
56-407 . {
56-408 . A = B + C;
56-409 . D = E + F;
56-410 . }
56-411 .
56-412 . A = B+C;
56-413 .
56-414 . if (A < B)
56-415 . {
56-416 . A = B + C;
56-417 . D = E + F;
56-418 . }
56-419 .
56-420 . A = B/C;
56-421 . A = 0x0007;
56-422 . A = B/C;
56-423 . /* LE SV TOC-2885 this is a stp-04.4.6 req to enable*/
56-424 .
56-425 . if (A gt B)
56-426 . {
56-427 . A = B + C;
56-428 . D = E + F;
56-429 . }
56-430 .
56-431 .
56-432 . if (A gt B)
56-433 . {
56-434 . A = B + C;
56-435 . D = E + F;
56-436 . }
56-437 .
56-438 . A = B-C;
56-439 .
56-440 . if (A != B)
56-441 . {
56-442 . A = B + C;
56-443 . D = E + F;
56-444 . }
56-445 .
56-446 . A = B-C;
56-447 .
56-448 . switch (stp stuff)
56-449 . {
56-450 . case one:
56-451 . {
56-452 . run_this;
56-453 . break;
56-454 . }
56-455 . case two:
56-456 . {
56-457 . run_this;
56-458 . break;
56-459 . }
56-460 . default:
56-461 . {
56-462 . SwError;
56-463 . }
56-464 . }
56-465 .
56-466 . A = B/C;
56-467 . A = B*C;
56-468 . A = B+C;
56-469 .
56-470 . if (A > B)
56-471 . {
56-472 . A = B + C;
56-473 . D = E + F;
56-474 . }
56-475 .
56-476 . A = B*C;
56-477 .
56-478 . if (A lt B)
56-479 . {
56-480 . A = B + C;
56-481 . D = E + F;
56-482 . }
56-483 .
56-484 . A = B+C;
56-485 . A = B/C;
56-486 .
56-487 . switch (stp stuff)
56-488 . {
56-489 . case one:
56-490 . {
56-491 . run_this;
56-492 . break;
56-493 . }
56-494 . case two:
56-495 . {
56-496 . run_this;
56-497 . break;
56-498 . }
56-499 . default:
56-500 . {
56-501 . SwError;
56-502 . }
56-503 . }
56-504 .
56-505 . A = B/C;
56-506 .
56-507 . if (A gt B)
56-508 . {
56-509 . A = B + C;
56-510 . D = E + F;
56-511 . }
56-512 .
56-513 . A = B+C;
56-514 . A = B/C;
56-515 .
56-516 . if (A > B)
56-517 . {
56-518 . A = B + C;
56-519 . D = E + F;
56-520 . }
56-521 .
56-522 . A = B*C;
56-523 . A = B/C;
56-524 . A = B/C;
56-525 .
56-526 . if (A le B)
56-527 . {
56-528 . A = B + C;
56-529 . D = E + F;
56-530 . }
56-531 .
56-532 . A = B*C;
56-533 . A = B+C;
56-534 . A = B*C;
56-535 .
56-536 . if (A != B)
56-537 . {
56-538 . A = B + C;
56-539 . D = E + F;
56-540 . }
56-541 .
56-542 . A = B+C;
56-543 . A = B+C;
56-544 . A = B/C;
56-545 . A = B-C;
56-546 . A = B+C;
56-547 .
56-548 . if (A gt B)
56-549 . {
56-550 . A = B + C;
56-551 . D = E + F;
56-552 . }
56-553 .
56-554 . A = B*C;
56-555 . A = B/C;
56-556 . A = B+C;
56-557 . A = 0x0002;
56-558 .
56-559 . switch (stp stuff)
56-560 . {
56-561 . case one:
56-562 . {
56-563 . run_this;
56-564 . break;
56-565 . }
56-566 . case two:
56-567 . {
56-568 . run_this;
56-569 . break;
56-570 . }
56-571 . default:
56-572 . {
56-573 . SwError;
56-574 . }
56-575 . }
56-576 .
56-577 .
56-578 . if (A le B)
56-579 . {
56-580 . A = B + C;
56-581 . D = E + F;
56-582 . }
56-583 .
56-584 .
56-585 . if (A lt B)
56-586 . {
56-587 . A = B + C;
56-588 . D = E + F;
56-589 . }
56-590 .
56-591 .
56-592 . if (A ge B)
56-593 . {
56-594 . A = B + C;
56-595 . D = E + F;
56-596 . }
56-597 .
56-598 . A = B*C;
56-599 . A = B*C;
56-600 . A = B*C;
56-601 . send_buffer = (U16 *) malloc(size+1);
56-602 . A = B/C;
56-603 . // max LOC 50
56-604 .
56-605 . }
56-606 .
56-607 .
56-608 . /*
56-609 . -----------------------------------------------------------------------------
56-610 . --| NAME: stp.4.5
56-611 . --|
56-612 . --| ABSTRACT:
56-613 . --| This function does stp stuff.
56-614 . --|
56-615 . --| RETURNS:
56-616 . --| NONE.
56-617 . --|
56-618 . ----------------------------------------------------------------------------
56-619 . */
56-620 . static void stp.4.5(void)
56-621 . {
56-622 . A = B*C;
56-623 . A = B*C;
56-624 . A = B*C;
56-625 . A = B/C;
56-626 .
56-627 . if (A eq B)
56-628 . {
56-629 . A = B + C;
56-630 . D = E + F;
56-631 . }
56-632 .
56-633 . A = B/C;
56-634 . A = B*C;
56-635 . A = B-C;
56-636 .
56-637 . switch (stp stuff)
56-638 . {
56-639 . case one:
56-640 . {
56-641 . run_this;
56-642 . break;
56-643 . }
56-644 . case two:
56-645 . {
56-646 . run_this;
56-647 . break;
56-648 . }
56-649 . default:
56-650 . {
56-651 . SwError;
56-652 . }
56-653 . }
56-654 .
56-655 .
56-656 . switch (stp stuff)
56-657 . {
56-658 . case one:
56-659 . {
56-660 . run_this;
56-661 . break;
56-662 . }
56-663 . case two:
56-664 . {
56-665 . run_this;
56-666 . break;
56-667 . }
56-668 . default:
56-669 . {
56-670 . SwError;
56-671 . }
56-672 . }
56-673 .
56-674 . A = B+C;
56-675 .
56-676 . if (A > B)
56-677 . {
56-678 . A = B + C;
56-679 . D = E + F;
56-680 . }
56-681 .
56-682 . A = B-C;
56-683 . A = B+C;
56-684 . A = B/C;
56-685 . A = B*C;
56-686 . A = B-C;
56-687 . A = B-C;
56-688 . A = B*C;
56-689 . A = B+C;
56-690 . A = B+C;
56-691 . A = B-C;
56-692 . /* LE SV TOC-2886 this is a stp-04.5.23 req to call admin*/
56-693 .
56-694 . if (A lt B)
56-695 . {
56-696 . A = B + C;
56-697 . D = E + F;
56-698 . }
56-699 .
56-700 . A = B/C;
56-701 . A = B/C;
56-702 . A = B+C;
56-703 .
56-704 . if (A le B)
56-705 . {
56-706 . A = B + C;
56-707 . D = E + F;
56-708 . }
56-709 .
56-710 . A = B-C;
56-711 . A = B+C;
56-712 . A = B-C;
56-713 . A = B+C;
56-714 . A = B*C;
56-715 . A = B-C;
56-716 . A = 0x0007;
56-717 . A = B*C;
56-718 .
56-719 . switch (stp stuff)
56-720 . {
56-721 . case one:
56-722 . {
56-723 . run_this;
56-724 . break;
56-725 . }
56-726 . case two:
56-727 . {
56-728 . run_this;
56-729 . break;
56-730 . }
56-731 . default:
56-732 . {
56-733 . SwError;
56-734 . }
56-735 . }
56-736 .
56-737 . A = B+C;
56-738 . A = B/C;
56-739 . A = B/C;
56-740 . A = B/C;
56-741 .
56-742 . if (A < B)
56-743 . {
56-744 . A = B + C;
56-745 . D = E + F;
56-746 . }
56-747 .
56-748 . A = B*C;
56-749 . A = 0x0007;
56-750 . A = B-C;
56-751 . A = B-C;
56-752 . A = B-C;
56-753 .
56-754 . if (A ne B)
56-755 . {
56-756 . A = B + C;
56-757 . D = E + F;
56-758 . }
56-759 .
56-760 . A = B+C;
56-761 . A = B+C;
56-762 . /* LE SV TOC-2887 this is a stp-04.5.48 req to detect error*/
56-763 . A = B+C;
56-764 . A = B*C;
56-765 .
56-766 . if (A < = B)
56-767 . {
56-768 . A = B + C;
56-769 . D = E + F;
56-770 . }
56-771 .
56-772 .
56-773 . if (A lt B)
56-774 . {
56-775 . A = B + C;
56-776 . D = E + F;
56-777 . }
56-778 .
56-779 .
56-780 . if (A == B)
56-781 . {
56-782 . A = B + C;
56-783 . D = E + F;
56-784 . }
56-785 .
56-786 . free(FreePtr);
56-787 .
56-788 . if (A == B)
56-789 . {
56-790 . A = B + C;
56-791 . D = E + F;
56-792 . }
56-793 .
56-794 . A = B+C;
56-795 . A = B*C;
56-796 . // max LOC 55
56-797 .
56-798 . }
56-799 .
56-800 .
56-801 . /*
56-802 . -----------------------------------------------------------------------------
56-803 . --| NAME: stp.4.6
56-804 . --|
56-805 . --| ABSTRACT:
56-806 . --| This function does stp stuff.
56-807 . --|
56-808 . --| RETURNS:
56-809 . --| NONE.
56-810 . --|
56-811 . ----------------------------------------------------------------------------
56-812 . */
56-813 . static void stp.4.6(void)
56-814 . {
56-815 .
56-816 . if (A != B)
56-817 . {
56-818 . A = B + C;
56-819 . D = E + F;
56-820 . }
56-821 .
56-822 . A = B+C;
56-823 . A = B*C;
56-824 . A = B/C;
56-825 . /* LE SV TOC-2888 this is a stp-04.6.5 req to verify*/
56-826 . A = B/C;
56-827 . A = B/C;
56-828 . A = B+C;
56-829 .
56-830 . switch (stp stuff)
56-831 . {
56-832 . case one:
56-833 . {
56-834 . run_this;
56-835 . break;
56-836 . }
56-837 . case two:
56-838 . {
56-839 . run_this;
56-840 . break;
56-841 . }
56-842 . default:
56-843 . {
56-844 . SwError;
56-845 . }
56-846 . }
56-847 .
56-848 . A = B+C;
56-849 .
56-850 . if (A le B)
56-851 . {
56-852 . A = B + C;
56-853 . D = E + F;
56-854 . }
56-855 .
56-856 .
56-857 . if (A gt B)
56-858 . {
56-859 . A = B + C;
56-860 . D = E + F;
56-861 . }
56-862 .
56-863 . A = B-C;
56-864 . A = B+C;
56-865 . A = B+C;
56-866 .
56-867 . if (A ge B)
56-868 . {
56-869 . A = B + C;
56-870 . D = E + F;
56-871 . }
56-872 .
56-873 . A = B-C;
56-874 .
56-875 . if (A lt B)
56-876 . {
56-877 . A = B + C;
56-878 . D = E + F;
56-879 . }
56-880 .
56-881 .
56-882 . if (A > = B)
56-883 . {
56-884 . A = B + C;
56-885 . D = E + F;
56-886 . }
56-887 .
56-888 . A = B+C;
56-889 . A = B*C;
56-890 .
56-891 . if (A < = B)
56-892 . {
56-893 . A = B + C;
56-894 . D = E + F;
56-895 . }
56-896 .
56-897 .
56-898 . if (A ge B)
56-899 . {
56-900 . A = B + C;
56-901 . D = E + F;
56-902 . }
56-903 .
56-904 . A = B*C;
56-905 .
56-906 . if (A lt B)
56-907 . {
56-908 . A = B + C;
56-909 . D = E + F;
56-910 . }
56-911 .
56-912 . A = B/C;
56-913 .
56-914 . switch (stp stuff)
56-915 . {
56-916 . case one:
56-917 . {
56-918 . run_this;
56-919 . break;
56-920 . }
56-921 . case two:
56-922 . {
56-923 . run_this;
56-924 . break;
56-925 . }
56-926 . default:
56-927 . {
56-928 . SwError;
56-929 . }
56-930 . }
56-931 .
56-932 . A = B+C;
56-933 . A = B-C;
56-934 . A = B-C;
56-935 .
56-936 . if (A < = B)
56-937 . {
56-938 . A = B + C;
56-939 . D = E + F;
56-940 . }
56-941 .
56-942 . A = B/C;
56-943 . A = B-C;
56-944 . A = B+C;
56-945 . A = B*C;
56-946 . A = B+C;
56-947 . A = B/C;
56-948 .
56-949 . if (A != B)
56-950 . {
56-951 . A = B + C;
56-952 . D = E + F;
56-953 . }
56-954 .
56-955 . // max LOC 37
56-956 .
56-957 . }
56-958 .
56-959 .
56-960 . /*
56-961 . -----------------------------------------------------------------------------
56-962 . --| NAME: stp.4.7
56-963 . --|
56-964 . --| ABSTRACT:
56-965 . --| This function does stp stuff.
56-966 . --|
56-967 . --| RETURNS:
56-968 . --| NONE.
56-969 . --|
56-970 . ----------------------------------------------------------------------------
56-971 . */
56-972 . static void stp.4.7(void)
56-973 . {
56-974 . A = 0x0003;
56-975 . A = B-C;
56-976 .
56-977 . if (A eq B)
56-978 . {
56-979 . A = B + C;
56-980 . D = E + F;
56-981 . }
56-982 .
56-983 .
56-984 . if (A != B)
56-985 . {
56-986 . A = B + C;
56-987 . D = E + F;
56-988 . }
56-989 .
56-990 .
56-991 . if (A > B)
56-992 . {
56-993 . A = B + C;
56-994 . D = E + F;
56-995 . }
56-996 .
56-997 .
56-998 . if (A gt B)
56-999 . {
56-1000 . A = B + C;
56-1001 . D = E + F;
56-1002 . }
56-1003 .
56-1004 . A = B*C;
56-1005 . // (P) this is really improtant
56-1006 . A = B-C;
56-1007 .
56-1008 . if (A lt B)
56-1009 . {
56-1010 . A = B + C;
56-1011 . D = E + F;
56-1012 . }
56-1013 .
56-1014 . A = B+C;
56-1015 . A = B*C;
56-1016 . A = B+C;
56-1017 . A = B-C;
56-1018 . A = B*C;
56-1019 . A = B*C;
56-1020 . A = B/C;
56-1021 .
56-1022 . if (A > = B)
56-1023 . {
56-1024 . A = B + C;
56-1025 . D = E + F;
56-1026 . }
56-1027 .
56-1028 . A = B*C;
56-1029 . A = B*C;
56-1030 . A = B+C;
56-1031 . // max LOC 19
56-1032 .
56-1033 . }
56-1034 .
56 56 Result: result/source/ft-app/ft-app-B1.1/stp/stp-04.c
57 57 Source: source/ft-app/ft-app-B1.1/stp/stp-05.c
57-0 . /*
57-1 . ----------------------------------------------------------------------------
57-2 . --| BEGIN PROLOGUE
57-3 . --|
57-4 . --| CLASSIFICATION: UNCLASSIFIED
57-5 . --|
57-6 . --| FILE NAME: stp-05.c
57-7 . --|
57-8 . --| ABSTRACT:
57-9 . --| This file contains the 14 functions that do file stp stuff.
57-10 . --|
57-11 . --| HISTORY:
57-12 . --| CCCQ_NAME:
57-13 . --| CCCQ_VER:
57-14 . --|
57-15 . --| END PROLOGUE
57-16 . ----------------------------------------------------------------------------
57-17 . */
57-18 .
57-19 . double C;
57-20 . #include B;
57-21 . double C;
57-22 . #include B;
57-23 . #include C;
57-24 .
57-25 .
57-26 .
57-27 . /*
57-28 . -----------------------------------------------------------------------------
57-29 . --| NAME: stp.5.1
57-30 . --|
57-31 . --| ABSTRACT:
57-32 . --| This function does stp stuff.
57-33 . --|
57-34 . --| RETURNS:
57-35 . --| NONE.
57-36 . --|
57-37 . ----------------------------------------------------------------------------
57-38 . */
57-39 . static void stp.5.1(void)
57-40 . {
57-41 . A = B-C;
57-42 . A = B-C;
57-43 . A = B+C;
57-44 . A = B/C;
57-45 . /* LE SV TOC-2889 this is a stp-05.1.5 req to call isr*/
57-46 . A = B*C;
57-47 . A = B+C;
57-48 . A = B-C;
57-49 . A = B/C;
57-50 .
57-51 . if ($stp stuff > $otherstp stuff)
57-52 . /* LE SV TOC-008 we really should log all error calls */
57-53 . {
57-54 . A = B + C;
57-55 . }
57-56 .
57-57 .
57-58 . if (A ge B)
57-59 . {
57-60 . A = B + C;
57-61 . D = E + F;
57-62 . }
57-63 .
57-64 .
57-65 . if (A le B)
57-66 . {
57-67 . A = B + C;
57-68 . D = E + F;
57-69 . }
57-70 .
57-71 . A = B*C;
57-72 . A = B/C;
57-73 .
57-74 . if (A > B)
57-75 . {
57-76 . A = B + C;
57-77 . D = E + F;
57-78 . }
57-79 .
57-80 . A = B-C;
57-81 . /* LE SV TOC-2890 this is a stp-05.1.15 req to check unix*/
57-82 . A = B*C;
57-83 .
57-84 . if (A eq B)
57-85 . {
57-86 . A = B + C;
57-87 . D = E + F;
57-88 . }
57-89 .
57-90 .
57-91 . if (A ne B)
57-92 . {
57-93 . A = B + C;
57-94 . D = E + F;
57-95 . }
57-96 .
57-97 . /* LE SV TOC-2891 this is a stp-05.1.18 req to call admin*/
57-98 . A = B+C;
57-99 . A = B-C;
57-100 . /* LE SV TOC-2892 this is a stp-05.1.20 req to set Real Time Clock*/
57-101 .
57-102 . if (A ne B)
57-103 . {
57-104 . A = B + C;
57-105 . D = E + F;
57-106 . }
57-107 .
57-108 . A = B*C;
57-109 . A = B-C;
57-110 . A = B-C;
57-111 . A = B/C;
57-112 . A = B*C;
57-113 . A = B*C;
57-114 .
57-115 . if (A le B)
57-116 . {
57-117 . A = B + C;
57-118 . D = E + F;
57-119 . }
57-120 .
57-121 . A = B/C;
57-122 . A = B+C;
57-123 . A = (long)B + C;
57-124 . A = B-C;
57-125 . A = B*C;
57-126 . A = B/C;
57-127 . A = B-C;
57-128 .
57-129 . if (A ne B)
57-130 . {
57-131 . A = B + C;
57-132 . D = E + F;
57-133 . }
57-134 .
57-135 . A = B+C;
57-136 . A = B+C;
57-137 . A = B/C;
57-138 . A = B/C;
57-139 . A = B-C;
57-140 . A = B/C;
57-141 . A = B/C;
57-142 . A = B-C;
57-143 . A = B+C;
57-144 . A = B*C;
57-145 . /* LE SV TOC-2893 this is a stp-05.1.45 req to check unix*/
57-146 . A = B/C;
57-147 .
57-148 . if (A ge B)
57-149 . {
57-150 . A = B + C;
57-151 . D = E + F;
57-152 . }
57-153 .
57-154 . A = B*C;
57-155 . A = B*C;
57-156 . A = B-C;
57-157 . // max LOC 49
57-158 .
57-159 . }
57-160 .
57-161 .
57-162 . /*
57-163 . -----------------------------------------------------------------------------
57-164 . --| NAME: stp.5.2
57-165 . --|
57-166 . --| ABSTRACT:
57-167 . --| This function does stp stuff.
57-168 . --|
57-169 . --| RETURNS:
57-170 . --| NONE.
57-171 . --|
57-172 . ----------------------------------------------------------------------------
57-173 . */
57-174 . static void stp.5.2(void)
57-175 . {
57-176 . A = B-C;
57-177 . A = B*C;
57-178 . /* LE SV TOC-2894 this is a stp-05.2.3 req to verify*/
57-179 . A = B/C;
57-180 . A = B/C;
57-181 .
57-182 . if (A ge B)
57-183 . {
57-184 . A = B + C;
57-185 . D = E + F;
57-186 . }
57-187 .
57-188 . A = B/C;
57-189 . A = B+C;
57-190 . A = B+C;
57-191 .
57-192 . if (A > = B)
57-193 . {
57-194 . A = B + C;
57-195 . D = E + F;
57-196 . }
57-197 .
57-198 . A = B*C;
57-199 . // (P) this is really improtant
57-200 .
57-201 . if (A > = B)
57-202 . {
57-203 . A = B + C;
57-204 . D = E + F;
57-205 . }
57-206 .
57-207 . A = B-C;
57-208 . A = B/C;
57-209 . A = B/C;
57-210 . A = B-C;
57-211 . A = B*C;
57-212 . A = B-C;
57-213 .
57-214 . if (A lt B)
57-215 . {
57-216 . A = B + C;
57-217 . D = E + F;
57-218 . }
57-219 .
57-220 .
57-221 . if (A le B)
57-222 . {
57-223 . A = B + C;
57-224 . D = E + F;
57-225 . }
57-226 .
57-227 . A = B*C;
57-228 . A = B*C;
57-229 . A = B*C;
57-230 . A = B/C;
57-231 .
57-232 . if (A != B)
57-233 . {
57-234 . A = B + C;
57-235 . D = E + F;
57-236 . }
57-237 .
57-238 . /* LE SV TOC-2895 this is a stp-05.2.25 req to update*/
57-239 . A = B+C;
57-240 .
57-241 . if (A ne B)
57-242 . {
57-243 . A = B + C;
57-244 . D = E + F;
57-245 . }
57-246 .
57-247 . A = B/C;
57-248 . A = B/C;
57-249 .
57-250 . if (A < B)
57-251 . {
57-252 . A = B + C;
57-253 . D = E + F;
57-254 . }
57-255 .
57-256 . A = B+C;
57-257 . A = B+C;
57-258 .
57-259 . if (A < B)
57-260 . {
57-261 . A = B + C;
57-262 . D = E + F;
57-263 . }
57-264 .
57-265 .
57-266 . if (A < B)
57-267 . {
57-268 . A = B + C;
57-269 . D = E + F;
57-270 . }
57-271 .
57-272 . A = B*C;
57-273 .
57-274 . if (A le B)
57-275 . {
57-276 . A = B + C;
57-277 . D = E + F;
57-278 . }
57-279 .
57-280 . A = B-C;
57-281 .
57-282 . if (A != B)
57-283 . {
57-284 . A = B + C;
57-285 . D = E + F;
57-286 . }
57-287 .
57-288 .
57-289 . if (A < = B)
57-290 . {
57-291 . A = B + C;
57-292 . D = E + F;
57-293 . }
57-294 .
57-295 .
57-296 . #ifdef LAZY
57-297 . // this is not nice
57-298 . A = B + C;
57-299 . A = B + C;
57-300 . #endif
57-301 .
57-302 . A = B*C;
57-303 . A = B-C;
57-304 . A = B*C;
57-305 . A = B+C;
57-306 . A = B-C;
57-307 .
57-308 . if (A != B)
57-309 . {
57-310 . A = B + C;
57-311 . D = E + F;
57-312 . }
57-313 .
57-314 . A = B/C;
57-315 . /* LE SV TOC-2896 this is a stp-05.2.46 req to set Real Time Clock*/
57-316 . A = B-C;
57-317 . A = B+C;
57-318 .
57-319 . if (A lt B)
57-320 . {
57-321 . A = B + C;
57-322 . D = E + F;
57-323 . }
57-324 .
57-325 . A = B+C;
57-326 .
57-327 . if (A > B)
57-328 . {
57-329 . A = B + C;
57-330 . D = E + F;
57-331 . }
57-332 .
57-333 .
57-334 . if (A < B)
57-335 . {
57-336 . A = B + C;
57-337 . D = E + F;
57-338 . }
57-339 .
57-340 .
57-341 . if (A != B)
57-342 . {
57-343 . A = B + C;
57-344 . D = E + F;
57-345 . }
57-346 .
57-347 . A = 0x0006;
57-348 . A = B+C;
57-349 . A = B-C;
57-350 . A = B*C;
57-351 .
57-352 . switch (stp stuff)
57-353 . {
57-354 . case one:
57-355 . {
57-356 . run_this;
57-357 . break;
57-358 . }
57-359 . case two:
57-360 . {
57-361 . run_this;
57-362 . break;
57-363 . }
57-364 . default:
57-365 . {
57-366 . SwError;
57-367 . }
57-368 . }
57-369 .
57-370 .
57-371 . if (A > B)
57-372 . {
57-373 . A = B + C;
57-374 . D = E + F;
57-375 . }
57-376 .
57-377 . A = B+C;
57-378 . A = B*C;
57-379 . /* LE SV TOC-2897 this is a stp-05.2.60 req to recover*/
57-380 . A = B-C;
57-381 . A = B*C;
57-382 . A = B+C;
57-383 . A = B-C;
57-384 . A = B-C;
57-385 .
57-386 . if (A le B)
57-387 . {
57-388 . A = B + C;
57-389 . D = E + F;
57-390 . }
57-391 .
57-392 . A = B*C;
57-393 . A = B-C;
57-394 .
57-395 . if (A ge B)
57-396 . {
57-397 . A = B + C;
57-398 . D = E + F;
57-399 . }
57-400 .
57-401 . A = B+C;
57-402 . A = B+C;
57-403 .
57-404 . if (A > B)
57-405 . {
57-406 . A = B + C;
57-407 . D = E + F;
57-408 . }
57-409 .
57-410 . A = B+C;
57-411 . /* LE SV TOC-2898 this is a stp-05.2.73 req to convert*/
57-412 . A = B/C;
57-413 . A = B*C;
57-414 . A = B+C;
57-415 . A = 0x0008;
57-416 .
57-417 . if (A < B)
57-418 . {
57-419 . A = B + C;
57-420 . D = E + F;
57-421 . }
57-422 .
57-423 . A = B*C;
57-424 .
57-425 . if (A > B)
57-426 . {
57-427 . A = B + C;
57-428 . D = E + F;
57-429 . }
57-430 .
57-431 . // max LOC 78
57-432 .
57-433 . }
57-434 .
57-435 .
57-436 . /*
57-437 . -----------------------------------------------------------------------------
57-438 . --| NAME: stp.5.3
57-439 . --|
57-440 . --| ABSTRACT:
57-441 . --| This function does stp stuff.
57-442 . --|
57-443 . --| RETURNS:
57-444 . --| NONE.
57-445 . --|
57-446 . ----------------------------------------------------------------------------
57-447 . */
57-448 . static void stp.5.3(void)
57-449 . {
57-450 . A = B+C;
57-451 .
57-452 . if (A gt B)
57-453 . {
57-454 . A = B + C;
57-455 . D = E + F;
57-456 . }
57-457 .
57-458 .
57-459 . if (A < B)
57-460 . {
57-461 . A = B + C;
57-462 . D = E + F;
57-463 . }
57-464 .
57-465 . A = B*C;
57-466 . FreePtr = HmiStringPtr;
57-467 . A = B*C;
57-468 .
57-469 . if (A eq B)
57-470 . {
57-471 . A = B + C;
57-472 . D = E + F;
57-473 . }
57-474 .
57-475 .
57-476 . if (A < B)
57-477 . {
57-478 . A = B + C;
57-479 . D = E + F;
57-480 . }
57-481 .
57-482 . A = B*C;
57-483 . A = B-C;
57-484 . A = B+C;
57-485 .
57-486 . switch (stp stuff)
57-487 . {
57-488 . case one:
57-489 . {
57-490 . run_this;
57-491 . break;
57-492 . }
57-493 . case two:
57-494 . {
57-495 . run_this;
57-496 . break;
57-497 . }
57-498 . default:
57-499 . {
57-500 . // missing error call
57-501 . }
57-502 . }
57-503 .
57-504 . A = B*C;
57-505 . A = B/C;
57-506 . A = B*C;
57-507 . A = B+C;
57-508 . A = B/C;
57-509 .
57-510 . if (A < = B)
57-511 . {
57-512 . A = B + C;
57-513 . D = E + F;
57-514 . }
57-515 .
57-516 . A = B-C;
57-517 .
57-518 . switch (stp stuff)
57-519 . {
57-520 . case one:
57-521 . {
57-522 . run_this;
57-523 . break;
57-524 . }
57-525 . case two:
57-526 . {
57-527 . run_this;
57-528 . break;
57-529 . }
57-530 . default:
57-531 . {
57-532 . SwError;
57-533 . }
57-534 . }
57-535 .
57-536 . A = B+C;
57-537 . /* LE SV TOC-2899 this is a stp-05.3.20 req to translate*/
57-538 . A = B-C;
57-539 .
57-540 . if (A > B)
57-541 . {
57-542 . A = B + C;
57-543 . D = E + F;
57-544 . }
57-545 .
57-546 . A = B+C;
57-547 .
57-548 . if (A ge B)
57-549 . {
57-550 . A = B + C;
57-551 . D = E + F;
57-552 . }
57-553 .
57-554 . // max LOC 23
57-555 .
57-556 . }
57-557 .
57-558 .
57-559 . /*
57-560 . -----------------------------------------------------------------------------
57-561 . --| NAME: stp.5.4
57-562 . --|
57-563 . --| ABSTRACT:
57-564 . --| This function does stp stuff.
57-565 . --|
57-566 . --| RETURNS:
57-567 . --| NONE.
57-568 . --|
57-569 . ----------------------------------------------------------------------------
57-570 . */
57-571 . static void stp.5.4(void)
57-572 . {
57-573 . A = B+C;
57-574 . A = B*C;
57-575 .
57-576 . if (A > B)
57-577 . {
57-578 . A = B + C;
57-579 . D = E + F;
57-580 . }
57-581 .
57-582 . A = B-C;
57-583 . A = B-C;
57-584 .
57-585 . if (A < B)
57-586 . {
57-587 . A = B + C;
57-588 . D = E + F;
57-589 . }
57-590 .
57-591 .
57-592 . if (A == B)
57-593 . {
57-594 . A = B + C;
57-595 . D = E + F;
57-596 . }
57-597 .
57-598 .
57-599 . if (A < = B)
57-600 . {
57-601 . A = B + C;
57-602 . D = E + F;
57-603 . }
57-604 .
57-605 .
57-606 . if (A < B)
57-607 . {
57-608 . A = B + C;
57-609 . D = E + F;
57-610 . }
57-611 .
57-612 . A = B/C;
57-613 . A = B/C;
57-614 . /* LE SV TOC-2900 this is a stp-05.4.12 req to convert*/
57-615 .
57-616 . switch (stp stuff)
57-617 . {
57-618 . case one:
57-619 . {
57-620 . run_this;
57-621 . break;
57-622 . }
57-623 . case two:
57-624 . {
57-625 . run_this;
57-626 . break;
57-627 . }
57-628 . default:
57-629 . {
57-630 . SwError;
57-631 . }
57-632 . }
57-633 .
57-634 . A = B/C;
57-635 .
57-636 . #ifdef LAZY
57-637 . // this is not nice
57-638 . A = B + C;
57-639 . A = B + C;
57-640 . #endif
57-641 .
57-642 .
57-643 . if (A < = B)
57-644 . {
57-645 . A = B + C;
57-646 . D = E + F;
57-647 . }
57-648 .
57-649 . A = B/C;
57-650 .
57-651 . if (A eq B)
57-652 . {
57-653 . A = B + C;
57-654 . D = E + F;
57-655 . }
57-656 .
57-657 .
57-658 . if (A > = B)
57-659 . {
57-660 . A = B + C;
57-661 . D = E + F;
57-662 . }
57-663 .
57-664 .
57-665 . if (A > = B)
57-666 . {
57-667 . A = B + C;
57-668 . D = E + F;
57-669 . }
57-670 .
57-671 . A = B+C;
57-672 . A = B/C;
57-673 .
57-674 . if (A gt B)
57-675 . {
57-676 . A = B + C;
57-677 . D = E + F;
57-678 . }
57-679 .
57-680 . A = B-C;
57-681 .
57-682 . if (A eq B)
57-683 . {
57-684 . A = B + C;
57-685 . D = E + F;
57-686 . }
57-687 .
57-688 . A = B+C;
57-689 . A = B-C;
57-690 . A = B+C;
57-691 . A = B*C;
57-692 . A = B-C;
57-693 . A = B-C;
57-694 . A = B*C;
57-695 . A = B/C;
57-696 . A = B*C;
57-697 . A = B-C;
57-698 . A = B+C;
57-699 . A = B/C;
57-700 . A = 0x0007;
57-701 . A = B*C;
57-702 . A = B*C;
57-703 .
57-704 . switch (stp stuff)
57-705 . {
57-706 . case one:
57-707 . {
57-708 . run_this;
57-709 . break;
57-710 . }
57-711 . case two:
57-712 . {
57-713 . run_this;
57-714 . break;
57-715 . }
57-716 . default:
57-717 . {
57-718 . SwError;
57-719 . }
57-720 . }
57-721 .
57-722 . A = B+C;
57-723 .
57-724 . #ifdef LAZY
57-725 . // this is not nice
57-726 . A = B + C;
57-727 . A = B + C;
57-728 . #endif
57-729 .
57-730 . A = B*C;
57-731 . A = B*C;
57-732 . A = B+C;
57-733 . /* LE SV TOC-2901 this is a stp-05.4.43 req to compare*/
57-734 . A = B+C;
57-735 . A = B+C;
57-736 . A = B/C;
57-737 . A = B*C;
57-738 . A = B+C;
57-739 .
57-740 . if (A < B)
57-741 . {
57-742 . A = B + C;
57-743 . D = E + F;
57-744 . }
57-745 .
57-746 . A = B/C;
57-747 . A = B*C;
57-748 . A = B+C;
57-749 . A = B-C;
57-750 . A = B+C;
57-751 . A = B-C;
57-752 . A = B-C;
57-753 . // max LOC 55
57-754 .
57-755 . }
57-756 .
57-757 .
57-758 . /*
57-759 . -----------------------------------------------------------------------------
57-760 . --| NAME: stp.5.5
57-761 . --|
57-762 . --| ABSTRACT:
57-763 . --| This function does stp stuff.
57-764 . --|
57-765 . --| RETURNS:
57-766 . --| NONE.
57-767 . --|
57-768 . ----------------------------------------------------------------------------
57-769 . */
57-770 . static void stp.5.5(void)
57-771 . {
57-772 . A = B+C;
57-773 . A = B/C;
57-774 . A = B*C;
57-775 . A = B-C;
57-776 . A = B/C;
57-777 .
57-778 . if (A < B)
57-779 . {
57-780 . A = B + C;
57-781 . D = E + F;
57-782 . }
57-783 .
57-784 . A = B-C;
57-785 .
57-786 . if (A ne B)
57-787 . {
57-788 . A = B + C;
57-789 . D = E + F;
57-790 . }
57-791 .
57-792 . A = B/C;
57-793 . A = B+C;
57-794 . A = B-C;
57-795 . A = (int)B + C;
57-796 .
57-797 . if (A lt B)
57-798 . {
57-799 . A = B + C;
57-800 . D = E + F;
57-801 . }
57-802 .
57-803 . A = B*C;
57-804 . A = B+C;
57-805 . A = B+C;
57-806 .
57-807 . /*
57-808 . dead_code = B - C;
57-809 . dead_code = D - E;
57-810 . dead_code = F - G;
57-811 . */
57-812 .
57-813 .
57-814 . if (A le B)
57-815 . {
57-816 . A = B + C;
57-817 . D = E + F;
57-818 . }
57-819 .
57-820 .
57-821 . if (A > = B)
57-822 . {
57-823 . A = B + C;
57-824 . D = E + F;
57-825 . }
57-826 .
57-827 . A = B-C;
57-828 . A = B/C;
57-829 . A = B*C;
57-830 .
57-831 . if (A < = B)
57-832 . {
57-833 . A = B + C;
57-834 . D = E + F;
57-835 . }
57-836 .
57-837 . A = B*C;
57-838 . /* LE SV TOC-2902 this is a stp-05.5.23 req to compare*/
57-839 . A = B+C;
57-840 . A = B-C;
57-841 . A = B+C;
57-842 .
57-843 . switch (stp stuff)
57-844 . {
57-845 . case one:
57-846 . {
57-847 . run_this;
57-848 . break;
57-849 . }
57-850 . case two:
57-851 . {
57-852 . run_this;
57-853 . break;
57-854 . }
57-855 . default:
57-856 . {
57-857 . // missing error call
57-858 . }
57-859 . }
57-860 .
57-861 . A = B*C;
57-862 . A = B+C;
57-863 . A = B-C;
57-864 . A = B/C;
57-865 . A = B*C;
57-866 . A = B/C;
57-867 . A = B*C;
57-868 . A = B*C;
57-869 . A = B+C;
57-870 . A = B*C;
57-871 .
57-872 . if (A > B)
57-873 . {
57-874 . A = B + C;
57-875 . D = E + F;
57-876 . }
57-877 .
57-878 . A = B*C;
57-879 . /* LE SV TOC-2903 this is a stp-05.5.38 req to set RTC*/
57-880 . A = B+C;
57-881 . A = B/C;
57-882 . A = B*C;
57-883 .
57-884 . if (A == B)
57-885 . {
57-886 . A = B + C;
57-887 . D = E + F;
57-888 . }
57-889 .
57-890 .
57-891 . if (A > = B)
57-892 . {
57-893 . A = B + C;
57-894 . D = E + F;
57-895 . }
57-896 .
57-897 . A = B/C;
57-898 . A = B/C;
57-899 . A = B-C;
57-900 . A = B-C;
57-901 . /* LE SV TOC-2904 this is a stp-05.5.47 req to convert*/
57-902 . A = B-C;
57-903 .
57-904 . if (veg)
57-905 . // missing curly brace
57-906 . variable = orange;
57-907 .
57-908 . A = B+C;
57-909 .
57-910 . if (A ne B)
57-911 . {
57-912 . A = B + C;
57-913 . D = E + F;
57-914 . }
57-915 .
57-916 . A = B+C;
57-917 . A = B+C;
57-918 . A = B*C;
57-919 .
57-920 . if (A > B)
57-921 . {
57-922 . A = B + C;
57-923 . D = E + F;
57-924 . }
57-925 .
57-926 . A = B*C;
57-927 . A = B/C;
57-928 . // max LOC 55
57-929 .
57-930 . }
57-931 .
57-932 .
57-933 . /*
57-934 . -----------------------------------------------------------------------------
57-935 . --| NAME: stp.5.6
57-936 . --|
57-937 . --| ABSTRACT:
57-938 . --| This function does stp stuff.
57-939 . --|
57-940 . --| RETURNS:
57-941 . --| NONE.
57-942 . --|
57-943 . ----------------------------------------------------------------------------
57-944 . */
57-945 . static void stp.5.6(void)
57-946 . {
57-947 . A = B*C;
57-948 . A = B-C;
57-949 . A = B+C;
57-950 . A = B*C;
57-951 .
57-952 . if (A > = B)
57-953 . {
57-954 . A = B + C;
57-955 . D = E + F;
57-956 . }
57-957 .
57-958 . A = B+C;
57-959 . A = B/C;
57-960 . A = B*C;
57-961 .
57-962 . if (A le B)
57-963 . {
57-964 . A = B + C;
57-965 . D = E + F;
57-966 . }
57-967 .
57-968 .
57-969 . if (A lt B)
57-970 . {
57-971 . A = B + C;
57-972 . D = E + F;
57-973 . }
57-974 .
57-975 .
57-976 . if (A < = B)
57-977 . {
57-978 . A = B + C;
57-979 . D = E + F;
57-980 . }
57-981 .
57-982 .
57-983 . if (A ge B)
57-984 . {
57-985 . A = B + C;
57-986 . D = E + F;
57-987 . }
57-988 .
57-989 .
57-990 . if (A le B)
57-991 . {
57-992 . A = B + C;
57-993 . D = E + F;
57-994 . }
57-995 .
57-996 . A = (int)B + C;
57-997 . A = B/C;
57-998 . A = 0x0004;
57-999 . A = B*C;
57-1000 . A = B*C;
57-1001 .
57-1002 . if (A eq B)
57-1003 . {
57-1004 . A = B + C;
57-1005 . D = E + F;
57-1006 . }
57-1007 .
57-1008 . A = B+C;
57-1009 . // max LOC 18
57-1010 .
57-1011 . }
57-1012 .
57-1013 .
57-1014 . /*
57-1015 . -----------------------------------------------------------------------------
57-1016 . --| NAME: stp.5.7
57-1017 . --|
57-1018 . --| ABSTRACT:
57-1019 . --| This function does stp stuff.
57-1020 . --|
57-1021 . --| RETURNS:
57-1022 . --| NONE.
57-1023 . --|
57-1024 . ----------------------------------------------------------------------------
57-1025 . */
57-1026 . static void stp.5.7(void)
57-1027 . {
57-1028 . A = B/C;
57-1029 .
57-1030 . if (A != B)
57-1031 . {
57-1032 . A = B + C;
57-1033 . D = E + F;
57-1034 . }
57-1035 .
57-1036 .
57-1037 . if (A > B)
57-1038 . {
57-1039 . A = B + C;
57-1040 . D = E + F;
57-1041 . }
57-1042 .
57-1043 .
57-1044 . if (A ge B)
57-1045 . {
57-1046 . A = B + C;
57-1047 . D = E + F;
57-1048 . }
57-1049 .
57-1050 . A = B*C;
57-1051 . A = B-C;
57-1052 .
57-1053 . switch (stp stuff)
57-1054 . {
57-1055 . case one:
57-1056 . {
57-1057 . run_this;
57-1058 . break;
57-1059 . }
57-1060 . case two:
57-1061 . {
57-1062 . run_this;
57-1063 . break;
57-1064 . }
57-1065 . default:
57-1066 . {
57-1067 . SwError;
57-1068 . }
57-1069 . }
57-1070 .
57-1071 .
57-1072 . if (A > B)
57-1073 . {
57-1074 . A = B + C;
57-1075 . D = E + F;
57-1076 . }
57-1077 .
57-1078 . A = B-C;
57-1079 . A = B*C;
57-1080 . A = B-C;
57-1081 .
57-1082 . if (A == B)
57-1083 . {
57-1084 . A = B + C;
57-1085 . D = E + F;
57-1086 . }
57-1087 .
57-1088 . A = B/C;
57-1089 . A = B-C;
57-1090 .
57-1091 . switch (stp stuff)
57-1092 . {
57-1093 . case one:
57-1094 . {
57-1095 . switch (nested)
57-1096 . {
57-1097 . case:
57-1098 . X = Y + Z;
57-1099 . case:
57-1100 . X = Y + Z;
57-1101 . default:
57-1102 . SwError;
57-1103 . }
57-1104 . }
57-1105 . case two:
57-1106 . {
57-1107 . run_this;
57-1108 . break;
57-1109 . }
57-1110 . default:
57-1111 . {
57-1112 . SwError;
57-1113 . }
57-1114 . }
57-1115 .
57-1116 . A = B/C;
57-1117 . A = B*C;
57-1118 . // TBS - I need to figure this out
57-1119 . A = B+C;
57-1120 . A = B+C;
57-1121 . A = B/C;
57-1122 . A = B+C;
57-1123 . A = B+C;
57-1124 . A = B-C;
57-1125 . A = B+C;
57-1126 .
57-1127 . /*
57-1128 . dead_block = C * D;
57-1129 . dead_block = E * F;
57-1130 . */
57-1131 .
57-1132 . A = B+C;
57-1133 . A = B/C;
57-1134 . A = B-C;
57-1135 .
57-1136 . if (A == B)
57-1137 . {
57-1138 . A = B + C;
57-1139 . D = E + F;
57-1140 . }
57-1141 .
57-1142 . A = B+C;
57-1143 . A = B+C;
57-1144 . A = B*C;
57-1145 . A = B-C;
57-1146 . A = B/C;
57-1147 . A = B-C;
57-1148 . A = B-C;
57-1149 .
57-1150 . if (A eq B)
57-1151 . {
57-1152 . A = B + C;
57-1153 . D = E + F;
57-1154 . }
57-1155 .
57-1156 .
57-1157 . if (A < B)
57-1158 . {
57-1159 . A = B + C;
57-1160 . D = E + F;
57-1161 . }
57-1162 .
57-1163 . /* LE SV TOC-2905 this is a stp-05.7.37 req to process*/
57-1164 . A = B*C;
57-1165 . A = B-C;
57-1166 .
57-1167 . if (A eq B)
57-1168 . {
57-1169 . A = B + C;
57-1170 . D = E + F;
57-1171 . }
57-1172 .
57-1173 . A = B*C;
57-1174 .
57-1175 . if (A < = B)
57-1176 . {
57-1177 . A = B + C;
57-1178 . D = E + F;
57-1179 . }
57-1180 .
57-1181 . // max LOC 41
57-1182 .
57-1183 . }
57-1184 .
57-1185 .
57-1186 . /*
57-1187 . -----------------------------------------------------------------------------
57-1188 . --| NAME: stp.5.8
57-1189 . --|
57-1190 . --| ABSTRACT:
57-1191 . --| This function does stp stuff.
57-1192 . --|
57-1193 . --| RETURNS:
57-1194 . --| NONE.
57-1195 . --|
57-1196 . ----------------------------------------------------------------------------
57-1197 . */
57-1198 . static void stp.5.8(void)
57-1199 . {
57-1200 . A = B-C;
57-1201 . A = B*C;
57-1202 . A = B-C;
57-1203 .
57-1204 . if (A > B)
57-1205 . {
57-1206 . A = B + C;
57-1207 . D = E + F;
57-1208 . }
57-1209 .
57-1210 . /* LE SV TOC-2906 this is a stp-05.8.5 req to disable*/
57-1211 . A = B+C;
57-1212 . A = B+C;
57-1213 . A = B+C;
57-1214 . A = B+C;
57-1215 . A = B/C;
57-1216 . A = B+C;
57-1217 . A = B/C;
57-1218 . A = B+C;
57-1219 .
57-1220 . if (A < B)
57-1221 . {
57-1222 . A = B + C;
57-1223 . D = E + F;
57-1224 . }
57-1225 .
57-1226 . A = B-C;
57-1227 . A = B/C;
57-1228 . A = B*C;
57-1229 . A = B*C;
57-1230 .
57-1231 . if (A == B)
57-1232 . {
57-1233 . A = B + C;
57-1234 . D = E + F;
57-1235 . }
57-1236 .
57-1237 . A = B/C;
57-1238 . A = B+C;
57-1239 . A = B*C;
57-1240 .
57-1241 . #ifdef LAZY
57-1242 . // this is not nice
57-1243 . A = B + C;
57-1244 . A = B + C;
57-1245 . #endif
57-1246 .
57-1247 . A = B/C;
57-1248 . A = B*C;
57-1249 . goto error;
57-1250 . A = B-C;
57-1251 . A = B/C;
57-1252 . A = B/C;
57-1253 .
57-1254 . if (A != B)
57-1255 . {
57-1256 . A = B + C;
57-1257 . D = E + F;
57-1258 . }
57-1259 .
57-1260 .
57-1261 . switch (stp stuff)
57-1262 . {
57-1263 . case:
57-1264 . case:
57-1265 . // stacked case statements but only if there is a new line in between
57-1266 .
57-1267 . case:
57-1268 . case:
57-1269 . case:
57-1270 . {
57-1271 . run_this;
57-1272 . break;
57-1273 . }
57-1274 . default:
57-1275 . {
57-1276 . halt;
57-1277 . }
57-1278 . }
57-1279 .
57-1280 . A = B-C;
57-1281 . /* LE SV TOC-2907 this is a stp-05.8.29 req to halt*/
57-1282 . A = B/C;
57-1283 . A = B*C;
57-1284 . /* LE SV TOC-2908 this is a stp-05.8.31 req to compare*/
57-1285 .
57-1286 . if (A < B)
57-1287 . {
57-1288 . A = B + C;
57-1289 . D = E + F;
57-1290 . }
57-1291 .
57-1292 . A = B/C;
57-1293 . A = B/C;
57-1294 .
57-1295 . if (A < = B)
57-1296 . {
57-1297 . A = B + C;
57-1298 . D = E + F;
57-1299 . }
57-1300 .
57-1301 . A = B+C;
57-1302 . /* LE SV TOC-2909 this is a stp-05.8.36 req to set Real Time Clock*/
57-1303 .
57-1304 . switch (stp stuff)
57-1305 . {
57-1306 . case one:
57-1307 . {
57-1308 . run_this;
57-1309 . break;
57-1310 . }
57-1311 . case two:
57-1312 . {
57-1313 . run_this;
57-1314 . break;
57-1315 . }
57-1316 . default:
57-1317 . {
57-1318 . SwError;
57-1319 . }
57-1320 . }
57-1321 .
57-1322 . A = B+C;
57-1323 .
57-1324 . switch (stp stuff)
57-1325 . {
57-1326 . case one:
57-1327 . {
57-1328 . run_this;
57-1329 . break;
57-1330 . }
57-1331 . case two:
57-1332 . {
57-1333 . run_this;
57-1334 . break;
57-1335 . }
57-1336 . default:
57-1337 . {
57-1338 . SwError;
57-1339 . }
57-1340 . }
57-1341 .
57-1342 . A = B/C;
57-1343 . A = B*C;
57-1344 . A = B/C;
57-1345 . A = B+C;
57-1346 .
57-1347 . if (A > = B)
57-1348 . {
57-1349 . A = B + C;
57-1350 . D = E + F;
57-1351 . }
57-1352 .
57-1353 . A = B*C;
57-1354 .
57-1355 . if (A == B)
57-1356 . {
57-1357 . A = B + C;
57-1358 . D = E + F;
57-1359 . }
57-1360 .
57-1361 . A = B+C;
57-1362 . A = B+C;
57-1363 . A = B*C;
57-1364 .
57-1365 . if ($stp stuff > $otherstp stuff)
57-1366 . /* LE SV TOC-008 we really should log all error calls */
57-1367 . {
57-1368 . A = B + C;
57-1369 . }
57-1370 .
57-1371 .
57-1372 . if (A < B)
57-1373 . {
57-1374 . A = B + C;
57-1375 . D = E + F;
57-1376 . }
57-1377 .
57-1378 . A = B*C;
57-1379 . A = B-C;
57-1380 . A = B/C;
57-1381 . A = B*C;
57-1382 . A = B*C;
57-1383 .
57-1384 . if (A > = B)
57-1385 . {
57-1386 . A = B + C;
57-1387 . D = E + F;
57-1388 . }
57-1389 .
57-1390 . A = B-C;
57-1391 .
57-1392 . if (A > B)
57-1393 . {
57-1394 . A = B + C;
57-1395 . D = E + F;
57-1396 . }
57-1397 .
57-1398 . A = B-C;
57-1399 .
57-1400 . switch (stp stuff)
57-1401 . {
57-1402 . case one:
57-1403 . {
57-1404 . switch (nested)
57-1405 . {
57-1406 . case:
57-1407 . X = Y + Z;
57-1408 . case:
57-1409 . X = Y + Z;
57-1410 . default:
57-1411 . SwError;
57-1412 . }
57-1413 . }
57-1414 . case two:
57-1415 . {
57-1416 . run_this;
57-1417 . break;
57-1418 . }
57-1419 . default:
57-1420 . {
57-1421 . SwError;
57-1422 . }
57-1423 . }
57-1424 .
57-1425 . A = B*C;
57-1426 .
57-1427 . if (A ne B)
57-1428 . {
57-1429 . A = B + C;
57-1430 . D = E + F;
57-1431 . }
57-1432 .
57-1433 . A = B+C;
57-1434 .
57-1435 . if (A != B)
57-1436 . {
57-1437 . A = B + C;
57-1438 . D = E + F;
57-1439 . }
57-1440 .
57-1441 . A = B-C;
57-1442 . A = B+C;
57-1443 . A = B+C;
57-1444 . A = B+C;
57-1445 . A = B/C;
57-1446 . A = B*C;
57-1447 . A = B+C;
57-1448 . /* LE SV TOC-2910 this is a stp-05.8.70 req to validate*/
57-1449 .
57-1450 . if (A < = B)
57-1451 . {
57-1452 . A = B + C;
57-1453 . D = E + F;
57-1454 . }
57-1455 .
57-1456 .
57-1457 . if (A ne B)
57-1458 . {
57-1459 . A = B + C;
57-1460 . D = E + F;
57-1461 . }
57-1462 .
57-1463 . A = B-C;
57-1464 . A = B-C;
57-1465 . A = B*C;
57-1466 .
57-1467 . if (A lt B)
57-1468 . {
57-1469 . A = B + C;
57-1470 . D = E + F;
57-1471 . }
57-1472 .
57-1473 .
57-1474 . switch (stp stuff)
57-1475 . {
57-1476 . case one:
57-1477 . {
57-1478 . run_this;
57-1479 . break;
57-1480 . }
57-1481 . case two:
57-1482 . {
57-1483 . run_this;
57-1484 . break;
57-1485 . }
57-1486 . default:
57-1487 . {
57-1488 . SwError;
57-1489 . }
57-1490 . }
57-1491 .
57-1492 . /* LE SV TOC-2911 this is a stp-05.8.77 req to set RTC*/
57-1493 .
57-1494 . if (A != B)
57-1495 . {
57-1496 . A = B + C;
57-1497 . D = E + F;
57-1498 . }
57-1499 .
57-1500 . A = B-C;
57-1501 .
57-1502 . if (A eq B)
57-1503 . {
57-1504 . A = B + C;
57-1505 . D = E + F;
57-1506 . }
57-1507 .
57-1508 .
57-1509 . if (A le B)
57-1510 . {
57-1511 . A = B + C;
57-1512 . D = E + F;
57-1513 . }
57-1514 .
57-1515 . A = B/C;
57-1516 . A = B+C;
57-1517 .
57-1518 . if (A eq B)
57-1519 . {
57-1520 . A = B + C;
57-1521 . D = E + F;
57-1522 . }
57-1523 .
57-1524 . A = B/C;
57-1525 . /* LE SV TOC-2912 this is a stp-05.8.85 req to fail*/
57-1526 .
57-1527 . if (A lt B)
57-1528 . {
57-1529 . A = B + C;
57-1530 . D = E + F;
57-1531 . }
57-1532 .
57-1533 . A = B*C;
57-1534 . A = 0x0007;
57-1535 .
57-1536 . if (A != B)
57-1537 . {
57-1538 . A = B + C;
57-1539 . D = E + F;
57-1540 . }
57-1541 .
57-1542 . A = B/C;
57-1543 .
57-1544 . if (A < = B)
57-1545 . {
57-1546 . A = B + C;
57-1547 . D = E + F;
57-1548 . }
57-1549 .
57-1550 . A = B*C;
57-1551 . A = B/C;
57-1552 .
57-1553 . if (A != B)
57-1554 . {
57-1555 . A = B + C;
57-1556 . D = E + F;
57-1557 . }
57-1558 .
57-1559 . A = B-C;
57-1560 . /* LE SV TOC-2913 this is a stp-05.8.94 req to store*/
57-1561 . A = B-C;
57-1562 . /* LE SV TOC-2914 this is a stp-05.8.95 req to update*/
57-1563 . A = B*C;
57-1564 . A = B-C;
57-1565 . A = B+C;
57-1566 . // max LOC 97
57-1567 .
57-1568 . }
57-1569 .
57-1570 .
57-1571 . /*
57-1572 . -----------------------------------------------------------------------------
57-1573 . --| NAME: stp.5.9
57-1574 . --|
57-1575 . --| ABSTRACT:
57-1576 . --| This function does stp stuff.
57-1577 . --|
57-1578 . --| RETURNS:
57-1579 . --| NONE.
57-1580 . --|
57-1581 . ----------------------------------------------------------------------------
57-1582 . */
57-1583 . static void stp.5.9(void)
57-1584 . {
57-1585 .
57-1586 . if (A > B)
57-1587 . {
57-1588 . A = B + C;
57-1589 . D = E + F;
57-1590 . }
57-1591 .
57-1592 . /* LE SV TOC-2915 this is a stp-05.9.2 req to validate*/
57-1593 . A = B*C;
57-1594 . /* LE SV TOC-2916 this is a stp-05.9.3 req to check pSOS*/
57-1595 . A = B/C;
57-1596 . A = B/C;
57-1597 . A = B*C;
57-1598 . A = B*C;
57-1599 . A = (int)B + C;
57-1600 . A = B-C;
57-1601 . A = B*C;
57-1602 .
57-1603 . if (A < = B)
57-1604 . {
57-1605 . A = B + C;
57-1606 . D = E + F;
57-1607 . }
57-1608 .
57-1609 . A = B/C;
57-1610 . A = B/C;
57-1611 . A = 0x0003;
57-1612 . A = B/C;
57-1613 . A = B-C;
57-1614 . // max LOC 13
57-1615 .
57-1616 . }
57-1617 .
57-1618 .
57-1619 . /*
57-1620 . -----------------------------------------------------------------------------
57-1621 . --| NAME: stp.5.10
57-1622 . --|
57-1623 . --| ABSTRACT:
57-1624 . --| This function does stp stuff.
57-1625 . --|
57-1626 . --| RETURNS:
57-1627 . --| NONE.
57-1628 . --|
57-1629 . ----------------------------------------------------------------------------
57-1630 . */
57-1631 . static void stp.5.10(void)
57-1632 . {
57-1633 .
57-1634 . if (A lt B)
57-1635 . {
57-1636 . A = B + C;
57-1637 . D = E + F;
57-1638 . }
57-1639 .
57-1640 .
57-1641 . if (A > B)
57-1642 . {
57-1643 . A = B + C;
57-1644 . D = E + F;
57-1645 . }
57-1646 .
57-1647 . A = B/C;
57-1648 . A = B/C;
57-1649 . A = B*C;
57-1650 . A = B+C;
57-1651 . A = B/C;
57-1652 . A = B/C;
57-1653 . A = B+C;
57-1654 . A = B/C;
57-1655 . A = B/C;
57-1656 . A = B*C;
57-1657 . /* LE SV TOC-2917 this is a stp-05.10.13 req to disable*/
57-1658 .
57-1659 . if (A > B)
57-1660 . {
57-1661 . A = B + C;
57-1662 . D = E + F;
57-1663 . }
57-1664 .
57-1665 .
57-1666 . if (A != B)
57-1667 . {
57-1668 . A = B + C;
57-1669 . D = E + F;
57-1670 . }
57-1671 .
57-1672 . /* LE SV TOC-2918 this is a stp-05.10.15 req to verify*/
57-1673 .
57-1674 . if (A eq B)
57-1675 . {
57-1676 . A = B + C;
57-1677 . D = E + F;
57-1678 . }
57-1679 .
57-1680 .
57-1681 . if (A ne B)
57-1682 . {
57-1683 . A = B + C;
57-1684 . D = E + F;
57-1685 . }
57-1686 .
57-1687 . A = B+C;
57-1688 . A = B/C;
57-1689 .
57-1690 . if (A > B)
57-1691 . {
57-1692 . A = B + C;
57-1693 . D = E + F;
57-1694 . }
57-1695 .
57-1696 . A = B+C;
57-1697 . A = B*C;
57-1698 . A = B/C;
57-1699 . A = B+C;
57-1700 . A = B*C;
57-1701 . A = B*C;
57-1702 . A = B-C;
57-1703 . A = B/C;
57-1704 . A = B+C;
57-1705 . A = B/C;
57-1706 .
57-1707 . switch (stp stuff)
57-1708 . {
57-1709 . case one:
57-1710 . {
57-1711 . run_this;
57-1712 . break;
57-1713 . }
57-1714 . case two:
57-1715 . {
57-1716 . run_this;
57-1717 . break;
57-1718 . }
57-1719 . default:
57-1720 . {
57-1721 . SwError;
57-1722 . }
57-1723 . }
57-1724 .
57-1725 . A = B+C;
57-1726 . A = B-C;
57-1727 . A = B-C;
57-1728 . A = B*C;
57-1729 . A = B-C;
57-1730 .
57-1731 . if (A == B)
57-1732 . {
57-1733 . A = B + C;
57-1734 . D = E + F;
57-1735 . }
57-1736 .
57-1737 . /* LE SV TOC-2919 this is a stp-05.10.37 req to audit*/
57-1738 . A = B-C;
57-1739 . A = B*C;
57-1740 . A = B*C;
57-1741 .
57-1742 . if (A > B)
57-1743 . {
57-1744 . A = B + C;
57-1745 . D = E + F;
57-1746 . }
57-1747 .
57-1748 . A = B*C;
57-1749 . A = B-C;
57-1750 .
57-1751 . if (A lt B)
57-1752 . {
57-1753 . A = B + C;
57-1754 . D = E + F;
57-1755 . }
57-1756 .
57-1757 .
57-1758 . switch (stp stuff)
57-1759 . {
57-1760 . case one:
57-1761 . {
57-1762 . run_this;
57-1763 . break;
57-1764 . }
57-1765 . case two:
57-1766 . {
57-1767 . run_this;
57-1768 . break;
57-1769 . }
57-1770 . default:
57-1771 . {
57-1772 . SwError;
57-1773 . }
57-1774 . }
57-1775 .
57-1776 . A = B/C;
57-1777 . A = B-C;
57-1778 .
57-1779 . if (A lt B)
57-1780 . {
57-1781 . A = B + C;
57-1782 . D = E + F;
57-1783 . }
57-1784 .
57-1785 . A = B-C;
57-1786 . A = B-C;
57-1787 . A = B*C;
57-1788 .
57-1789 . if (A le B)
57-1790 . {
57-1791 . A = B + C;
57-1792 . D = E + F;
57-1793 . }
57-1794 .
57-1795 . A = B/C;
57-1796 . A = B/C;
57-1797 . A = 0x0002;
57-1798 .
57-1799 . if (A ne B)
57-1800 . {
57-1801 . A = B + C;
57-1802 . D = E + F;
57-1803 . }
57-1804 .
57-1805 . A = B+C;
57-1806 . A = B-C;
57-1807 . A = B/C;
57-1808 .
57-1809 . if (A gt B)
57-1810 . {
57-1811 . A = B + C;
57-1812 . D = E + F;
57-1813 . }
57-1814 .
57-1815 . A = B+C;
57-1816 . A = B+C;
57-1817 . A = 0x0004;
57-1818 . A = B-C;
57-1819 . A = B/C;
57-1820 .
57-1821 . if (A eq B)
57-1822 . {
57-1823 . A = B + C;
57-1824 . D = E + F;
57-1825 . }
57-1826 .
57-1827 .
57-1828 . if (A le B)
57-1829 . {
57-1830 . A = B + C;
57-1831 . D = E + F;
57-1832 . }
57-1833 .
57-1834 . A = B*C;
57-1835 . A = B/C;
57-1836 . A = B+C;
57-1837 .
57-1838 . if (A eq B)
57-1839 . {
57-1840 . A = B + C;
57-1841 . D = E + F;
57-1842 . }
57-1843 .
57-1844 . A = B+C;
57-1845 .
57-1846 . if (A > = B)
57-1847 . {
57-1848 . A = B + C;
57-1849 . D = E + F;
57-1850 . }
57-1851 .
57-1852 . A = B*C;
57-1853 . A = B/C;
57-1854 .
57-1855 . if (A le B)
57-1856 . {
57-1857 . A = B + C;
57-1858 . D = E + F;
57-1859 . }
57-1860 .
57-1861 .
57-1862 . if (A < = B)
57-1863 . {
57-1864 . A = B + C;
57-1865 . D = E + F;
57-1866 . }
57-1867 .
57-1868 . // TBS - I need to figure this out
57-1869 .
57-1870 . switch (stp stuff)
57-1871 . {
57-1872 . case one:
57-1873 . {
57-1874 . run_this;
57-1875 . break;
57-1876 . }
57-1877 . case two:
57-1878 . {
57-1879 . run_this;
57-1880 . break;
57-1881 . }
57-1882 . default:
57-1883 . {
57-1884 . SwError;
57-1885 . }
57-1886 . }
57-1887 .
57-1888 . A = B/C;
57-1889 . // max LOC 76
57-1890 .
57-1891 . }
57-1892 .
57-1893 .
57-1894 . /*
57-1895 . -----------------------------------------------------------------------------
57-1896 . --| NAME: stp.5.11
57-1897 . --|
57-1898 . --| ABSTRACT:
57-1899 . --| This function does stp stuff.
57-1900 . --|
57-1901 . --| RETURNS:
57-1902 . --| NONE.
57-1903 . --|
57-1904 . ----------------------------------------------------------------------------
57-1905 . */
57-1906 . static void stp.5.11(void)
57-1907 . {
57-1908 . /* LE SV TOC-2920 this is a stp-05.11.1 req to halt*/
57-1909 . A = B/C;
57-1910 . A = B/C;
57-1911 .
57-1912 . if (A gt B)
57-1913 . {
57-1914 . A = B + C;
57-1915 . D = E + F;
57-1916 . }
57-1917 .
57-1918 . A = B*C;
57-1919 .
57-1920 . if (A < = B)
57-1921 . {
57-1922 . A = B + C;
57-1923 . D = E + F;
57-1924 . }
57-1925 .
57-1926 .
57-1927 . if (A < = B)
57-1928 . {
57-1929 . A = B + C;
57-1930 . D = E + F;
57-1931 . }
57-1932 .
57-1933 . A = B*C;
57-1934 . A = B*C;
57-1935 . A = B+C;
57-1936 . A = B*C;
57-1937 . A = B/C;
57-1938 . // (P) this is really improtant
57-1939 .
57-1940 . if (A > = B)
57-1941 . {
57-1942 . A = B + C;
57-1943 . D = E + F;
57-1944 . }
57-1945 .
57-1946 .
57-1947 . if (A != B)
57-1948 . {
57-1949 . A = B + C;
57-1950 . D = E + F;
57-1951 . }
57-1952 .
57-1953 . A = B-C;
57-1954 .
57-1955 . if (A lt B)
57-1956 . {
57-1957 . A = B + C;
57-1958 . D = E + F;
57-1959 . }
57-1960 .
57-1961 . A = B*C;
57-1962 . A = B+C;
57-1963 . send_buffer = (U16 *) malloc(size+1);
57-1964 . A = B+C;
57-1965 . A = B+C;
57-1966 . A = 0x0001;
57-1967 . A = B-C;
57-1968 . free(FreePtr);
57-1969 . A = B+C;
57-1970 . A = B-C;
57-1971 . A = B*C;
57-1972 . A = B*C;
57-1973 . A = B*C;
57-1974 .
57-1975 . if (A != B)
57-1976 . {
57-1977 . A = B + C;
57-1978 . D = E + F;
57-1979 . }
57-1980 .
57-1981 . do forever;
57-1982 . A = B-C;
57-1983 . A = B+C;
57-1984 . A = B/C;
57-1985 . /* LE SV TOC-2921 this is a stp-05.11.30 req to inhibit*/
57-1986 . A = B/C;
57-1987 . // TBS - I need to figure this out
57-1988 . A = B-C;
57-1989 . A = B+C;
57-1990 . A = B-C;
57-1991 .
57-1992 . if (A > = B)
57-1993 . {
57-1994 . A = B + C;
57-1995 . D = E + F;
57-1996 . }
57-1997 .
57-1998 . A = B-C;
57-1999 . A = B*C;
57-2000 .
57-2001 . if (A < B)
57-2002 . {
57-2003 . A = B + C;
57-2004 . D = E + F;
57-2005 . }
57-2006 .
57-2007 . A = B*C;
57-2008 .
57-2009 . if (A < B)
57-2010 . {
57-2011 . A = B + C;
57-2012 . D = E + F;
57-2013 . }
57-2014 .
57-2015 .
57-2016 . if (A > = B)
57-2017 . {
57-2018 . A = B + C;
57-2019 . D = E + F;
57-2020 . }
57-2021 .
57-2022 . A = B+C;
57-2023 .
57-2024 . if (A > = B)
57-2025 . {
57-2026 . A = B + C;
57-2027 . D = E + F;
57-2028 . }
57-2029 .
57-2030 . A = B/C;
57-2031 . A = B/C;
57-2032 . A = B-C;
57-2033 . A = B+C;
57-2034 .
57-2035 . if (A gt B)
57-2036 . {
57-2037 . A = B + C;
57-2038 . D = E + F;
57-2039 . }
57-2040 .
57-2041 .
57-2042 . if (A ne B)
57-2043 . {
57-2044 . A = B + C;
57-2045 . D = E + F;
57-2046 . }
57-2047 .
57-2048 . A = B/C;
57-2049 .
57-2050 . if (A < B)
57-2051 . {
57-2052 . A = B + C;
57-2053 . D = E + F;
57-2054 . }
57-2055 .
57-2056 .
57-2057 . if (A ge B)
57-2058 . {
57-2059 . A = B + C;
57-2060 . D = E + F;
57-2061 . }
57-2062 .
57-2063 . A = B/C;
57-2064 . A = B+C;
57-2065 . A = B*C;
57-2066 . A = B+C;
57-2067 . A = 0x0008;
57-2068 .
57-2069 . if (A != B)
57-2070 . {
57-2071 . A = B + C;
57-2072 . D = E + F;
57-2073 . }
57-2074 .
57-2075 . A = B-C;
57-2076 .
57-2077 . if (veg)
57-2078 . // missing curly brace
57-2079 . variable = orange;
57-2080 .
57-2081 . A = B+C;
57-2082 .
57-2083 . if (A != B)
57-2084 . {
57-2085 . A = B + C;
57-2086 . D = E + F;
57-2087 . }
57-2088 .
57-2089 . // max LOC 59
57-2090 .
57-2091 . }
57-2092 .
57-2093 .
57-2094 . /*
57-2095 . -----------------------------------------------------------------------------
57-2096 . --| NAME: stp.5.12
57-2097 . --|
57-2098 . --| ABSTRACT:
57-2099 . --| This function does stp stuff.
57-2100 . --|
57-2101 . --| RETURNS:
57-2102 . --| NONE.
57-2103 . --|
57-2104 . ----------------------------------------------------------------------------
57-2105 . */
57-2106 . static void stp.5.12(void)
57-2107 . {
57-2108 . A = B-C;
57-2109 . A = B-C;
57-2110 .
57-2111 . if (A < B)
57-2112 . {
57-2113 . A = B + C;
57-2114 . D = E + F;
57-2115 . }
57-2116 .
57-2117 . A = B*C;
57-2118 .
57-2119 . if (A > B)
57-2120 . {
57-2121 . A = B + C;
57-2122 . D = E + F;
57-2123 . }
57-2124 .
57-2125 . A = B+C;
57-2126 . A = B/C;
57-2127 .
57-2128 . if (A == B)
57-2129 . {
57-2130 . A = B + C;
57-2131 . D = E + F;
57-2132 . }
57-2133 .
57-2134 . A = B-C;
57-2135 .
57-2136 . if (A != B)
57-2137 . {
57-2138 . A = B + C;
57-2139 . D = E + F;
57-2140 . }
57-2141 .
57-2142 . A = B-C;
57-2143 . A = B/C;
57-2144 . A = B-C;
57-2145 . /* LE SV TOC-2922 this is a stp-05.12.14 req to record*/
57-2146 . A = B/C;
57-2147 . A = B*C;
57-2148 . A = B/C;
57-2149 .
57-2150 . if (A eq B)
57-2151 . {
57-2152 . A = B + C;
57-2153 . D = E + F;
57-2154 . }
57-2155 .
57-2156 . A = B+C;
57-2157 . /* LE SV TOC-2923 this is a stp-05.12.19 req to fail*/
57-2158 . A = B-C;
57-2159 . A = B/C;
57-2160 . /* LE SV TOC-2924 this is a stp-05.12.21 req to detect error*/
57-2161 .
57-2162 . if (A ge B)
57-2163 . {
57-2164 . A = B + C;
57-2165 . D = E + F;
57-2166 . }
57-2167 .
57-2168 . A = B+C;
57-2169 . A = B*C;
57-2170 . A = B+C;
57-2171 .
57-2172 . if (A > B)
57-2173 . {
57-2174 . A = B + C;
57-2175 . D = E + F;
57-2176 . }
57-2177 .
57-2178 . A = B+C;
57-2179 . A = 0x0003;
57-2180 .
57-2181 . if (A > = B)
57-2182 . {
57-2183 . A = B + C;
57-2184 . D = E + F;
57-2185 . }
57-2186 .
57-2187 .
57-2188 . if (A > = B)
57-2189 . {
57-2190 . A = B + C;
57-2191 . D = E + F;
57-2192 . }
57-2193 .
57-2194 . A = B-C;
57-2195 .
57-2196 . if (A eq B)
57-2197 . {
57-2198 . A = B + C;
57-2199 . D = E + F;
57-2200 . }
57-2201 .
57-2202 . A = B/C;
57-2203 . A = 0x0006;
57-2204 .
57-2205 . if (A le B)
57-2206 . {
57-2207 . A = B + C;
57-2208 . D = E + F;
57-2209 . }
57-2210 .
57-2211 .
57-2212 . if (A ne B)
57-2213 . {
57-2214 . A = B + C;
57-2215 . D = E + F;
57-2216 . }
57-2217 .
57-2218 .
57-2219 . if (A > B)
57-2220 . {
57-2221 . A = B + C;
57-2222 . D = E + F;
57-2223 . }
57-2224 .
57-2225 .
57-2226 . if (A > B)
57-2227 . {
57-2228 . A = B + C;
57-2229 . D = E + F;
57-2230 . }
57-2231 .
57-2232 . A = 0x0002;
57-2233 . A = B-C;
57-2234 . A = B+C;
57-2235 .
57-2236 . if (A gt B)
57-2237 . {
57-2238 . A = B + C;
57-2239 . D = E + F;
57-2240 . }
57-2241 .
57-2242 . A = B-C;
57-2243 . A = B*C;
57-2244 . A = B+C;
57-2245 . A = B-C;
57-2246 . A = B*C;
57-2247 .
57-2248 . if (A ne B)
57-2249 . {
57-2250 . A = B + C;
57-2251 . D = E + F;
57-2252 . }
57-2253 .
57-2254 . A = B*C;
57-2255 . A = B-C;
57-2256 . A = B/C;
57-2257 . A = B+C;
57-2258 . A = B+C;
57-2259 . A = B-C;
57-2260 . // ??? go see ws
57-2261 .
57-2262 . if (A < = B)
57-2263 . {
57-2264 . A = B + C;
57-2265 . D = E + F;
57-2266 . }
57-2267 .
57-2268 . A = B+C;
57-2269 . A = B+C;
57-2270 . A = B+C;
57-2271 . /* LE SV TOC-2925 this is a stp-05.12.55 req to store*/
57-2272 .
57-2273 . if (A != B)
57-2274 . {
57-2275 . A = B + C;
57-2276 . D = E + F;
57-2277 . }
57-2278 .
57-2279 . A = B+C;
57-2280 .
57-2281 . if (A > B)
57-2282 . {
57-2283 . A = B + C;
57-2284 . D = E + F;
57-2285 . }
57-2286 .
57-2287 . A = B/C;
57-2288 .
57-2289 . if (A lt B)
57-2290 . {
57-2291 . A = B + C;
57-2292 . D = E + F;
57-2293 . }
57-2294 .
57-2295 .
57-2296 . switch (stp stuff)
57-2297 . {
57-2298 . case one:
57-2299 . {
57-2300 . run_this;
57-2301 . break;
57-2302 . }
57-2303 . case two:
57-2304 . {
57-2305 . run_this;
57-2306 . break;
57-2307 . }
57-2308 . default:
57-2309 . {
57-2310 . SwError;
57-2311 . }
57-2312 . }
57-2313 .
57-2314 . A = B-C;
57-2315 . A = B-C;
57-2316 . A = B/C;
57-2317 . A = B-C;
57-2318 . A = B/C;
57-2319 . A = B-C;
57-2320 . /* LE SV TOC-2926 this is a stp-05.12.67 req to verify*/
57-2321 . A = B+C;
57-2322 . A = B*C;
57-2323 . A = B-C;
57-2324 . A = B*C;
57-2325 . A = B-C;
57-2326 .
57-2327 . if (A lt B)
57-2328 . {
57-2329 . A = B + C;
57-2330 . D = E + F;
57-2331 . }
57-2332 .
57-2333 . A = B*C;
57-2334 . // max LOC 73
57-2335 .
57-2336 . }
57-2337 .
57-2338 .
57-2339 . /*
57-2340 . -----------------------------------------------------------------------------
57-2341 . --| NAME: stp.5.13
57-2342 . --|
57-2343 . --| ABSTRACT:
57-2344 . --| This function does stp stuff.
57-2345 . --|
57-2346 . --| RETURNS:
57-2347 . --| NONE.
57-2348 . --|
57-2349 . ----------------------------------------------------------------------------
57-2350 . */
57-2351 . static void stp.5.13(void)
57-2352 . {
57-2353 . A = B/C;
57-2354 . A = B+C;
57-2355 .
57-2356 . if (A != B)
57-2357 . {
57-2358 . A = B + C;
57-2359 . D = E + F;
57-2360 . }
57-2361 .
57-2362 . A = B-C;
57-2363 . A = B/C;
57-2364 . /* LE SV TOC-2927 this is a stp-05.13.6 req to call admin*/
57-2365 . A = B-C;
57-2366 . A = B*C;
57-2367 . A = B-C;
57-2368 . A = B*C;
57-2369 . A = B-C;
57-2370 . /* LE SV TOC-2928 this is a stp-05.13.11 req to halt*/
57-2371 . A = B+C;
57-2372 . A = B+C;
57-2373 .
57-2374 . if (A lt B)
57-2375 . {
57-2376 . A = B + C;
57-2377 . D = E + F;
57-2378 . }
57-2379 .
57-2380 .
57-2381 . if (A le B)
57-2382 . {
57-2383 . A = B + C;
57-2384 . D = E + F;
57-2385 . }
57-2386 .
57-2387 . A = B/C;
57-2388 . A = B/C;
57-2389 . A = B+C;
57-2390 .
57-2391 . if (A eq B)
57-2392 . {
57-2393 . A = B + C;
57-2394 . D = E + F;
57-2395 . }
57-2396 .
57-2397 . A = B+C;
57-2398 . A = B+C;
57-2399 . A = B/C;
57-2400 . A = B*C;
57-2401 .
57-2402 . if (A > = B)
57-2403 . {
57-2404 . A = B + C;
57-2405 . D = E + F;
57-2406 . }
57-2407 .
57-2408 . A = B+C;
57-2409 . A = B-C;
57-2410 . A = B*C;
57-2411 . A = B-C;
57-2412 .
57-2413 . if (A < = B)
57-2414 . {
57-2415 . A = B + C;
57-2416 . D = E + F;
57-2417 . }
57-2418 .
57-2419 . A = B+C;
57-2420 . // max LOC 29
57-2421 .
57-2422 . }
57-2423 .
57-2424 .
57-2425 . /*
57-2426 . -----------------------------------------------------------------------------
57-2427 . --| NAME: stp.5.14
57-2428 . --|
57-2429 . --| ABSTRACT:
57-2430 . --| This function does stp stuff.
57-2431 . --|
57-2432 . --| RETURNS:
57-2433 . --| NONE.
57-2434 . --|
57-2435 . ----------------------------------------------------------------------------
57-2436 . */
57-2437 . static void stp.5.14(void)
57-2438 . {
57-2439 . A = B+C;
57-2440 .
57-2441 . if (A lt B)
57-2442 . {
57-2443 . A = B + C;
57-2444 . D = E + F;
57-2445 . }
57-2446 .
57-2447 . A = B+C;
57-2448 . A = B-C;
57-2449 . A = B/C;
57-2450 .
57-2451 . if (A > = B)
57-2452 . {
57-2453 . A = B + C;
57-2454 . D = E + F;
57-2455 . }
57-2456 .
57-2457 .
57-2458 . if (A eq B)
57-2459 . {
57-2460 . A = B + C;
57-2461 . D = E + F;
57-2462 . }
57-2463 .
57-2464 . A = B*C;
57-2465 . A = B-C;
57-2466 . do forever;
57-2467 .
57-2468 . if (A ne B)
57-2469 . {
57-2470 . A = B + C;
57-2471 . D = E + F;
57-2472 . }
57-2473 .
57-2474 . A = B-C;
57-2475 . A = B-C;
57-2476 . A = B*C;
57-2477 . // max LOC 13
57-2478 .
57-2479 . }
57-2480 .
57 57 Result: result/source/ft-app/ft-app-B1.1/stp/stp-05.c
58 58 Source: source/ft-app/ft-app-B1.1/stp/stp-06.c
58-0 . /*
58-1 . ----------------------------------------------------------------------------
58-2 . --| BEGIN PROLOGUE
58-3 . --|
58-4 . --| CLASSIFICATION: UNCLASSIFIED
58-5 . --|
58-6 . --| FILE NAME: stp-06.c
58-7 . --|
58-8 . --| ABSTRACT:
58-9 . --| This file contains the 8 functions that do file stp stuff.
58-10 . --|
58-11 . --| HISTORY:
58-12 . --| CCCQ_NAME:
58-13 . --| CCCQ_VER:
58-14 . --|
58-15 . --| END PROLOGUE
58-16 . ----------------------------------------------------------------------------
58-17 . */
58-18 .
58-19 . #define B;
58-20 .
58-21 .
58-22 .
58-23 . /*
58-24 . -----------------------------------------------------------------------------
58-25 . --| NAME: stp.6.1
58-26 . --|
58-27 . --| ABSTRACT:
58-28 . --| This function does stp stuff.
58-29 . --|
58-30 . --| RETURNS:
58-31 . --| NONE.
58-32 . --|
58-33 . ----------------------------------------------------------------------------
58-34 . */
58-35 . static void stp.6.1(void)
58-36 . {
58-37 . A = B/C;
58-38 . A = B+C;
58-39 . A = B+C;
58-40 .
58-41 . if (A > = B)
58-42 . {
58-43 . A = B + C;
58-44 . D = E + F;
58-45 . }
58-46 .
58-47 . A = B*C;
58-48 . A = B-C;
58-49 .
58-50 . if (A != B)
58-51 . {
58-52 . A = B + C;
58-53 . D = E + F;
58-54 . }
58-55 .
58-56 . A = B-C;
58-57 . A = B-C;
58-58 . A = B-C;
58-59 . A = 0x0009;
58-60 .
58-61 . switch (stp stuff)
58-62 . {
58-63 . case one:
58-64 . {
58-65 . run_this;
58-66 . break;
58-67 . }
58-68 . case two:
58-69 . {
58-70 . run_this;
58-71 . break;
58-72 . }
58-73 . default:
58-74 . {
58-75 . SwError;
58-76 . }
58-77 . }
58-78 .
58-79 . A = B/C;
58-80 . A = B*C;
58-81 . A = B+C;
58-82 .
58-83 . if (A > B)
58-84 . {
58-85 . A = B + C;
58-86 . D = E + F;
58-87 . }
58-88 .
58-89 . A = B+C;
58-90 . A = B-C;
58-91 . /* LE SV TOC-2929 this is a stp-06.1.18 req to verify*/
58-92 .
58-93 . if (A != B)
58-94 . {
58-95 . A = B + C;
58-96 . D = E + F;
58-97 . }
58-98 .
58-99 . A = B+C;
58-100 . A = B+C;
58-101 . A = B-C;
58-102 .
58-103 . if (A eq B)
58-104 . {
58-105 . A = B + C;
58-106 . D = E + F;
58-107 . }
58-108 .
58-109 . /* LE SV TOC-2930 this is a stp-06.1.23 req to process*/
58-110 .
58-111 . if (A > = B)
58-112 . {
58-113 . A = B + C;
58-114 . D = E + F;
58-115 . }
58-116 .
58-117 . A = B*C;
58-118 . A = B+C;
58-119 . A = B+C;
58-120 .
58-121 . if (A gt B)
58-122 . {
58-123 . A = B + C;
58-124 . D = E + F;
58-125 . }
58-126 .
58-127 . A = B*C;
58-128 .
58-129 . if (A > = B)
58-130 . {
58-131 . A = B + C;
58-132 . D = E + F;
58-133 . }
58-134 .
58-135 . A = B*C;
58-136 . A = B*C;
58-137 . A = B/C;
58-138 .
58-139 . if (A > = B)
58-140 . {
58-141 . A = B + C;
58-142 . D = E + F;
58-143 . }
58-144 .
58-145 . A = B/C;
58-146 . /* LE SV TOC-2931 this is a stp-06.1.35 req to detect error*/
58-147 . A = B/C;
58-148 . /* LE SV TOC-2932 this is a stp-06.1.36 req to detect error*/
58-149 . A = B+C;
58-150 . A = B-C;
58-151 . A = B*C;
58-152 .
58-153 . if (A ge B)
58-154 . {
58-155 . A = B + C;
58-156 . D = E + F;
58-157 . }
58-158 .
58-159 . A = B+C;
58-160 . A = B-C;
58-161 .
58-162 . switch (stp stuff)
58-163 . {
58-164 . case one:
58-165 . {
58-166 . run_this;
58-167 . break;
58-168 . }
58-169 . case two:
58-170 . {
58-171 . run_this;
58-172 . break;
58-173 . }
58-174 . default:
58-175 . {
58-176 . SwError;
58-177 . }
58-178 . }
58-179 .
58-180 .
58-181 . if (A ne B)
58-182 . {
58-183 . A = B + C;
58-184 . D = E + F;
58-185 . }
58-186 .
58-187 . A = B*C;
58-188 .
58-189 . if (A > B)
58-190 . {
58-191 . A = B + C;
58-192 . D = E + F;
58-193 . }
58-194 .
58-195 . A = B-C;
58-196 .
58-197 . if (A ne B)
58-198 . {
58-199 . A = B + C;
58-200 . D = E + F;
58-201 . }
58-202 .
58-203 . A = B*C;
58-204 . A = 0x0009;
58-205 . A = B/C;
58-206 .
58-207 . if (A gt B)
58-208 . {
58-209 . A = B + C;
58-210 . D = E + F;
58-211 . }
58-212 .
58-213 . A = B+C;
58-214 .
58-215 . if (A lt B)
58-216 . {
58-217 . A = B + C;
58-218 . D = E + F;
58-219 . }
58-220 .
58-221 . A = B-C;
58-222 .
58-223 . if (A > = B)
58-224 . {
58-225 . A = B + C;
58-226 . D = E + F;
58-227 . }
58-228 .
58-229 .
58-230 . switch (stp stuff)
58-231 . {
58-232 . case one:
58-233 . {
58-234 . run_this;
58-235 . break;
58-236 . }
58-237 . case two:
58-238 . {
58-239 . run_this;
58-240 . break;
58-241 . }
58-242 . default:
58-243 . {
58-244 . SwError;
58-245 . }
58-246 . }
58-247 .
58-248 .
58-249 . if (A ne B)
58-250 . {
58-251 . A = B + C;
58-252 . D = E + F;
58-253 . }
58-254 .
58-255 .
58-256 . if (A != B)
58-257 . {
58-258 . A = B + C;
58-259 . D = E + F;
58-260 . }
58-261 .
58-262 . A = B*C;
58-263 . A = B*C;
58-264 . A = B+C;
58-265 . A = 0x0004;
58-266 .
58-267 . if (A > B)
58-268 . {
58-269 . A = B + C;
58-270 . D = E + F;
58-271 . }
58-272 .
58-273 . A = B*C;
58-274 . A = B+C;
58-275 .
58-276 . if (A gt B)
58-277 . {
58-278 . A = B + C;
58-279 . D = E + F;
58-280 . }
58-281 .
58-282 . A = B+C;
58-283 .
58-284 . switch (stp stuff)
58-285 . {
58-286 . case one:
58-287 . {
58-288 . run_this;
58-289 . break;
58-290 . }
58-291 . case two:
58-292 . {
58-293 . run_this;
58-294 . break;
58-295 . }
58-296 . default:
58-297 . {
58-298 . SwError;
58-299 . }
58-300 . }
58-301 .
58-302 . A = B+C;
58-303 . A = B/C;
58-304 . A = B/C;
58-305 .
58-306 . if (A > B)
58-307 . {
58-308 . A = B + C;
58-309 . D = E + F;
58-310 . }
58-311 .
58-312 . // max LOC 70
58-313 .
58-314 . }
58-315 .
58-316 .
58-317 . /*
58-318 . -----------------------------------------------------------------------------
58-319 . --| NAME: stp.6.2
58-320 . --|
58-321 . --| ABSTRACT:
58-322 . --| This function does stp stuff.
58-323 . --|
58-324 . --| RETURNS:
58-325 . --| NONE.
58-326 . --|
58-327 . ----------------------------------------------------------------------------
58-328 . */
58-329 . static void stp.6.2(void)
58-330 . {
58-331 .
58-332 . if (A != B)
58-333 . {
58-334 . A = B + C;
58-335 . D = E + F;
58-336 . }
58-337 .
58-338 . A = B*C;
58-339 .
58-340 . if (A != B)
58-341 . {
58-342 . A = B + C;
58-343 . D = E + F;
58-344 . }
58-345 .
58-346 . A = B+C;
58-347 .
58-348 . if (A ge B)
58-349 . {
58-350 . A = B + C;
58-351 . D = E + F;
58-352 . }
58-353 .
58-354 . A = B-C;
58-355 . A = B+C;
58-356 .
58-357 . if (A > = B)
58-358 . {
58-359 . A = B + C;
58-360 . D = E + F;
58-361 . }
58-362 .
58-363 . /* LE SV TOC-2933 this is a stp-06.2.9 req to validate*/
58-364 . A = B/C;
58-365 . A = B-C;
58-366 . A = B-C;
58-367 . /* LE SV TOC-2934 this is a stp-06.2.12 req to halt*/
58-368 . A = B-C;
58-369 . A = B+C;
58-370 . A = B/C;
58-371 .
58-372 . if (A ge B)
58-373 . {
58-374 . A = B + C;
58-375 . D = E + F;
58-376 . }
58-377 .
58-378 . A = B-C;
58-379 . A = B*C;
58-380 . A = B/C;
58-381 . A = B*C;
58-382 . A = B*C;
58-383 . A = B-C;
58-384 . A = B+C;
58-385 .
58-386 . if (A le B)
58-387 . {
58-388 . A = B + C;
58-389 . D = E + F;
58-390 . }
58-391 .
58-392 . A = 0x0009;
58-393 . A = B+C;
58-394 .
58-395 . if (A le B)
58-396 . {
58-397 . A = B + C;
58-398 . D = E + F;
58-399 . }
58-400 .
58-401 . A = B/C;
58-402 . A = B+C;
58-403 .
58-404 . /*
58-405 . dead_code = B - C;
58-406 . dead_code = D - E;
58-407 . dead_code = F - G;
58-408 . */
58-409 .
58-410 . A = B*C;
58-411 . /* LE SV TOC-2935 this is a stp-06.2.29 req to enable*/
58-412 .
58-413 . if (A < = B)
58-414 . {
58-415 . A = B + C;
58-416 . D = E + F;
58-417 . }
58-418 .
58-419 .
58-420 . if (A ge B)
58-421 . {
58-422 . A = B + C;
58-423 . D = E + F;
58-424 . }
58-425 .
58-426 .
58-427 . switch (stp stuff)
58-428 . {
58-429 . case one:
58-430 . {
58-431 . run_this;
58-432 . break;
58-433 . }
58-434 . case two:
58-435 . {
58-436 . run_this;
58-437 . break;
58-438 . }
58-439 . default:
58-440 . {
58-441 . SwError;
58-442 . }
58-443 . }
58-444 .
58-445 .
58-446 . if (A < = B)
58-447 . {
58-448 . A = B + C;
58-449 . D = E + F;
58-450 . }
58-451 .
58-452 . A = B-C;
58-453 . /* LE SV TOC-2936 this is a stp-06.2.34 req to check unix*/
58-454 . A = B*C;
58-455 . A = B*C;
58-456 . A = B-C;
58-457 . A = B*C;
58-458 . A = B*C;
58-459 . A = B*C;
58-460 . A = B*C;
58-461 . A = B+C;
58-462 . A = B/C;
58-463 . A = B-C;
58-464 . A = B/C;
58-465 .
58-466 . if (A ge B)
58-467 . {
58-468 . A = B + C;
58-469 . D = E + F;
58-470 . }
58-471 .
58-472 . A = B/C;
58-473 . /* LE SV TOC-2937 this is a stp-06.2.47 req to recover*/
58-474 . A = B*C;
58-475 . A = B-C;
58-476 . do forever;
58-477 .
58-478 . if (A ge B)
58-479 . {
58-480 . A = B + C;
58-481 . D = E + F;
58-482 . }
58-483 .
58-484 . /* LE SV TOC-2938 this is a stp-06.2.50 req to assign*/
58-485 .
58-486 . if (A ne B)
58-487 . {
58-488 . A = B + C;
58-489 . D = E + F;
58-490 . }
58-491 .
58-492 .
58-493 . if (A < = B)
58-494 . {
58-495 . A = B + C;
58-496 . D = E + F;
58-497 . }
58-498 .
58-499 . /* LE SV TOC-2939 this is a stp-06.2.52 req to check pSOS*/
58-500 . A = B-C;
58-501 . A = B+C;
58-502 .
58-503 . if (A > = B)
58-504 . {
58-505 . A = B + C;
58-506 . D = E + F;
58-507 . }
58-508 .
58-509 .
58-510 . if (A < B)
58-511 . {
58-512 . A = B + C;
58-513 . D = E + F;
58-514 . }
58-515 .
58-516 .
58-517 . if (A == B)
58-518 . {
58-519 . A = B + C;
58-520 . D = E + F;
58-521 . }
58-522 .
58-523 . A = B/C;
58-524 . A = B*C;
58-525 . A = B/C;
58-526 . A = B-C;
58-527 . // max LOC 60
58-528 .
58-529 . }
58-530 .
58-531 .
58-532 . /*
58-533 . -----------------------------------------------------------------------------
58-534 . --| NAME: stp.6.3
58-535 . --|
58-536 . --| ABSTRACT:
58-537 . --| This function does stp stuff.
58-538 . --|
58-539 . --| RETURNS:
58-540 . --| NONE.
58-541 . --|
58-542 . ----------------------------------------------------------------------------
58-543 . */
58-544 . static void stp.6.3(void)
58-545 . {
58-546 . A = B+C;
58-547 .
58-548 . if (A < = B)
58-549 . {
58-550 . A = B + C;
58-551 . D = E + F;
58-552 . }
58-553 .
58-554 .
58-555 . if (A gt B)
58-556 . {
58-557 . A = B + C;
58-558 . D = E + F;
58-559 . }
58-560 .
58-561 . A = B+C;
58-562 .
58-563 . /* dead_code = B + C;
58-564 . dead_code = D + E;
58-565 . dead_code = F + G; */
58-566 .
58-567 . A = B+C;
58-568 . A = B-C;
58-569 .
58-570 . if (A != B)
58-571 . {
58-572 . A = B + C;
58-573 . D = E + F;
58-574 . }
58-575 .
58-576 . A = B*C;
58-577 . A = B+C;
58-578 . A = B*C;
58-579 . A = B*C;
58-580 .
58-581 . if (A < = B)
58-582 . {
58-583 . A = B + C;
58-584 . D = E + F;
58-585 . }
58-586 .
58-587 . /* LE SV TOC-2940 this is a stp-06.3.13 req to disable*/
58-588 . A = B+C;
58-589 . A = B+C;
58-590 .
58-591 . if (A ne B)
58-592 . {
58-593 . A = B + C;
58-594 . D = E + F;
58-595 . }
58-596 .
58-597 .
58-598 . if (A eq B)
58-599 . {
58-600 . A = B + C;
58-601 . D = E + F;
58-602 . }
58-603 .
58-604 . A = B*C;
58-605 . A = B/C;
58-606 . A = B/C;
58-607 . A = B+C;
58-608 . A = B/C;
58-609 . A = B*C;
58-610 . A = B/C;
58-611 . A = B*C;
58-612 .
58-613 . if (A < = B)
58-614 . {
58-615 . A = B + C;
58-616 . D = E + F;
58-617 . }
58-618 .
58-619 . A = B+C;
58-620 . /* dead_code = A * B; */
58-621 . A = B+C;
58-622 . A = B/C;
58-623 . A = B-C;
58-624 .
58-625 . if (A gt B)
58-626 . {
58-627 . A = B + C;
58-628 . D = E + F;
58-629 . }
58-630 .
58-631 . A = B/C;
58-632 .
58-633 . if (A le B)
58-634 . {
58-635 . A = B + C;
58-636 . D = E + F;
58-637 . }
58-638 .
58-639 .
58-640 . if (A == B)
58-641 . {
58-642 . A = B + C;
58-643 . D = E + F;
58-644 . }
58-645 .
58-646 .
58-647 . if (A == B)
58-648 . {
58-649 . A = B + C;
58-650 . D = E + F;
58-651 . }
58-652 .
58-653 . A = B+C;
58-654 .
58-655 . if (A ge B)
58-656 . {
58-657 . A = B + C;
58-658 . D = E + F;
58-659 . }
58-660 .
58-661 . A = B*C;
58-662 . A = B*C;
58-663 . A = B/C;
58-664 . A = B+C;
58-665 . A = B*C;
58-666 .
58-667 . /* dead_code = B + C;
58-668 . dead_code = D + E;
58-669 . dead_code = F + G; */
58-670 .
58-671 . A = B-C;
58-672 . A = B/C;
58-673 . A = B*C;
58-674 .
58-675 . if (A < = B)
58-676 . {
58-677 . A = B + C;
58-678 . D = E + F;
58-679 . }
58-680 .
58-681 . free(FreePtr);
58-682 .
58-683 . if (A > B)
58-684 . {
58-685 . A = B + C;
58-686 . D = E + F;
58-687 . }
58-688 .
58-689 . /* LE SV TOC-2941 this is a stp-06.3.47 req to disable*/
58-690 . A = B*C;
58-691 . A = B-C;
58-692 . A = B-C;
58-693 . A = B-C;
58-694 . A = B-C;
58-695 .
58-696 . if (A < = B)
58-697 . {
58-698 . A = B + C;
58-699 . D = E + F;
58-700 . }
58-701 .
58-702 . /* LE SV TOC-2942 this is a stp-06.3.53 req to audit*/
58-703 .
58-704 . if {
58-705 . X = Y + Z;
58-706 . }
58-707 . else {
58-708 . halt;
58-709 . }
58-710 .
58-711 . A = B-C;
58-712 .
58-713 . if (A < B)
58-714 . {
58-715 . A = B + C;
58-716 . D = E + F;
58-717 . }
58-718 .
58-719 . A = B+C;
58-720 . A = B/C;
58-721 .
58-722 . if (A > B)
58-723 . {
58-724 . A = B + C;
58-725 . D = E + F;
58-726 . }
58-727 .
58-728 . A = B/C;
58-729 .
58-730 . if (A gt B)
58-731 . {
58-732 . A = B + C;
58-733 . D = E + F;
58-734 . }
58-735 .
58-736 .
58-737 . if (A eq B)
58-738 . {
58-739 . A = B + C;
58-740 . D = E + F;
58-741 . }
58-742 .
58-743 . A = B/C;
58-744 .
58-745 . if (A eq B)
58-746 . {
58-747 . A = B + C;
58-748 . D = E + F;
58-749 . }
58-750 .
58-751 . A = B-C;
58-752 .
58-753 . if (A eq B)
58-754 . {
58-755 . A = B + C;
58-756 . D = E + F;
58-757 . }
58-758 .
58-759 .
58-760 . if (A > = B)
58-761 . {
58-762 . A = B + C;
58-763 . D = E + F;
58-764 . }
58-765 .
58-766 .
58-767 . if (A le B)
58-768 . {
58-769 . A = B + C;
58-770 . D = E + F;
58-771 . }
58-772 .
58-773 .
58-774 . if (A eq B)
58-775 . {
58-776 . A = B + C;
58-777 . D = E + F;
58-778 . }
58-779 .
58-780 . A = B*C;
58-781 .
58-782 . if (A lt B)
58-783 . {
58-784 . A = B + C;
58-785 . D = E + F;
58-786 . }
58-787 .
58-788 . A = B*C;
58-789 .
58-790 . if (A != B)
58-791 . {
58-792 . A = B + C;
58-793 . D = E + F;
58-794 . }
58-795 .
58-796 .
58-797 . /* dead_block = C * D;
58-798 . dead_block = E * F; */
58-799 .
58-800 . A = B*C;
58-801 . A = B+C;
58-802 . A = B/C;
58-803 . A = B*C;
58-804 .
58-805 . if (A lt B)
58-806 . {
58-807 . A = B + C;
58-808 . D = E + F;
58-809 . }
58-810 .
58-811 . A = B*C;
58-812 . A = B/C;
58-813 . A = B+C;
58-814 . A = B/C;
58-815 .
58-816 . if (A > = B)
58-817 . {
58-818 . A = B + C;
58-819 . D = E + F;
58-820 . }
58-821 .
58-822 . A = 0x0006;
58-823 . A = B/C;
58-824 .
58-825 . if (A ge B)
58-826 . {
58-827 . A = B + C;
58-828 . D = E + F;
58-829 . }
58-830 .
58-831 . /* LE SV TOC-2943 this is a stp-06.3.84 req to transform*/
58-832 . A = B*C;
58-833 . A = B/C;
58-834 . A = B+C;
58-835 . A = B*C;
58-836 . A = B/C;
58-837 . A = B/C;
58-838 . A = B+C;
58-839 . A = B/C;
58-840 . A = B+C;
58-841 . A = B*C;
58-842 .
58-843 . if (A > B)
58-844 . {
58-845 . A = B + C;
58-846 . D = E + F;
58-847 . }
58-848 .
58-849 . A = B*C;
58-850 . // max LOC 95
58-851 .
58-852 . }
58-853 .
58-854 .
58-855 . /*
58-856 . -----------------------------------------------------------------------------
58-857 . --| NAME: stp.6.4
58-858 . --|
58-859 . --| ABSTRACT:
58-860 . --| This function does stp stuff.
58-861 . --|
58-862 . --| RETURNS:
58-863 . --| NONE.
58-864 . --|
58-865 . ----------------------------------------------------------------------------
58-866 . */
58-867 . static void stp.6.4(void)
58-868 . {
58-869 .
58-870 . if (A == B)
58-871 . {
58-872 . A = B + C;
58-873 . D = E + F;
58-874 . }
58-875 .
58-876 .
58-877 . if (A != B)
58-878 . {
58-879 . A = B + C;
58-880 . D = E + F;
58-881 . }
58-882 .
58-883 .
58-884 . if (A == B)
58-885 . {
58-886 . A = B + C;
58-887 . D = E + F;
58-888 . }
58-889 .
58-890 . A = B/C;
58-891 .
58-892 . if (A le B)
58-893 . {
58-894 . A = B + C;
58-895 . D = E + F;
58-896 . }
58-897 .
58-898 . A = B*C;
58-899 .
58-900 . if (A le B)
58-901 . {
58-902 . A = B + C;
58-903 . D = E + F;
58-904 . }
58-905 .
58-906 . A = B/C;
58-907 .
58-908 . if (A == B)
58-909 . {
58-910 . A = B + C;
58-911 . D = E + F;
58-912 . }
58-913 .
58-914 . A = B*C;
58-915 . A = B-C;
58-916 .
58-917 . if (A le B)
58-918 . {
58-919 . A = B + C;
58-920 . D = E + F;
58-921 . }
58-922 .
58-923 . A = B+C;
58-924 .
58-925 . if (A gt B)
58-926 . {
58-927 . A = B + C;
58-928 . D = E + F;
58-929 . }
58-930 .
58-931 . A = B-C;
58-932 . A = B/C;
58-933 . A = B*C;
58-934 . A = B+C;
58-935 . A = B-C;
58-936 .
58-937 . if (A lt B)
58-938 . {
58-939 . A = B + C;
58-940 . D = E + F;
58-941 . }
58-942 .
58-943 . A = B/C;
58-944 . A = B-C;
58-945 . A = B-C;
58-946 . A = B/C;
58-947 . A = B+C;
58-948 .
58-949 . switch (stp stuff)
58-950 . {
58-951 . case:
58-952 . case:
58-953 . // stacked case statements but only if there is a new line in between
58-954 .
58-955 . case:
58-956 . case:
58-957 . case:
58-958 . {
58-959 . run_this;
58-960 . break;
58-961 . }
58-962 . default:
58-963 . {
58-964 . halt;
58-965 . }
58-966 . }
58-967 .
58-968 . A = B+C;
58-969 . A = B/C;
58-970 . A = B/C;
58-971 . A = B*C;
58-972 .
58-973 . if (A == B)
58-974 . {
58-975 . A = B + C;
58-976 . D = E + F;
58-977 . }
58-978 .
58-979 . A = B*C;
58-980 .
58-981 . if (A ge B)
58-982 . {
58-983 . A = B + C;
58-984 . D = E + F;
58-985 . }
58-986 .
58-987 . A = B-C;
58-988 .
58-989 . switch (stp stuff)
58-990 . {
58-991 . case one:
58-992 . {
58-993 . run_this;
58-994 . break;
58-995 . }
58-996 . case two:
58-997 . {
58-998 . run_this;
58-999 . break;
58-1000 . }
58-1001 . default:
58-1002 . {
58-1003 . SwError;
58-1004 . }
58-1005 . }
58-1006 .
58-1007 . A = B+C;
58-1008 . /* LE SV TOC-2944 this is a stp-06.4.36 req to validate*/
58-1009 .
58-1010 . if (A < = B)
58-1011 . {
58-1012 . A = B + C;
58-1013 . D = E + F;
58-1014 . }
58-1015 .
58-1016 .
58-1017 . if (A < = B)
58-1018 . {
58-1019 . A = B + C;
58-1020 . D = E + F;
58-1021 . }
58-1022 .
58-1023 . A = B/C;
58-1024 .
58-1025 . if (A > B)
58-1026 . {
58-1027 . A = B + C;
58-1028 . D = E + F;
58-1029 . }
58-1030 .
58-1031 . A = B/C;
58-1032 . A = B*C;
58-1033 . A = B/C;
58-1034 . A = B*C;
58-1035 .
58-1036 . switch (stp stuff)
58-1037 . {
58-1038 . case one:
58-1039 . {
58-1040 . run_this;
58-1041 . break;
58-1042 . }
58-1043 . case two:
58-1044 . {
58-1045 . run_this;
58-1046 . break;
58-1047 . }
58-1048 . default:
58-1049 . {
58-1050 . SwError;
58-1051 . }
58-1052 . }
58-1053 .
58-1054 . A = B-C;
58-1055 . A = B*C;
58-1056 .
58-1057 . if (A gt B)
58-1058 . {
58-1059 . A = B + C;
58-1060 . D = E + F;
58-1061 . }
58-1062 .
58-1063 .
58-1064 . if (A > B)
58-1065 . {
58-1066 . A = B + C;
58-1067 . D = E + F;
58-1068 . }
58-1069 .
58-1070 . A = B/C;
58-1071 .
58-1072 . if {
58-1073 . X = Y + Z;
58-1074 . }
58-1075 . else {
58-1076 . halt;
58-1077 . }
58-1078 .
58-1079 . A = B*C;
58-1080 .
58-1081 . if (A == B)
58-1082 . {
58-1083 . A = B + C;
58-1084 . D = E + F;
58-1085 . }
58-1086 .
58-1087 . A = B+C;
58-1088 . A = B/C;
58-1089 . A = B+C;
58-1090 . A = B+C;
58-1091 . A = B-C;
58-1092 . A = B-C;
58-1093 .
58-1094 . /* dead_code = B + C;
58-1095 . dead_code = D + E;
58-1096 . dead_code = F + G; */
58-1097 .
58-1098 . A = B/C;
58-1099 . A = B-C;
58-1100 . A = B/C;
58-1101 . A = B/C;
58-1102 .
58-1103 . if (A < B)
58-1104 . {
58-1105 . A = B + C;
58-1106 . D = E + F;
58-1107 . }
58-1108 .
58-1109 .
58-1110 . if (A eq B)
58-1111 . {
58-1112 . A = B + C;
58-1113 . D = E + F;
58-1114 . }
58-1115 .
58-1116 . A = B*C;
58-1117 . A = B-C;
58-1118 .
58-1119 . if (A != B)
58-1120 . {
58-1121 . A = B + C;
58-1122 . D = E + F;
58-1123 . }
58-1124 .
58-1125 .
58-1126 . if (A lt B)
58-1127 . {
58-1128 . A = B + C;
58-1129 . D = E + F;
58-1130 . }
58-1131 .
58-1132 . A = B*C;
58-1133 . A = B-C;
58-1134 .
58-1135 . if (A ne B)
58-1136 . {
58-1137 . A = B + C;
58-1138 . D = E + F;
58-1139 . }
58-1140 .
58-1141 . A = B/C;
58-1142 . // max LOC 71
58-1143 .
58-1144 . }
58-1145 .
58-1146 .
58-1147 . /*
58-1148 . -----------------------------------------------------------------------------
58-1149 . --| NAME: stp.6.5
58-1150 . --|
58-1151 . --| ABSTRACT:
58-1152 . --| This function does stp stuff.
58-1153 . --|
58-1154 . --| RETURNS:
58-1155 . --| NONE.
58-1156 . --|
58-1157 . ----------------------------------------------------------------------------
58-1158 . */
58-1159 . static void stp.6.5(void)
58-1160 . {
58-1161 .
58-1162 . if (A > B)
58-1163 . {
58-1164 . A = B + C;
58-1165 . D = E + F;
58-1166 . }
58-1167 .
58-1168 .
58-1169 . if (A eq B)
58-1170 . {
58-1171 . A = B + C;
58-1172 . D = E + F;
58-1173 . }
58-1174 .
58-1175 .
58-1176 . if (A != B)
58-1177 . {
58-1178 . A = B + C;
58-1179 . D = E + F;
58-1180 . }
58-1181 .
58-1182 . A = B+C;
58-1183 . A = B*C;
58-1184 .
58-1185 . if (A < = B)
58-1186 . {
58-1187 . A = B + C;
58-1188 . D = E + F;
58-1189 . }
58-1190 .
58-1191 .
58-1192 . if (A lt B)
58-1193 . {
58-1194 . A = B + C;
58-1195 . D = E + F;
58-1196 . }
58-1197 .
58-1198 . A = B*C;
58-1199 .
58-1200 . if (A < B)
58-1201 . {
58-1202 . A = B + C;
58-1203 . D = E + F;
58-1204 . }
58-1205 .
58-1206 . A = B*C;
58-1207 . send_buffer = (U16 *) malloc(size+1);
58-1208 .
58-1209 . if (A le B)
58-1210 . {
58-1211 . A = B + C;
58-1212 . D = E + F;
58-1213 . }
58-1214 .
58-1215 . // max LOC 11
58-1216 .
58-1217 . }
58-1218 .
58-1219 .
58-1220 . /*
58-1221 . -----------------------------------------------------------------------------
58-1222 . --| NAME: stp.6.6
58-1223 . --|
58-1224 . --| ABSTRACT:
58-1225 . --| This function does stp stuff.
58-1226 . --|
58-1227 . --| RETURNS:
58-1228 . --| NONE.
58-1229 . --|
58-1230 . ----------------------------------------------------------------------------
58-1231 . */
58-1232 . static void stp.6.6(void)
58-1233 . {
58-1234 . A = B*C;
58-1235 . A = B-C;
58-1236 .
58-1237 . if (A > B)
58-1238 . {
58-1239 . A = B + C;
58-1240 . D = E + F;
58-1241 . }
58-1242 .
58-1243 . A = B/C;
58-1244 . A = B-C;
58-1245 .
58-1246 . if (A != B)
58-1247 . {
58-1248 . A = B + C;
58-1249 . D = E + F;
58-1250 . }
58-1251 .
58-1252 . A = B*C;
58-1253 . A = B/C;
58-1254 .
58-1255 . switch (stp stuff)
58-1256 . {
58-1257 . case one:
58-1258 . {
58-1259 . run_this;
58-1260 . // missing break
58-1261 . }
58-1262 . case two:
58-1263 . {
58-1264 . run_this;
58-1265 . break;
58-1266 . }
58-1267 . default:
58-1268 . {
58-1269 . SwError;
58-1270 . }
58-1271 . }
58-1272 .
58-1273 . A = B*C;
58-1274 . /* LE SV TOC-2945 this is a stp-06.6.10 req to check pSOS*/
58-1275 . A = B*C;
58-1276 .
58-1277 . if (A eq B)
58-1278 . {
58-1279 . A = B + C;
58-1280 . D = E + F;
58-1281 . }
58-1282 .
58-1283 . A = B*C;
58-1284 . A = B*C;
58-1285 . A = B+C;
58-1286 . A = B*C;
58-1287 . A = B/C;
58-1288 . /* LE SV TOC-2946 this is a stp-06.6.17 req to enable*/
58-1289 . A = 0x0007;
58-1290 .
58-1291 . if (A eq B)
58-1292 . {
58-1293 . A = B + C;
58-1294 . D = E + F;
58-1295 . }
58-1296 .
58-1297 .
58-1298 . /*
58-1299 . dead_block = C * D;
58-1300 . dead_block = E * F;
58-1301 . */
58-1302 .
58-1303 . A = B-C;
58-1304 . A = B/C;
58-1305 .
58-1306 . if (A != B)
58-1307 . {
58-1308 . A = B + C;
58-1309 . D = E + F;
58-1310 . }
58-1311 .
58-1312 . A = B/C;
58-1313 .
58-1314 . if (A > = B)
58-1315 . {
58-1316 . A = B + C;
58-1317 . D = E + F;
58-1318 . }
58-1319 .
58-1320 . A = B*C;
58-1321 . A = B*C;
58-1322 . A = B+C;
58-1323 . A = B-C;
58-1324 . A = B-C;
58-1325 .
58-1326 . if (A < B)
58-1327 . {
58-1328 . A = B + C;
58-1329 . D = E + F;
58-1330 . }
58-1331 .
58-1332 . A = B-C;
58-1333 . A = B-C;
58-1334 . A = B-C;
58-1335 .
58-1336 . if (A gt B)
58-1337 . {
58-1338 . A = B + C;
58-1339 . D = E + F;
58-1340 . }
58-1341 .
58-1342 .
58-1343 . if (A gt B)
58-1344 . {
58-1345 . A = B + C;
58-1346 . D = E + F;
58-1347 . }
58-1348 .
58-1349 .
58-1350 . switch (stp stuff)
58-1351 . {
58-1352 . case one:
58-1353 . {
58-1354 . run_this;
58-1355 . break;
58-1356 . }
58-1357 . case two:
58-1358 . {
58-1359 . run_this;
58-1360 . break;
58-1361 . }
58-1362 . default:
58-1363 . {
58-1364 . SwError;
58-1365 . }
58-1366 . }
58-1367 .
58-1368 . A = B/C;
58-1369 . A = B-C;
58-1370 .
58-1371 . if (A le B)
58-1372 . {
58-1373 . A = B + C;
58-1374 . D = E + F;
58-1375 . }
58-1376 .
58-1377 . A = B*C;
58-1378 . // max LOC 38
58-1379 .
58-1380 . }
58-1381 .
58-1382 .
58-1383 . /*
58-1384 . -----------------------------------------------------------------------------
58-1385 . --| NAME: stp.6.7
58-1386 . --|
58-1387 . --| ABSTRACT:
58-1388 . --| This function does stp stuff.
58-1389 . --|
58-1390 . --| RETURNS:
58-1391 . --| NONE.
58-1392 . --|
58-1393 . ----------------------------------------------------------------------------
58-1394 . */
58-1395 . static void stp.6.7(void)
58-1396 . {
58-1397 . A = B*C;
58-1398 . A = B/C;
58-1399 . A = B+C;
58-1400 .
58-1401 . if (A < = B)
58-1402 . {
58-1403 . A = B + C;
58-1404 . D = E + F;
58-1405 . }
58-1406 .
58-1407 .
58-1408 . if (veg)
58-1409 . // missing curly brace
58-1410 . variable = orange;
58-1411 .
58-1412 . A = B-C;
58-1413 . A = B/C;
58-1414 . A = B+C;
58-1415 . A = B*C;
58-1416 .
58-1417 . if (A > = B)
58-1418 . {
58-1419 . A = B + C;
58-1420 . D = E + F;
58-1421 . }
58-1422 .
58-1423 . A = B+C;
58-1424 . A = B+C;
58-1425 . A = B+C;
58-1426 . A = B/C;
58-1427 . A = B-C;
58-1428 .
58-1429 . if (A < = B)
58-1430 . {
58-1431 . A = B + C;
58-1432 . D = E + F;
58-1433 . }
58-1434 .
58-1435 . A = B/C;
58-1436 . A = B+C;
58-1437 . // (P) this is really improtant
58-1438 . A = B+C;
58-1439 . A = B*C;
58-1440 . A = B+C;
58-1441 .
58-1442 . if (A eq B)
58-1443 . {
58-1444 . A = B + C;
58-1445 . D = E + F;
58-1446 . }
58-1447 .
58-1448 . A = B+C;
58-1449 . A = B/C;
58-1450 . A = B+C;
58-1451 . A = B/C;
58-1452 . A = B*C;
58-1453 . A = B*C;
58-1454 .
58-1455 . if (A ge B)
58-1456 . {
58-1457 . A = B + C;
58-1458 . D = E + F;
58-1459 . }
58-1460 .
58-1461 . A = B/C;
58-1462 .
58-1463 . if (A gt B)
58-1464 . {
58-1465 . A = B + C;
58-1466 . D = E + F;
58-1467 . }
58-1468 .
58-1469 . A = B+C;
58-1470 . FreePtr = HmiStringPtr;
58-1471 . A = B*C;
58-1472 .
58-1473 . if (A eq B)
58-1474 . {
58-1475 . A = B + C;
58-1476 . D = E + F;
58-1477 . }
58-1478 .
58-1479 .
58-1480 . if (A < B)
58-1481 . {
58-1482 . A = B + C;
58-1483 . D = E + F;
58-1484 . }
58-1485 .
58-1486 . /* LE SV TOC-2947 this is a stp-06.7.35 req to increment*/
58-1487 . A = 0x0003;
58-1488 .
58-1489 . switch (stp stuff)
58-1490 . {
58-1491 . case one:
58-1492 . {
58-1493 . run_this;
58-1494 . break;
58-1495 . }
58-1496 . case two:
58-1497 . {
58-1498 . run_this;
58-1499 . break;
58-1500 . }
58-1501 . default:
58-1502 . {
58-1503 . SwError;
58-1504 . }
58-1505 . }
58-1506 .
58-1507 .
58-1508 . if (A > = B)
58-1509 . {
58-1510 . A = B + C;
58-1511 . D = E + F;
58-1512 . }
58-1513 .
58-1514 . A = B+C;
58-1515 .
58-1516 . if (A ge B)
58-1517 . {
58-1518 . A = B + C;
58-1519 . D = E + F;
58-1520 . }
58-1521 .
58-1522 .
58-1523 . if (A le B)
58-1524 . {
58-1525 . A = B + C;
58-1526 . D = E + F;
58-1527 . }
58-1528 .
58-1529 .
58-1530 . if (A == B)
58-1531 . {
58-1532 . A = B + C;
58-1533 . D = E + F;
58-1534 . }
58-1535 .
58-1536 . A = B*C;
58-1537 . /* LE SV TOC-2948 this is a stp-06.7.42 req to reject*/
58-1538 . A = B+C;
58-1539 . A = B+C;
58-1540 . A = B*C;
58-1541 . A = B-C;
58-1542 . A = B*C;
58-1543 . A = B/C;
58-1544 . A = B+C;
58-1545 . A = B*C;
58-1546 . // max LOC 49
58-1547 .
58-1548 . }
58-1549 .
58-1550 .
58-1551 . /*
58-1552 . -----------------------------------------------------------------------------
58-1553 . --| NAME: stp.6.8
58-1554 . --|
58-1555 . --| ABSTRACT:
58-1556 . --| This function does stp stuff.
58-1557 . --|
58-1558 . --| RETURNS:
58-1559 . --| NONE.
58-1560 . --|
58-1561 . ----------------------------------------------------------------------------
58-1562 . */
58-1563 . static void stp.6.8(void)
58-1564 . {
58-1565 . A = B+C;
58-1566 . A = B-C;
58-1567 .
58-1568 . if (A < = B)
58-1569 . {
58-1570 . A = B + C;
58-1571 . D = E + F;
58-1572 . }
58-1573 .
58-1574 . A = B/C;
58-1575 . A = B-C;
58-1576 .
58-1577 . switch (stp stuff)
58-1578 . {
58-1579 . case one:
58-1580 . {
58-1581 . run_this;
58-1582 . break;
58-1583 . }
58-1584 . case two:
58-1585 . {
58-1586 . run_this;
58-1587 . break;
58-1588 . }
58-1589 . default:
58-1590 . {
58-1591 . // missing error call
58-1592 . }
58-1593 . }
58-1594 .
58-1595 . A = B-C;
58-1596 . /* LE SV TOC-2949 this is a stp-06.8.7 req to fail*/
58-1597 .
58-1598 . if (A le B)
58-1599 . {
58-1600 . A = B + C;
58-1601 . D = E + F;
58-1602 . }
58-1603 .
58-1604 . A = B-C;
58-1605 . /* LE SV TOC-2950 this is a stp-06.8.9 req to assign*/
58-1606 .
58-1607 . if (A eq B)
58-1608 . {
58-1609 . A = B + C;
58-1610 . D = E + F;
58-1611 . }
58-1612 .
58-1613 . A = B/C;
58-1614 . A = B+C;
58-1615 . // max LOC 11
58-1616 .
58-1617 . }
58-1618 .
58 58 Result: result/source/ft-app/ft-app-B1.1/stp/stp-06.c
59 59 Source: source/ft-app/ft-app-B1.1/wxp/wxp-01.c
59-0 . /*
59-1 . ----------------------------------------------------------------------------
59-2 . --| BEGIN PROLOGUE
59-3 . --|
59-4 . --| CLASSIFICATION: UNCLASSIFIED
59-5 . --|
59-6 . --| FILE NAME: wxp-01.c
59-7 . --|
59-8 . --| ABSTRACT:
59-9 . --| This file contains the 10 functions that do file wxp stuff.
59-10 . --|
59-11 . --| HISTORY:
59-12 . --| CCCQ_NAME:
59-13 . --| CCCQ_VER:
59-14 . --|
59-15 . --| END PROLOGUE
59-16 . ----------------------------------------------------------------------------
59-17 . */
59-18 .
59-19 . char D;
59-20 . char D;
59-21 . #define B;
59-22 .
59-23 .
59-24 .
59-25 . /*
59-26 . -----------------------------------------------------------------------------
59-27 . --| NAME: wxp.1.1
59-28 . --|
59-29 . --| ABSTRACT:
59-30 . --| This function does wxp stuff.
59-31 . --|
59-32 . --| RETURNS:
59-33 . --| NONE.
59-34 . --|
59-35 . ----------------------------------------------------------------------------
59-36 . */
59-37 . static void wxp.1.1(void)
59-38 . {
59-39 . A = B-C;
59-40 . A = B/C;
59-41 . A = B+C;
59-42 . /* LE SV TOC-3001 this is a wxp-01.1.4 req to verify*/
59-43 . A = B+C;
59-44 . /* LE SV TOC-3002 this is a wxp-01.1.5 req to set RTC*/
59-45 . A = B+C;
59-46 .
59-47 . if (A le B)
59-48 . {
59-49 . A = B + C;
59-50 . D = E + F;
59-51 . }
59-52 .
59-53 .
59-54 . if (A ge B)
59-55 . {
59-56 . A = B + C;
59-57 . D = E + F;
59-58 . }
59-59 .
59-60 . A = B-C;
59-61 .
59-62 . if (A > = B)
59-63 . {
59-64 . A = B + C;
59-65 . D = E + F;
59-66 . }
59-67 .
59-68 . A = B-C;
59-69 . A = B/C;
59-70 .
59-71 . if (A lt B)
59-72 . {
59-73 . A = B + C;
59-74 . D = E + F;
59-75 . }
59-76 .
59-77 . A = B/C;
59-78 . A = B*C;
59-79 . A = B-C;
59-80 . A = B/C;
59-81 . A = B/C;
59-82 . A = B+C;
59-83 .
59-84 . if (A == B)
59-85 . {
59-86 . A = B + C;
59-87 . D = E + F;
59-88 . }
59-89 .
59-90 . A = B/C;
59-91 . A = B/C;
59-92 . A = B+C;
59-93 .
59-94 . if (A < = B)
59-95 . {
59-96 . A = B + C;
59-97 . D = E + F;
59-98 . }
59-99 .
59-100 . A = B-C;
59-101 . A = B+C;
59-102 . A = B-C;
59-103 .
59-104 . switch (wxp stuff)
59-105 . {
59-106 . case one:
59-107 . {
59-108 . switch (nested)
59-109 . {
59-110 . case:
59-111 . X = Y + Z;
59-112 . case:
59-113 . X = Y + Z;
59-114 . default:
59-115 . SwError;
59-116 . }
59-117 . }
59-118 . case two:
59-119 . {
59-120 . run_this;
59-121 . break;
59-122 . }
59-123 . default:
59-124 . {
59-125 . SwError;
59-126 . }
59-127 . }
59-128 .
59-129 . A = B-C;
59-130 . A = B*C;
59-131 .
59-132 . if (A gt B)
59-133 . {
59-134 . A = B + C;
59-135 . D = E + F;
59-136 . }
59-137 .
59-138 . A = B-C;
59-139 .
59-140 . if (A ne B)
59-141 . {
59-142 . A = B + C;
59-143 . D = E + F;
59-144 . }
59-145 .
59-146 . A = B/C;
59-147 .
59-148 . if (A < B)
59-149 . {
59-150 . A = B + C;
59-151 . D = E + F;
59-152 . }
59-153 .
59-154 .
59-155 . switch (wxp stuff)
59-156 . {
59-157 . case one:
59-158 . {
59-159 . run_this;
59-160 . break;
59-161 . }
59-162 . case two:
59-163 . {
59-164 . run_this;
59-165 . break;
59-166 . }
59-167 . default:
59-168 . {
59-169 . SwError;
59-170 . }
59-171 . }
59-172 .
59-173 . A = B*C;
59-174 . A = B-C;
59-175 . /* LE SV TOC-3003 this is a wxp-01.1.37 req to store*/
59-176 . A = B-C;
59-177 .
59-178 . if (A == B)
59-179 . {
59-180 . A = B + C;
59-181 . D = E + F;
59-182 . }
59-183 .
59-184 . A = B/C;
59-185 . A = B-C;
59-186 .
59-187 . if (A le B)
59-188 . {
59-189 . A = B + C;
59-190 . D = E + F;
59-191 . }
59-192 .
59-193 . A = B-C;
59-194 . A = B/C;
59-195 .
59-196 . if (A eq B)
59-197 . {
59-198 . A = B + C;
59-199 . D = E + F;
59-200 . }
59-201 .
59-202 . A = B*C;
59-203 .
59-204 . switch (wxp stuff)
59-205 . {
59-206 . case one:
59-207 . {
59-208 . run_this;
59-209 . break;
59-210 . }
59-211 . case two:
59-212 . {
59-213 . run_this;
59-214 . break;
59-215 . }
59-216 . default:
59-217 . {
59-218 . SwError;
59-219 . }
59-220 . }
59-221 .
59-222 . /* LE SV TOC-3004 this is a wxp-01.1.47 req to detect error*/
59-223 . A = B/C;
59-224 . A = B+C;
59-225 . // max LOC 48
59-226 .
59-227 . }
59-228 .
59-229 .
59-230 . /*
59-231 . -----------------------------------------------------------------------------
59-232 . --| NAME: wxp.1.2
59-233 . --|
59-234 . --| ABSTRACT:
59-235 . --| This function does wxp stuff.
59-236 . --|
59-237 . --| RETURNS:
59-238 . --| NONE.
59-239 . --|
59-240 . ----------------------------------------------------------------------------
59-241 . */
59-242 . static void wxp.1.2(void)
59-243 . {
59-244 . A = B-C;
59-245 . A = B-C;
59-246 . A = B+C;
59-247 . A = B+C;
59-248 . A = B*C;
59-249 . A = B-C;
59-250 . A = B-C;
59-251 . A = B-C;
59-252 . A = B-C;
59-253 . /* LE SV TOC-3005 this is a wxp-01.2.10 req to assign*/
59-254 . A = B/C;
59-255 . A = B-C;
59-256 . A = B-C;
59-257 .
59-258 . if (A eq B)
59-259 . {
59-260 . A = B + C;
59-261 . D = E + F;
59-262 . }
59-263 .
59-264 . A = B-C;
59-265 . A = B+C;
59-266 . A = B*C;
59-267 .
59-268 . if (A < = B)
59-269 . {
59-270 . A = B + C;
59-271 . D = E + F;
59-272 . }
59-273 .
59-274 . A = B/C;
59-275 . A = B-C;
59-276 . A = B*C;
59-277 . A = 0x0008;
59-278 .
59-279 . if (A > = B)
59-280 . {
59-281 . A = B + C;
59-282 . D = E + F;
59-283 . }
59-284 .
59-285 . goto error;
59-286 . A = B*C;
59-287 . /* LE SV TOC-3006 this is a wxp-01.2.23 req to inhibit*/
59-288 . A = B-C;
59-289 . A = B*C;
59-290 . A = B+C;
59-291 . /* LE SV TOC-3007 this is a wxp-01.2.26 req to disable*/
59-292 .
59-293 . if (A le B)
59-294 . {
59-295 . A = B + C;
59-296 . D = E + F;
59-297 . }
59-298 .
59-299 . A = B/C;
59-300 . A = B-C;
59-301 . A = B*C;
59-302 .
59-303 . if (A eq B)
59-304 . {
59-305 . A = B + C;
59-306 . D = E + F;
59-307 . }
59-308 .
59-309 . A = B+C;
59-310 .
59-311 . if (A lt B)
59-312 . {
59-313 . A = B + C;
59-314 . D = E + F;
59-315 . }
59-316 .
59-317 .
59-318 . if (A < B)
59-319 . {
59-320 . A = B + C;
59-321 . D = E + F;
59-322 . }
59-323 .
59-324 .
59-325 . if (A le B)
59-326 . {
59-327 . A = B + C;
59-328 . D = E + F;
59-329 . }
59-330 .
59-331 .
59-332 . if (A != B)
59-333 . {
59-334 . A = B + C;
59-335 . D = E + F;
59-336 . }
59-337 .
59-338 . A = B+C;
59-339 . A = B/C;
59-340 . A = B-C;
59-341 . A = B-C;
59-342 .
59-343 . if (A == B)
59-344 . {
59-345 . A = B + C;
59-346 . D = E + F;
59-347 . }
59-348 .
59-349 .
59-350 . /* dead_block = C * D;
59-351 . dead_block = E * F; */
59-352 .
59-353 . A = B/C;
59-354 . A = B/C;
59-355 .
59-356 . if (A eq B)
59-357 . {
59-358 . A = B + C;
59-359 . D = E + F;
59-360 . }
59-361 .
59-362 . A = B-C;
59-363 . A = B*C;
59-364 .
59-365 . if (A eq B)
59-366 . {
59-367 . A = B + C;
59-368 . D = E + F;
59-369 . }
59-370 .
59-371 . A = B+C;
59-372 .
59-373 . if (A < = B)
59-374 . {
59-375 . A = B + C;
59-376 . D = E + F;
59-377 . }
59-378 .
59-379 . A = B-C;
59-380 .
59-381 . if (A > B)
59-382 . {
59-383 . A = B + C;
59-384 . D = E + F;
59-385 . }
59-386 .
59-387 . A = B-C;
59-388 . A = B+C;
59-389 .
59-390 . if (A == B)
59-391 . {
59-392 . A = B + C;
59-393 . D = E + F;
59-394 . }
59-395 .
59-396 . A = B/C;
59-397 . A = B*C;
59-398 .
59-399 . if (A < = B)
59-400 . {
59-401 . A = B + C;
59-402 . D = E + F;
59-403 . }
59-404 .
59-405 .
59-406 . if (A le B)
59-407 . {
59-408 . A = B + C;
59-409 . D = E + F;
59-410 . }
59-411 .
59-412 . A = B+C;
59-413 . A = B+C;
59-414 . A = B*C;
59-415 . A = B/C;
59-416 .
59-417 . if (A == B)
59-418 . {
59-419 . A = B + C;
59-420 . D = E + F;
59-421 . }
59-422 .
59-423 .
59-424 . if (A gt B)
59-425 . {
59-426 . A = B + C;
59-427 . D = E + F;
59-428 . }
59-429 .
59-430 .
59-431 . if (A != B)
59-432 . {
59-433 . A = B + C;
59-434 . D = E + F;
59-435 . }
59-436 .
59-437 . A = B+C;
59-438 . A = B/C;
59-439 . A = B*C;
59-440 . // TBD - what do I do now
59-441 .
59-442 . if (A > B)
59-443 . {
59-444 . A = B + C;
59-445 . D = E + F;
59-446 . }
59-447 .
59-448 . A = B*C;
59-449 . A = B-C;
59-450 . rcv_buffer = (U16 *) alloc(size+1);
59-451 .
59-452 . if (A > B)
59-453 . {
59-454 . A = B + C;
59-455 . D = E + F;
59-456 . }
59-457 .
59-458 .
59-459 . if (A > = B)
59-460 . {
59-461 . A = B + C;
59-462 . D = E + F;
59-463 . }
59-464 .
59-465 .
59-466 . if (A == B)
59-467 . {
59-468 . A = B + C;
59-469 . D = E + F;
59-470 . }
59-471 .
59-472 .
59-473 . if (A > B)
59-474 . {
59-475 . A = B + C;
59-476 . D = E + F;
59-477 . }
59-478 .
59-479 . /* LE SV TOC-3008 this is a wxp-01.2.75 req to convert*/
59-480 . A = B/C;
59-481 . /* LE SV TOC-3009 this is a wxp-01.2.76 req to fail*/
59-482 . A = B*C;
59-483 .
59-484 . if (A ge B)
59-485 . {
59-486 . A = B + C;
59-487 . D = E + F;
59-488 . }
59-489 .
59-490 . A = B/C;
59-491 . A = B/C;
59-492 . A = B*C;
59-493 .
59-494 . if (A > B)
59-495 . {
59-496 . A = B + C;
59-497 . D = E + F;
59-498 . }
59-499 .
59-500 . A = B-C;
59-501 . A = B-C;
59-502 . A = B-C;
59-503 . // max LOC 84
59-504 .
59-505 . }
59-506 .
59-507 .
59-508 . /*
59-509 . -----------------------------------------------------------------------------
59-510 . --| NAME: wxp.1.3
59-511 . --|
59-512 . --| ABSTRACT:
59-513 . --| This function does wxp stuff.
59-514 . --|
59-515 . --| RETURNS:
59-516 . --| NONE.
59-517 . --|
59-518 . ----------------------------------------------------------------------------
59-519 . */
59-520 . static void wxp.1.3(void)
59-521 . {
59-522 . A = B*C;
59-523 .
59-524 . if (A != B)
59-525 . {
59-526 . A = B + C;
59-527 . D = E + F;
59-528 . }
59-529 .
59-530 . A = B/C;
59-531 . A = B-C;
59-532 .
59-533 . if (A ne B)
59-534 . {
59-535 . A = B + C;
59-536 . D = E + F;
59-537 . }
59-538 .
59-539 . /* LE SV TOC-3010 this is a wxp-01.3.6 req to inhibit*/
59-540 .
59-541 . if (A > B)
59-542 . {
59-543 . A = B + C;
59-544 . D = E + F;
59-545 . }
59-546 .
59-547 . A = B*C;
59-548 . A = B+C;
59-549 .
59-550 . if (A lt B)
59-551 . {
59-552 . A = B + C;
59-553 . D = E + F;
59-554 . }
59-555 .
59-556 . A = B/C;
59-557 . A = B-C;
59-558 .
59-559 . if (A == B)
59-560 . {
59-561 . A = B + C;
59-562 . D = E + F;
59-563 . }
59-564 .
59-565 . A = B+C;
59-566 . A = (float)B + C;
59-567 .
59-568 . if (A > B)
59-569 . {
59-570 . A = B + C;
59-571 . D = E + F;
59-572 . }
59-573 .
59-574 .
59-575 . switch (wxp stuff)
59-576 . {
59-577 . case one:
59-578 . {
59-579 . run_this;
59-580 . break;
59-581 . }
59-582 . case two:
59-583 . {
59-584 . run_this;
59-585 . break;
59-586 . }
59-587 . default:
59-588 . {
59-589 . SwError;
59-590 . }
59-591 . }
59-592 .
59-593 . A = B-C;
59-594 .
59-595 . /*
59-596 . dead_block = C * D;
59-597 . dead_block = E * F;
59-598 . */
59-599 .
59-600 . A = B/C;
59-601 .
59-602 . switch (wxp stuff)
59-603 . {
59-604 . case one:
59-605 . {
59-606 . run_this;
59-607 . break;
59-608 . }
59-609 . case two:
59-610 . {
59-611 . run_this;
59-612 . break;
59-613 . }
59-614 . default:
59-615 . {
59-616 . SwError;
59-617 . }
59-618 . }
59-619 .
59-620 . A = B/C;
59-621 . A = B+C;
59-622 . A = B*C;
59-623 . A = B*C;
59-624 . A = 0x0001;
59-625 . A = B*C;
59-626 . A = B/C;
59-627 . A = B/C;
59-628 . A = B/C;
59-629 . /* LE SV TOC-3011 this is a wxp-01.3.27 req to detect error*/
59-630 . A = B/C;
59-631 . A = B-C;
59-632 . A = B-C;
59-633 . A = B+C;
59-634 . A = B*C;
59-635 .
59-636 . if (A le B)
59-637 . {
59-638 . A = B + C;
59-639 . D = E + F;
59-640 . }
59-641 .
59-642 . /* LE SV TOC-3012 this is a wxp-01.3.33 req to check unix*/
59-643 .
59-644 . if (A eq B)
59-645 . {
59-646 . A = B + C;
59-647 . D = E + F;
59-648 . }
59-649 .
59-650 . /* LE SV TOC-3013 this is a wxp-01.3.34 req to reject*/
59-651 . A = B/C;
59-652 .
59-653 . if (A == B)
59-654 . {
59-655 . A = B + C;
59-656 . D = E + F;
59-657 . }
59-658 .
59-659 . A = B/C;
59-660 . A = B-C;
59-661 . A = B*C;
59-662 .
59-663 . if (A != B)
59-664 . {
59-665 . A = B + C;
59-666 . D = E + F;
59-667 . }
59-668 .
59-669 . A = 0x0006;
59-670 . A = B+C;
59-671 . A = B/C;
59-672 . A = B+C;
59-673 . // TBS - I need to figure this out
59-674 . A = B/C;
59-675 .
59-676 . if (A < B)
59-677 . {
59-678 . A = B + C;
59-679 . D = E + F;
59-680 . }
59-681 .
59-682 . A = B/C;
59-683 . A = B-C;
59-684 . A = B/C;
59-685 . A = B/C;
59-686 .
59-687 . if (A == B)
59-688 . {
59-689 . A = B + C;
59-690 . D = E + F;
59-691 . }
59-692 .
59-693 . // max LOC 49
59-694 .
59-695 . }
59-696 .
59-697 .
59-698 . /*
59-699 . -----------------------------------------------------------------------------
59-700 . --| NAME: wxp.1.4
59-701 . --|
59-702 . --| ABSTRACT:
59-703 . --| This function does wxp stuff.
59-704 . --|
59-705 . --| RETURNS:
59-706 . --| NONE.
59-707 . --|
59-708 . ----------------------------------------------------------------------------
59-709 . */
59-710 . static void wxp.1.4(void)
59-711 . {
59-712 . /* LE SV TOC-3014 this is a wxp-01.4.1 req to disable*/
59-713 .
59-714 . if (A > = B)
59-715 . {
59-716 . A = B + C;
59-717 . D = E + F;
59-718 . }
59-719 .
59-720 . A = B/C;
59-721 . A = B*C;
59-722 . A = 0x0004;
59-723 . A = B+C;
59-724 . A = 0x0008;
59-725 . A = B-C;
59-726 . A = B-C;
59-727 .
59-728 . if (A > = B)
59-729 . {
59-730 . A = B + C;
59-731 . D = E + F;
59-732 . }
59-733 .
59-734 . A = B/C;
59-735 . A = B-C;
59-736 . A = B-C;
59-737 . A = B-C;
59-738 . A = 0x0008;
59-739 . A = B+C;
59-740 . A = B-C;
59-741 . A = B*C;
59-742 . send_buffer = (U16 *) malloc(size+1);
59-743 . A = B+C;
59-744 .
59-745 . if (A > = B)
59-746 . {
59-747 . A = B + C;
59-748 . D = E + F;
59-749 . }
59-750 .
59-751 . A = B-C;
59-752 . A = B*C;
59-753 . A = B*C;
59-754 . A = B+C;
59-755 . /* LE SV TOC-3015 this is a wxp-01.4.21 req to halt*/
59-756 . A = B-C;
59-757 . A = B*C;
59-758 . // (P) this is really improtant
59-759 .
59-760 . if (A == B)
59-761 . {
59-762 . A = B + C;
59-763 . D = E + F;
59-764 . }
59-765 .
59-766 . A = B/C;
59-767 . A = B+C;
59-768 . A = B-C;
59-769 .
59-770 . if (A > B)
59-771 . {
59-772 . A = B + C;
59-773 . D = E + F;
59-774 . }
59-775 .
59-776 .
59-777 . if (A > B)
59-778 . {
59-779 . A = B + C;
59-780 . D = E + F;
59-781 . }
59-782 .
59-783 . A = B/C;
59-784 . A = B/C;
59-785 . A = B-C;
59-786 . A = B+C;
59-787 . A = B+C;
59-788 . A = B-C;
59-789 . A = B/C;
59-790 .
59-791 . switch (wxp stuff)
59-792 . {
59-793 . case one:
59-794 . {
59-795 . run_this;
59-796 . break;
59-797 . }
59-798 . case two:
59-799 . {
59-800 . run_this;
59-801 . break;
59-802 . }
59-803 . // missing default
59-804 . }
59-805 .
59-806 .
59-807 . if (A lt B)
59-808 . {
59-809 . A = B + C;
59-810 . D = E + F;
59-811 . }
59-812 .
59-813 .
59-814 . if (A < B)
59-815 . {
59-816 . A = B + C;
59-817 . D = E + F;
59-818 . }
59-819 .
59-820 . A = B+C;
59-821 .
59-822 . if (A ne B)
59-823 . {
59-824 . A = B + C;
59-825 . D = E + F;
59-826 . }
59-827 .
59-828 . A = B/C;
59-829 . A = B/C;
59-830 . A = 0x0009;
59-831 . A = B/C;
59-832 . A = B+C;
59-833 . A = B+C;
59-834 . A = B*C;
59-835 . A = B-C;
59-836 . goto error;
59-837 . A = B+C;
59-838 . /* LE SV TOC-3016 this is a wxp-01.4.48 req to call isr*/
59-839 . A = B/C;
59-840 . A = B+C;
59-841 . // TBS - I need to figure this out
59-842 .
59-843 . if (A ne B)
59-844 . {
59-845 . A = B + C;
59-846 . D = E + F;
59-847 . }
59-848 .
59-849 . A = B/C;
59-850 . A = B+C;
59-851 . A = B*C;
59-852 .
59-853 . if (A ge B)
59-854 . {
59-855 . A = B + C;
59-856 . D = E + F;
59-857 . }
59-858 .
59-859 . // TBS - I need to figure this out
59-860 .
59-861 . if (A != B)
59-862 . {
59-863 . A = B + C;
59-864 . D = E + F;
59-865 . }
59-866 .
59-867 . A = B-C;
59-868 . // max LOC 56
59-869 .
59-870 . }
59-871 .
59-872 .
59-873 . /*
59-874 . -----------------------------------------------------------------------------
59-875 . --| NAME: wxp.1.5
59-876 . --|
59-877 . --| ABSTRACT:
59-878 . --| This function does wxp stuff.
59-879 . --|
59-880 . --| RETURNS:
59-881 . --| NONE.
59-882 . --|
59-883 . ----------------------------------------------------------------------------
59-884 . */
59-885 . static void wxp.1.5(void)
59-886 . {
59-887 .
59-888 . if (A > = B)
59-889 . {
59-890 . A = B + C;
59-891 . D = E + F;
59-892 . }
59-893 .
59-894 . /* LE SV TOC-3017 this is a wxp-01.5.2 req to check pSOS*/
59-895 . A = 0x0004;
59-896 . A = B/C;
59-897 . A = B/C;
59-898 . A = B*C;
59-899 . A = B*C;
59-900 . A = B+C;
59-901 . A = B+C;
59-902 .
59-903 . if (A != B)
59-904 . {
59-905 . A = B + C;
59-906 . D = E + F;
59-907 . }
59-908 .
59-909 . A = B-C;
59-910 . A = B-C;
59-911 . A = B-C;
59-912 . A = B*C;
59-913 .
59-914 . if (A ge B)
59-915 . {
59-916 . A = B + C;
59-917 . D = E + F;
59-918 . }
59-919 .
59-920 .
59-921 . if (A le B)
59-922 . {
59-923 . A = B + C;
59-924 . D = E + F;
59-925 . }
59-926 .
59-927 .
59-928 . if (A > = B)
59-929 . {
59-930 . A = B + C;
59-931 . D = E + F;
59-932 . }
59-933 .
59-934 .
59-935 . if (A < = B)
59-936 . {
59-937 . A = B + C;
59-938 . D = E + F;
59-939 . }
59-940 .
59-941 . A = B*C;
59-942 . A = B+C;
59-943 .
59-944 . if (A eq B)
59-945 . {
59-946 . A = B + C;
59-947 . D = E + F;
59-948 . }
59-949 .
59-950 . A = B*C;
59-951 . // max LOC 20
59-952 .
59-953 . }
59-954 .
59-955 .
59-956 . /*
59-957 . -----------------------------------------------------------------------------
59-958 . --| NAME: wxp.1.6
59-959 . --|
59-960 . --| ABSTRACT:
59-961 . --| This function does wxp stuff.
59-962 . --|
59-963 . --| RETURNS:
59-964 . --| NONE.
59-965 . --|
59-966 . ----------------------------------------------------------------------------
59-967 . */
59-968 . static void wxp.1.6(void)
59-969 . {
59-970 . A = B-C;
59-971 . A = B-C;
59-972 . A = B*C;
59-973 . A = B+C;
59-974 . /* LE SV TOC-3018 this is a wxp-01.6.5 req to store*/
59-975 .
59-976 . if (A != B)
59-977 . {
59-978 . A = B + C;
59-979 . D = E + F;
59-980 . }
59-981 .
59-982 .
59-983 . if (A gt B)
59-984 . {
59-985 . A = B + C;
59-986 . D = E + F;
59-987 . }
59-988 .
59-989 . A = B/C;
59-990 . A = B+C;
59-991 .
59-992 . if (A le B)
59-993 . {
59-994 . A = B + C;
59-995 . D = E + F;
59-996 . }
59-997 .
59-998 . A = B+C;
59-999 . A = B-C;
59-1000 .
59-1001 . if (A gt B)
59-1002 . {
59-1003 . A = B + C;
59-1004 . D = E + F;
59-1005 . }
59-1006 .
59-1007 . A = B+C;
59-1008 . A = B+C;
59-1009 .
59-1010 . if (A le B)
59-1011 . {
59-1012 . A = B + C;
59-1013 . D = E + F;
59-1014 . }
59-1015 .
59-1016 . /* LE SV TOC-3019 this is a wxp-01.6.16 req to convert*/
59-1017 . A = B/C;
59-1018 . A = B-C;
59-1019 .
59-1020 . switch (wxp stuff)
59-1021 . {
59-1022 . case one:
59-1023 . {
59-1024 . run_this;
59-1025 . break;
59-1026 . }
59-1027 . case two:
59-1028 . {
59-1029 . run_this;
59-1030 . break;
59-1031 . }
59-1032 . default:
59-1033 . {
59-1034 . SwError;
59-1035 . }
59-1036 . }
59-1037 .
59-1038 .
59-1039 . if (A gt B)
59-1040 . {
59-1041 . A = B + C;
59-1042 . D = E + F;
59-1043 . }
59-1044 .
59-1045 . A = B*C;
59-1046 . A = B-C;
59-1047 . A = B*C;
59-1048 . /* LE SV TOC-3020 this is a wxp-01.6.23 req to call isr*/
59-1049 . FreePtr = HmiStringPtr;
59-1050 . A = B/C;
59-1051 . /* LE SV TOC-3021 this is a wxp-01.6.24 req to compare*/
59-1052 .
59-1053 . if (A lt B)
59-1054 . {
59-1055 . A = B + C;
59-1056 . D = E + F;
59-1057 . }
59-1058 .
59-1059 .
59-1060 . if (A ne B)
59-1061 . {
59-1062 . A = B + C;
59-1063 . D = E + F;
59-1064 . }
59-1065 .
59-1066 . A = B/C;
59-1067 .
59-1068 . if (A > = B)
59-1069 . {
59-1070 . A = B + C;
59-1071 . D = E + F;
59-1072 . }
59-1073 .
59-1074 .
59-1075 . if (A > = B)
59-1076 . {
59-1077 . A = B + C;
59-1078 . D = E + F;
59-1079 . }
59-1080 .
59-1081 .
59-1082 . if (A ne B)
59-1083 . {
59-1084 . A = B + C;
59-1085 . D = E + F;
59-1086 . }
59-1087 .
59-1088 . A = B-C;
59-1089 . A = B+C;
59-1090 .
59-1091 . if (A < = B)
59-1092 . {
59-1093 . A = B + C;
59-1094 . D = E + F;
59-1095 . }
59-1096 .
59-1097 . A = B-C;
59-1098 .
59-1099 . if (A < B)
59-1100 . {
59-1101 . A = B + C;
59-1102 . D = E + F;
59-1103 . }
59-1104 .
59-1105 . A = B-C;
59-1106 . A = B/C;
59-1107 . A = B/C;
59-1108 .
59-1109 . switch (wxp stuff)
59-1110 . {
59-1111 . case one:
59-1112 . {
59-1113 . run_this;
59-1114 . break;
59-1115 . }
59-1116 . case two:
59-1117 . {
59-1118 . run_this;
59-1119 . break;
59-1120 . }
59-1121 . default:
59-1122 . {
59-1123 . SwError;
59-1124 . }
59-1125 . }
59-1126 .
59-1127 .
59-1128 . if (A lt B)
59-1129 . {
59-1130 . A = B + C;
59-1131 . D = E + F;
59-1132 . }
59-1133 .
59-1134 . A = B/C;
59-1135 .
59-1136 . if (veg)
59-1137 . // missing curly brace
59-1138 . variable = orange;
59-1139 .
59-1140 . A = B/C;
59-1141 . A = B+C;
59-1142 .
59-1143 . if (A < B)
59-1144 . {
59-1145 . A = B + C;
59-1146 . D = E + F;
59-1147 . }
59-1148 .
59-1149 .
59-1150 . if (A lt B)
59-1151 . {
59-1152 . A = B + C;
59-1153 . D = E + F;
59-1154 . }
59-1155 .
59-1156 . /* LE SV TOC-3022 this is a wxp-01.6.45 req to translate*/
59-1157 . A = B/C;
59-1158 . /* LE SV TOC-3023 this is a wxp-01.6.46 req to translate*/
59-1159 . A = B+C;
59-1160 .
59-1161 . /*
59-1162 . dead_code = B - C;
59-1163 . dead_code = D - E;
59-1164 . dead_code = F - G;
59-1165 . */
59-1166 .
59-1167 .
59-1168 . if (A > = B)
59-1169 . {
59-1170 . A = B + C;
59-1171 . D = E + F;
59-1172 . }
59-1173 .
59-1174 .
59-1175 . if (A < = B)
59-1176 . {
59-1177 . A = B + C;
59-1178 . D = E + F;
59-1179 . }
59-1180 .
59-1181 . A = B-C;
59-1182 . A = B*C;
59-1183 .
59-1184 . if (A < B)
59-1185 . {
59-1186 . A = B + C;
59-1187 . D = E + F;
59-1188 . }
59-1189 .
59-1190 . A = B-C;
59-1191 . A = B*C;
59-1192 . // max LOC 53
59-1193 .
59-1194 . }
59-1195 .
59-1196 .
59-1197 . /*
59-1198 . -----------------------------------------------------------------------------
59-1199 . --| NAME: wxp.1.7
59-1200 . --|
59-1201 . --| ABSTRACT:
59-1202 . --| This function does wxp stuff.
59-1203 . --|
59-1204 . --| RETURNS:
59-1205 . --| NONE.
59-1206 . --|
59-1207 . ----------------------------------------------------------------------------
59-1208 . */
59-1209 . static void wxp.1.7(void)
59-1210 . {
59-1211 . A = B+C;
59-1212 . A = B+C;
59-1213 . A = B/C;
59-1214 . A = B+C;
59-1215 . A = B/C;
59-1216 . A = B-C;
59-1217 . A = B-C;
59-1218 . // max LOC 7
59-1219 .
59-1220 . }
59-1221 .
59-1222 .
59-1223 . /*
59-1224 . -----------------------------------------------------------------------------
59-1225 . --| NAME: wxp.1.8
59-1226 . --|
59-1227 . --| ABSTRACT:
59-1228 . --| This function does wxp stuff.
59-1229 . --|
59-1230 . --| RETURNS:
59-1231 . --| NONE.
59-1232 . --|
59-1233 . ----------------------------------------------------------------------------
59-1234 . */
59-1235 . static void wxp.1.8(void)
59-1236 . {
59-1237 . A = B*C;
59-1238 . A = B/C;
59-1239 . A = B-C;
59-1240 . /* LE SV TOC-3024 this is a wxp-01.8.4 req to convert*/
59-1241 . A = B/C;
59-1242 . /* LE SV TOC-3025 this is a wxp-01.8.5 req to check unix*/
59-1243 . A = B*C;
59-1244 . A = B/C;
59-1245 . A = B-C;
59-1246 . A = B/C;
59-1247 . // max LOC 8
59-1248 .
59-1249 . }
59-1250 .
59-1251 .
59-1252 . /*
59-1253 . -----------------------------------------------------------------------------
59-1254 . --| NAME: wxp.1.9
59-1255 . --|
59-1256 . --| ABSTRACT:
59-1257 . --| This function does wxp stuff.
59-1258 . --|
59-1259 . --| RETURNS:
59-1260 . --| NONE.
59-1261 . --|
59-1262 . ----------------------------------------------------------------------------
59-1263 . */
59-1264 . static void wxp.1.9(void)
59-1265 . {
59-1266 .
59-1267 . switch (wxp stuff)
59-1268 . {
59-1269 . case one:
59-1270 . {
59-1271 . run_this;
59-1272 . break;
59-1273 . }
59-1274 . case two:
59-1275 . {
59-1276 . run_this;
59-1277 . break;
59-1278 . }
59-1279 . default:
59-1280 . {
59-1281 . // missing error call
59-1282 . }
59-1283 . }
59-1284 .
59-1285 .
59-1286 . if (A != B)
59-1287 . {
59-1288 . A = B + C;
59-1289 . D = E + F;
59-1290 . }
59-1291 .
59-1292 . A = B*C;
59-1293 . A = B-C;
59-1294 .
59-1295 . if (A lt B)
59-1296 . {
59-1297 . A = B + C;
59-1298 . D = E + F;
59-1299 . }
59-1300 .
59-1301 . A = B/C;
59-1302 . A = B+C;
59-1303 . /* LE SV TOC-3026 this is a wxp-01.9.7 req to set Real Time Clock*/
59-1304 .
59-1305 . if (A ne B)
59-1306 . {
59-1307 . A = B + C;
59-1308 . D = E + F;
59-1309 . }
59-1310 .
59-1311 .
59-1312 . if (A eq B)
59-1313 . {
59-1314 . A = B + C;
59-1315 . D = E + F;
59-1316 . }
59-1317 .
59-1318 . A = B+C;
59-1319 . A = B+C;
59-1320 . A = B*C;
59-1321 . A = B*C;
59-1322 .
59-1323 . if (A gt B)
59-1324 . {
59-1325 . A = B + C;
59-1326 . D = E + F;
59-1327 . }
59-1328 .
59-1329 .
59-1330 . if (A < = B)
59-1331 . {
59-1332 . A = B + C;
59-1333 . D = E + F;
59-1334 . }
59-1335 .
59-1336 . /* LE SV TOC-3027 this is a wxp-01.9.15 req to validate*/
59-1337 . A = B/C;
59-1338 . A = B*C;
59-1339 . A = B*C;
59-1340 . A = B+C;
59-1341 .
59-1342 . switch (wxp stuff)
59-1343 . {
59-1344 . case one:
59-1345 . {
59-1346 . run_this;
59-1347 . break;
59-1348 . }
59-1349 . case two:
59-1350 . {
59-1351 . run_this;
59-1352 . break;
59-1353 . }
59-1354 . default:
59-1355 . {
59-1356 . SwError;
59-1357 . }
59-1358 . }
59-1359 .
59-1360 . /* LE SV TOC-3028 this is a wxp-01.9.20 req to inhibit*/
59-1361 . A = B-C;
59-1362 . A = B-C;
59-1363 . A = B-C;
59-1364 .
59-1365 . if (A != B)
59-1366 . {
59-1367 . A = B + C;
59-1368 . D = E + F;
59-1369 . }
59-1370 .
59-1371 .
59-1372 . if (A < = B)
59-1373 . {
59-1374 . A = B + C;
59-1375 . D = E + F;
59-1376 . }
59-1377 .
59-1378 . A = B-C;
59-1379 . A = 0x0002;
59-1380 . A = B*C;
59-1381 . A = B*C;
59-1382 . A = B-C;
59-1383 .
59-1384 . switch (wxp stuff)
59-1385 . {
59-1386 . case one:
59-1387 . {
59-1388 . run_this;
59-1389 . break;
59-1390 . }
59-1391 . case two:
59-1392 . {
59-1393 . run_this;
59-1394 . break;
59-1395 . }
59-1396 . default:
59-1397 . {
59-1398 . // missing error call
59-1399 . }
59-1400 . }
59-1401 .
59-1402 . A = B*C;
59-1403 . A = B/C;
59-1404 . A = B/C;
59-1405 .
59-1406 . if (A < B)
59-1407 . {
59-1408 . A = B + C;
59-1409 . D = E + F;
59-1410 . }
59-1411 .
59-1412 .
59-1413 . /*
59-1414 . dead_block = C * D;
59-1415 . dead_block = E * F;
59-1416 . */
59-1417 .
59-1418 . A = B/C;
59-1419 . A = B/C;
59-1420 . A = B+C;
59-1421 . A = B/C;
59-1422 .
59-1423 . if (A == B)
59-1424 . {
59-1425 . A = B + C;
59-1426 . D = E + F;
59-1427 . }
59-1428 .
59-1429 . A = B+C;
59-1430 . A = B-C;
59-1431 . A = B*C;
59-1432 . A = B-C;
59-1433 .
59-1434 . if (A ge B)
59-1435 . {
59-1436 . A = B + C;
59-1437 . D = E + F;
59-1438 . }
59-1439 .
59-1440 . A = B+C;
59-1441 . A = B-C;
59-1442 . A = B/C;
59-1443 . // max LOC 45
59-1444 .
59-1445 . }
59-1446 .
59-1447 .
59-1448 . /*
59-1449 . -----------------------------------------------------------------------------
59-1450 . --| NAME: wxp.1.10
59-1451 . --|
59-1452 . --| ABSTRACT:
59-1453 . --| This function does wxp stuff.
59-1454 . --|
59-1455 . --| RETURNS:
59-1456 . --| NONE.
59-1457 . --|
59-1458 . ----------------------------------------------------------------------------
59-1459 . */
59-1460 . static void wxp.1.10(void)
59-1461 . {
59-1462 . A = B*C;
59-1463 . A = B+C;
59-1464 . A = B+C;
59-1465 . A = B*C;
59-1466 . A = B/C;
59-1467 . A = B/C;
59-1468 . A = B/C;
59-1469 . A = B/C;
59-1470 . goto error;
59-1471 . A = B-C;
59-1472 . A = B/C;
59-1473 .
59-1474 . if (A > B)
59-1475 . {
59-1476 . A = B + C;
59-1477 . D = E + F;
59-1478 . }
59-1479 .
59-1480 . A = B*C;
59-1481 . A = B-C;
59-1482 .
59-1483 . switch (wxp stuff)
59-1484 . {
59-1485 . case one:
59-1486 . {
59-1487 . run_this;
59-1488 . break;
59-1489 . }
59-1490 . case two:
59-1491 . {
59-1492 . run_this;
59-1493 . break;
59-1494 . }
59-1495 . default:
59-1496 . {
59-1497 . SwError;
59-1498 . }
59-1499 . }
59-1500 .
59-1501 . A = B+C;
59-1502 .
59-1503 . if (A != B)
59-1504 . {
59-1505 . A = B + C;
59-1506 . D = E + F;
59-1507 . }
59-1508 .
59-1509 . A = B*C;
59-1510 . A = B+C;
59-1511 . A = B/C;
59-1512 .
59-1513 . if (A < B)
59-1514 . {
59-1515 . A = B + C;
59-1516 . D = E + F;
59-1517 . }
59-1518 .
59-1519 . A = B-C;
59-1520 .
59-1521 . if (A ne B)
59-1522 . {
59-1523 . A = B + C;
59-1524 . D = E + F;
59-1525 . }
59-1526 .
59-1527 . A = B-C;
59-1528 . A = B+C;
59-1529 . A = B/C;
59-1530 . A = B+C;
59-1531 .
59-1532 . if (A > = B)
59-1533 . {
59-1534 . A = B + C;
59-1535 . D = E + F;
59-1536 . }
59-1537 .
59-1538 . A = B-C;
59-1539 .
59-1540 . if (A != B)
59-1541 . {
59-1542 . A = B + C;
59-1543 . D = E + F;
59-1544 . }
59-1545 .
59-1546 .
59-1547 . if (A != B)
59-1548 . {
59-1549 . A = B + C;
59-1550 . D = E + F;
59-1551 . }
59-1552 .
59-1553 . A = B+C;
59-1554 . A = B+C;
59-1555 .
59-1556 . if (A ne B)
59-1557 . {
59-1558 . A = B + C;
59-1559 . D = E + F;
59-1560 . }
59-1561 .
59-1562 . A = B*C;
59-1563 . A = B/C;
59-1564 . A = B/C;
59-1565 . A = B-C;
59-1566 . A = B+C;
59-1567 . /* LE SV TOC-3029 this is a wxp-01.10.39 req to enable*/
59-1568 . A = B/C;
59-1569 . A = B/C;
59-1570 . A = B*C;
59-1571 .
59-1572 . if (A > = B)
59-1573 . {
59-1574 . A = B + C;
59-1575 . D = E + F;
59-1576 . }
59-1577 .
59-1578 . A = B*C;
59-1579 . A = B-C;
59-1580 . A = B-C;
59-1581 . A = B/C;
59-1582 . A = B*C;
59-1583 . A = B+C;
59-1584 .
59-1585 . if (A le B)
59-1586 . {
59-1587 . A = B + C;
59-1588 . D = E + F;
59-1589 . }
59-1590 .
59-1591 . A = B*C;
59-1592 . A = B+C;
59-1593 .
59-1594 . if (A eq B)
59-1595 . {
59-1596 . A = B + C;
59-1597 . D = E + F;
59-1598 . }
59-1599 .
59-1600 . /* dead_code = A * B; */
59-1601 . A = B/C;
59-1602 . A = B/C;
59-1603 .
59-1604 . if (A le B)
59-1605 . {
59-1606 . A = B + C;
59-1607 . D = E + F;
59-1608 . }
59-1609 .
59-1610 . A = B/C;
59-1611 . A = B*C;
59-1612 . A = B-C;
59-1613 . A = B+C;
59-1614 . A = (int)B + C;
59-1615 . A = B+C;
59-1616 . A = B-C;
59-1617 . A = B*C;
59-1618 . A = B/C;
59-1619 . A = B/C;
59-1620 . A = B+C;
59-1621 . A = B/C;
59-1622 . // max LOC 66
59-1623 .
59-1624 . }
59-1625 .
59 59 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-01.c
60 60 Source: source/ft-app/ft-app-B1.1/wxp/wxp-02.c
60-0 . /*
60-1 . ----------------------------------------------------------------------------
60-2 . --| BEGIN PROLOGUE
60-3 . --|
60-4 . --| CLASSIFICATION: UNCLASSIFIED
60-5 . --|
60-6 . --| FILE NAME: wxp-02.c
60-7 . --|
60-8 . --| ABSTRACT:
60-9 . --| This file contains the 11 functions that do file wxp stuff.
60-10 . --|
60-11 . --| HISTORY:
60-12 . --| CCCQ_NAME:
60-13 . --| CCCQ_VER:
60-14 . --|
60-15 . --| END PROLOGUE
60-16 . ----------------------------------------------------------------------------
60-17 . */
60-18 .
60-19 . #include A;
60-20 . #include A;
60-21 . #define A;
60-22 . #include B;
60-23 . #include D;
60-24 . float B;
60-25 .
60-26 .
60-27 .
60-28 . /*
60-29 . -----------------------------------------------------------------------------
60-30 . --| NAME: wxp.2.1
60-31 . --|
60-32 . --| ABSTRACT:
60-33 . --| This function does wxp stuff.
60-34 . --|
60-35 . --| RETURNS:
60-36 . --| NONE.
60-37 . --|
60-38 . ----------------------------------------------------------------------------
60-39 . */
60-40 . static void wxp.2.1(void)
60-41 . {
60-42 . A = B*C;
60-43 . A = B/C;
60-44 . A = B*C;
60-45 .
60-46 . if (A ge B)
60-47 . {
60-48 . A = B + C;
60-49 . D = E + F;
60-50 . }
60-51 .
60-52 .
60-53 . if (A < = B)
60-54 . {
60-55 . A = B + C;
60-56 . D = E + F;
60-57 . }
60-58 .
60-59 . A = B+C;
60-60 . A = B+C;
60-61 . A = B-C;
60-62 . A = B-C;
60-63 . A = B/C;
60-64 . A = B-C;
60-65 .
60-66 . if (A gt B)
60-67 . {
60-68 . A = B + C;
60-69 . D = E + F;
60-70 . }
60-71 .
60-72 . A = B*C;
60-73 . A = B-C;
60-74 .
60-75 . if (A == B)
60-76 . {
60-77 . A = B + C;
60-78 . D = E + F;
60-79 . }
60-80 .
60-81 .
60-82 . switch (wxp stuff)
60-83 . {
60-84 . case one:
60-85 . {
60-86 . run_this;
60-87 . break;
60-88 . }
60-89 . case two:
60-90 . {
60-91 . run_this;
60-92 . break;
60-93 . }
60-94 . // missing default
60-95 . }
60-96 .
60-97 . A = B*C;
60-98 . FreePtr = HmiStringPtr;
60-99 .
60-100 . if (A > B)
60-101 . {
60-102 . A = B + C;
60-103 . D = E + F;
60-104 . }
60-105 .
60-106 .
60-107 . switch (wxp stuff)
60-108 . {
60-109 . case one:
60-110 . {
60-111 . run_this;
60-112 . break;
60-113 . }
60-114 . case two:
60-115 . {
60-116 . run_this;
60-117 . break;
60-118 . }
60-119 . default:
60-120 . {
60-121 . SwError;
60-122 . }
60-123 . }
60-124 .
60-125 . A = B/C;
60-126 . /* LE SV TOC-3030 this is a wxp-02.1.20 req to fail*/
60-127 . A = B+C;
60-128 . A = B+C;
60-129 . A = B-C;
60-130 . A = B-C;
60-131 . A = B+C;
60-132 . A = B*C;
60-133 . A = B/C;
60-134 .
60-135 . if (A ne B)
60-136 . {
60-137 . A = B + C;
60-138 . D = E + F;
60-139 . }
60-140 .
60-141 . A = B*C;
60-142 . A = B+C;
60-143 . A = B+C;
60-144 . A = B-C;
60-145 .
60-146 . if (A ge B)
60-147 . {
60-148 . A = B + C;
60-149 . D = E + F;
60-150 . }
60-151 .
60-152 . // (P) this is really improtant
60-153 . A = B+C;
60-154 .
60-155 . /*
60-156 . dead_code = B - C;
60-157 . dead_code = D - E;
60-158 . dead_code = F - G;
60-159 . */
60-160 .
60-161 .
60-162 . if (A < = B)
60-163 . {
60-164 . A = B + C;
60-165 . D = E + F;
60-166 . }
60-167 .
60-168 . A = B*C;
60-169 . A = B+C;
60-170 . A = B/C;
60-171 .
60-172 . if (A < = B)
60-173 . {
60-174 . A = B + C;
60-175 . D = E + F;
60-176 . }
60-177 .
60-178 . A = B*C;
60-179 . A = B+C;
60-180 .
60-181 . if (A == B)
60-182 . {
60-183 . A = B + C;
60-184 . D = E + F;
60-185 . }
60-186 .
60-187 . A = B*C;
60-188 .
60-189 . if (A ne B)
60-190 . {
60-191 . A = B + C;
60-192 . D = E + F;
60-193 . }
60-194 .
60-195 .
60-196 . if (A == B)
60-197 . {
60-198 . A = B + C;
60-199 . D = E + F;
60-200 . }
60-201 .
60-202 .
60-203 . if (A > = B)
60-204 . {
60-205 . A = B + C;
60-206 . D = E + F;
60-207 . }
60-208 .
60-209 . A = B+C;
60-210 . A = B-C;
60-211 . /* LE SV TOC-3031 this is a wxp-02.1.48 req to audit*/
60-212 . A = B/C;
60-213 . A = B-C;
60-214 . // TBD - what do I do now
60-215 . A = B*C;
60-216 . A = B*C;
60-217 . A = B+C;
60-218 . A = B*C;
60-219 .
60-220 . switch (wxp stuff)
60-221 . {
60-222 . case one:
60-223 . {
60-224 . run_this;
60-225 . break;
60-226 . }
60-227 . case two:
60-228 . {
60-229 . run_this;
60-230 . break;
60-231 . }
60-232 . default:
60-233 . {
60-234 . SwError;
60-235 . }
60-236 . }
60-237 .
60-238 . A = B-C;
60-239 . A = B*C;
60-240 . // TBD - what do I do now
60-241 . A = B*C;
60-242 . A = B*C;
60-243 . A = B*C;
60-244 . A = B/C;
60-245 . A = B+C;
60-246 .
60-247 . if (A > = B)
60-248 . {
60-249 . A = B + C;
60-250 . D = E + F;
60-251 . }
60-252 .
60-253 . A = B-C;
60-254 . A = B-C;
60-255 . A = B*C;
60-256 . A = B/C;
60-257 . A = B/C;
60-258 .
60-259 . if (A le B)
60-260 . {
60-261 . A = B + C;
60-262 . D = E + F;
60-263 . }
60-264 .
60-265 .
60-266 . if (A < = B)
60-267 . {
60-268 . A = B + C;
60-269 . D = E + F;
60-270 . }
60-271 .
60-272 . /* LE SV TOC-3032 this is a wxp-02.1.70 req to check pSOS*/
60-273 . A = B*C;
60-274 . A = B*C;
60-275 . A = B/C;
60-276 . // max LOC 72
60-277 .
60-278 . }
60-279 .
60-280 .
60-281 . /*
60-282 . -----------------------------------------------------------------------------
60-283 . --| NAME: wxp.2.2
60-284 . --|
60-285 . --| ABSTRACT:
60-286 . --| This function does wxp stuff.
60-287 . --|
60-288 . --| RETURNS:
60-289 . --| NONE.
60-290 . --|
60-291 . ----------------------------------------------------------------------------
60-292 . */
60-293 . static void wxp.2.2(void)
60-294 . {
60-295 .
60-296 . if (A > B)
60-297 . {
60-298 . A = B + C;
60-299 . D = E + F;
60-300 . }
60-301 .
60-302 . A = B-C;
60-303 . A = B+C;
60-304 .
60-305 . if (A > B)
60-306 . {
60-307 . A = B + C;
60-308 . D = E + F;
60-309 . }
60-310 .
60-311 . /* dead_code = A * B; */
60-312 . A = B-C;
60-313 . A = B-C;
60-314 .
60-315 . switch (wxp stuff)
60-316 . {
60-317 . case one:
60-318 . {
60-319 . run_this;
60-320 . break;
60-321 . }
60-322 . case two:
60-323 . {
60-324 . run_this;
60-325 . break;
60-326 . }
60-327 . default:
60-328 . {
60-329 . SwError;
60-330 . }
60-331 . }
60-332 .
60-333 . A = B-C;
60-334 . A = B*C;
60-335 .
60-336 . if (A < B)
60-337 . {
60-338 . A = B + C;
60-339 . D = E + F;
60-340 . }
60-341 .
60-342 .
60-343 . if (A == B)
60-344 . {
60-345 . A = B + C;
60-346 . D = E + F;
60-347 . }
60-348 .
60-349 . A = B/C;
60-350 . A = B/C;
60-351 .
60-352 . if (A < B)
60-353 . {
60-354 . A = B + C;
60-355 . D = E + F;
60-356 . }
60-357 .
60-358 .
60-359 . if (A == B)
60-360 . {
60-361 . A = B + C;
60-362 . D = E + F;
60-363 . }
60-364 .
60-365 .
60-366 . if (A < = B)
60-367 . {
60-368 . A = B + C;
60-369 . D = E + F;
60-370 . }
60-371 .
60-372 .
60-373 . if (A != B)
60-374 . {
60-375 . A = B + C;
60-376 . D = E + F;
60-377 . }
60-378 .
60-379 .
60-380 . if (A eq B)
60-381 . {
60-382 . A = B + C;
60-383 . D = E + F;
60-384 . }
60-385 .
60-386 . A = B+C;
60-387 . A = B-C;
60-388 . A = B-C;
60-389 . A = B/C;
60-390 . A = B/C;
60-391 . A = B*C;
60-392 . A = 0x0003;
60-393 .
60-394 . if (A != B)
60-395 . {
60-396 . A = B + C;
60-397 . D = E + F;
60-398 . }
60-399 .
60-400 . A = B-C;
60-401 .
60-402 . switch (wxp stuff)
60-403 . {
60-404 . case one:
60-405 . {
60-406 . run_this;
60-407 . break;
60-408 . }
60-409 . case two:
60-410 . {
60-411 . run_this;
60-412 . break;
60-413 . }
60-414 . default:
60-415 . {
60-416 . SwError;
60-417 . }
60-418 . }
60-419 .
60-420 . A = B+C;
60-421 . A = (float)B + C;
60-422 . A = B*C;
60-423 .
60-424 . if (A le B)
60-425 . {
60-426 . A = B + C;
60-427 . D = E + F;
60-428 . }
60-429 .
60-430 . send_buffer = (U16 *) malloc(size+1);
60-431 . A = B-C;
60-432 . A = B*C;
60-433 . A = B/C;
60-434 .
60-435 . if (A lt B)
60-436 . {
60-437 . A = B + C;
60-438 . D = E + F;
60-439 . }
60-440 .
60-441 .
60-442 . if (A ne B)
60-443 . {
60-444 . A = B + C;
60-445 . D = E + F;
60-446 . }
60-447 .
60-448 .
60-449 . if (A ge B)
60-450 . {
60-451 . A = B + C;
60-452 . D = E + F;
60-453 . }
60-454 .
60-455 .
60-456 . /*
60-457 . dead_code = B - C;
60-458 . dead_code = D - E;
60-459 . dead_code = F - G;
60-460 . */
60-461 .
60-462 . A = B+C;
60-463 .
60-464 . if (A ne B)
60-465 . {
60-466 . A = B + C;
60-467 . D = E + F;
60-468 . }
60-469 .
60-470 .
60-471 . if (A lt B)
60-472 . {
60-473 . A = B + C;
60-474 . D = E + F;
60-475 . }
60-476 .
60-477 .
60-478 . if (A eq B)
60-479 . {
60-480 . A = B + C;
60-481 . D = E + F;
60-482 . }
60-483 .
60-484 .
60-485 . switch (wxp stuff)
60-486 . {
60-487 . case one:
60-488 . {
60-489 . run_this;
60-490 . break;
60-491 . }
60-492 . case two:
60-493 . {
60-494 . run_this;
60-495 . break;
60-496 . }
60-497 . default:
60-498 . {
60-499 . SwError;
60-500 . }
60-501 . }
60-502 .
60-503 .
60-504 . if (A ge B)
60-505 . {
60-506 . A = B + C;
60-507 . D = E + F;
60-508 . }
60-509 .
60-510 . A = B*C;
60-511 . A = B*C;
60-512 . A = B*C;
60-513 . A = B-C;
60-514 . A = B*C;
60-515 . A = B/C;
60-516 . /* LE SV TOC-3033 this is a wxp-02.2.49 req to verify*/
60-517 . A = B-C;
60-518 . A = B+C;
60-519 .
60-520 . if (A ge B)
60-521 . {
60-522 . A = B + C;
60-523 . D = E + F;
60-524 . }
60-525 .
60-526 .
60-527 . switch (wxp stuff)
60-528 . {
60-529 . case one:
60-530 . {
60-531 . run_this;
60-532 . break;
60-533 . }
60-534 . case two:
60-535 . {
60-536 . run_this;
60-537 . break;
60-538 . }
60-539 . default:
60-540 . {
60-541 . SwError;
60-542 . }
60-543 . }
60-544 .
60-545 . A = B/C;
60-546 .
60-547 . if (A ne B)
60-548 . {
60-549 . A = B + C;
60-550 . D = E + F;
60-551 . }
60-552 .
60-553 .
60-554 . if (A lt B)
60-555 . {
60-556 . A = B + C;
60-557 . D = E + F;
60-558 . }
60-559 .
60-560 . A = B/C;
60-561 . A = B-C;
60-562 . A = B/C;
60-563 . A = B/C;
60-564 . A = B*C;
60-565 .
60-566 . switch (wxp stuff)
60-567 . {
60-568 . case one:
60-569 . {
60-570 . run_this;
60-571 . break;
60-572 . }
60-573 . case two:
60-574 . {
60-575 . run_this;
60-576 . break;
60-577 . }
60-578 . default:
60-579 . {
60-580 . SwError;
60-581 . }
60-582 . }
60-583 .
60-584 . A = B*C;
60-585 . // max LOC 62
60-586 .
60-587 . }
60-588 .
60-589 .
60-590 . /*
60-591 . -----------------------------------------------------------------------------
60-592 . --| NAME: wxp.2.3
60-593 . --|
60-594 . --| ABSTRACT:
60-595 . --| This function does wxp stuff.
60-596 . --|
60-597 . --| RETURNS:
60-598 . --| NONE.
60-599 . --|
60-600 . ----------------------------------------------------------------------------
60-601 . */
60-602 . static void wxp.2.3(void)
60-603 . {
60-604 . A = B+C;
60-605 . A = B*C;
60-606 . A = B*C;
60-607 . A = B-C;
60-608 . A = B-C;
60-609 . A = B-C;
60-610 . A = B/C;
60-611 .
60-612 . switch (wxp stuff)
60-613 . {
60-614 . case one:
60-615 . {
60-616 . run_this;
60-617 . // missing break
60-618 . }
60-619 . case two:
60-620 . {
60-621 . run_this;
60-622 . break;
60-623 . }
60-624 . default:
60-625 . {
60-626 . SwError;
60-627 . }
60-628 . }
60-629 .
60-630 .
60-631 . if (A gt B)
60-632 . {
60-633 . A = B + C;
60-634 . D = E + F;
60-635 . }
60-636 .
60-637 . A = B-C;
60-638 . A = B*C;
60-639 . A = B*C;
60-640 . A = B-C;
60-641 . A = B-C;
60-642 . A = B*C;
60-643 .
60-644 . if (A le B)
60-645 . {
60-646 . A = B + C;
60-647 . D = E + F;
60-648 . }
60-649 .
60-650 . A = B*C;
60-651 . A = B/C;
60-652 .
60-653 . if (A ne B)
60-654 . {
60-655 . A = B + C;
60-656 . D = E + F;
60-657 . }
60-658 .
60-659 .
60-660 . if (A == B)
60-661 . {
60-662 . A = B + C;
60-663 . D = E + F;
60-664 . }
60-665 .
60-666 .
60-667 . if (A < = B)
60-668 . {
60-669 . A = B + C;
60-670 . D = E + F;
60-671 . }
60-672 .
60-673 . A = B*C;
60-674 . A = B*C;
60-675 . A = B+C;
60-676 . A = B/C;
60-677 . A = B-C;
60-678 . A = B+C;
60-679 .
60-680 . if (A > B)
60-681 . {
60-682 . A = B + C;
60-683 . D = E + F;
60-684 . }
60-685 .
60-686 . A = B+C;
60-687 . /* LE SV TOC-3034 this is a wxp-02.3.29 req to validate*/
60-688 . A = 0x0007;
60-689 .
60-690 . switch (wxp stuff)
60-691 . {
60-692 . case one:
60-693 . {
60-694 . run_this;
60-695 . break;
60-696 . }
60-697 . case two:
60-698 . {
60-699 . run_this;
60-700 . break;
60-701 . }
60-702 . default:
60-703 . {
60-704 . SwError;
60-705 . }
60-706 . }
60-707 .
60-708 . A = B-C;
60-709 . A = B*C;
60-710 . A = B*C;
60-711 . A = B+C;
60-712 . A = B+C;
60-713 .
60-714 . switch (wxp stuff)
60-715 . {
60-716 . case one:
60-717 . {
60-718 . run_this;
60-719 . break;
60-720 . }
60-721 . case two:
60-722 . {
60-723 . run_this;
60-724 . break;
60-725 . }
60-726 . default:
60-727 . {
60-728 . SwError;
60-729 . }
60-730 . }
60-731 .
60-732 . A = B/C;
60-733 . /* LE SV TOC-3035 this is a wxp-02.3.37 req to verify*/
60-734 .
60-735 . if (A lt B)
60-736 . {
60-737 . A = B + C;
60-738 . D = E + F;
60-739 . }
60-740 .
60-741 . /* LE SV TOC-3036 this is a wxp-02.3.38 req to process*/
60-742 . A = B+C;
60-743 . A = B+C;
60-744 . A = B*C;
60-745 . A = B*C;
60-746 . A = B+C;
60-747 . A = B*C;
60-748 .
60-749 . if (A lt B)
60-750 . {
60-751 . A = B + C;
60-752 . D = E + F;
60-753 . }
60-754 .
60-755 . A = B*C;
60-756 . A = B*C;
60-757 .
60-758 . if (A gt B)
60-759 . {
60-760 . A = B + C;
60-761 . D = E + F;
60-762 . }
60-763 .
60-764 .
60-765 . if (A lt B)
60-766 . {
60-767 . A = B + C;
60-768 . D = E + F;
60-769 . }
60-770 .
60-771 . A = B*C;
60-772 . A = B*C;
60-773 . A = 0x0009;
60-774 . A = B-C;
60-775 . A = B/C;
60-776 . /* LE SV TOC-3037 this is a wxp-02.3.53 req to store*/
60-777 . A = B*C;
60-778 . A = B/C;
60-779 . A = B/C;
60-780 .
60-781 . if (A le B)
60-782 . {
60-783 . A = B + C;
60-784 . D = E + F;
60-785 . }
60-786 .
60-787 . A = B-C;
60-788 . A = B*C;
60-789 . A = B+C;
60-790 . A = B*C;
60-791 . A = B/C;
60-792 . A = B*C;
60-793 .
60-794 . if (A > = B)
60-795 . {
60-796 . A = B + C;
60-797 . D = E + F;
60-798 . }
60-799 .
60-800 . A = B-C;
60-801 . A = B/C;
60-802 . A = B/C;
60-803 . // max LOC 66
60-804 .
60-805 . }
60-806 .
60-807 .
60-808 . /*
60-809 . -----------------------------------------------------------------------------
60-810 . --| NAME: wxp.2.4
60-811 . --|
60-812 . --| ABSTRACT:
60-813 . --| This function does wxp stuff.
60-814 . --|
60-815 . --| RETURNS:
60-816 . --| NONE.
60-817 . --|
60-818 . ----------------------------------------------------------------------------
60-819 . */
60-820 . static void wxp.2.4(void)
60-821 . {
60-822 . A = B+C;
60-823 . A = B*C;
60-824 . A = B*C;
60-825 . A = B+C;
60-826 .
60-827 . if (A eq B)
60-828 . {
60-829 . A = B + C;
60-830 . D = E + F;
60-831 . }
60-832 .
60-833 .
60-834 . if (A > = B)
60-835 . {
60-836 . A = B + C;
60-837 . D = E + F;
60-838 . }
60-839 .
60-840 . A = B-C;
60-841 .
60-842 . if (A < B)
60-843 . {
60-844 . A = B + C;
60-845 . D = E + F;
60-846 . }
60-847 .
60-848 .
60-849 . /* dead_code = B + C;
60-850 . dead_code = D + E;
60-851 . dead_code = F + G; */
60-852 .
60-853 . A = B*C;
60-854 . A = B-C;
60-855 . A = B-C;
60-856 .
60-857 . if (A lt B)
60-858 . {
60-859 . A = B + C;
60-860 . D = E + F;
60-861 . }
60-862 .
60-863 .
60-864 . if (A > = B)
60-865 . {
60-866 . A = B + C;
60-867 . D = E + F;
60-868 . }
60-869 .
60-870 . A = B+C;
60-871 . A = B-C;
60-872 . /* LE SV TOC-3038 this is a wxp-02.4.16 req to check pSOS*/
60-873 .
60-874 . if (A eq B)
60-875 . {
60-876 . A = B + C;
60-877 . D = E + F;
60-878 . }
60-879 .
60-880 .
60-881 . #ifdef LAZY
60-882 . // this is not nice
60-883 . A = B + C;
60-884 . A = B + C;
60-885 . #endif
60-886 .
60-887 . A = B-C;
60-888 . A = B*C;
60-889 . A = B*C;
60-890 . /* LE SV TOC-3039 this is a wxp-02.4.20 req to verify*/
60-891 .
60-892 . if (A != B)
60-893 . {
60-894 . A = B + C;
60-895 . D = E + F;
60-896 . }
60-897 .
60-898 . A = B+C;
60-899 . A = B/C;
60-900 .
60-901 . if (A lt B)
60-902 . {
60-903 . A = B + C;
60-904 . D = E + F;
60-905 . }
60-906 .
60-907 . A = B+C;
60-908 . A = B-C;
60-909 .
60-910 . if (A ge B)
60-911 . {
60-912 . A = B + C;
60-913 . D = E + F;
60-914 . }
60-915 .
60-916 . A = B-C;
60-917 .
60-918 . if (A eq B)
60-919 . {
60-920 . A = B + C;
60-921 . D = E + F;
60-922 . }
60-923 .
60-924 .
60-925 . if (A < B)
60-926 . {
60-927 . A = B + C;
60-928 . D = E + F;
60-929 . }
60-930 .
60-931 . A = B+C;
60-932 . A = B*C;
60-933 . A = B-C;
60-934 . A = B*C;
60-935 . A = B*C;
60-936 . A = B/C;
60-937 . A = B-C;
60-938 .
60-939 . switch (wxp stuff)
60-940 . {
60-941 . case one:
60-942 . {
60-943 . run_this;
60-944 . break;
60-945 . }
60-946 . case two:
60-947 . {
60-948 . run_this;
60-949 . break;
60-950 . }
60-951 . default:
60-952 . {
60-953 . SwError;
60-954 . }
60-955 . }
60-956 .
60-957 . A = 0x0009;
60-958 .
60-959 . if (A > = B)
60-960 . {
60-961 . A = B + C;
60-962 . D = E + F;
60-963 . }
60-964 .
60-965 . A = B+C;
60-966 . A = B*C;
60-967 . A = B-C;
60-968 .
60-969 . if (A > B)
60-970 . {
60-971 . A = B + C;
60-972 . D = E + F;
60-973 . }
60-974 .
60-975 .
60-976 . if (A ge B)
60-977 . {
60-978 . A = B + C;
60-979 . D = E + F;
60-980 . }
60-981 .
60-982 .
60-983 . if (A lt B)
60-984 . {
60-985 . A = B + C;
60-986 . D = E + F;
60-987 . }
60-988 .
60-989 . A = B-C;
60-990 . A = B-C;
60-991 . /* LE SV TOC-3040 this is a wxp-02.4.47 req to record*/
60-992 . A = B-C;
60-993 .
60-994 . if (A lt B)
60-995 . {
60-996 . A = B + C;
60-997 . D = E + F;
60-998 . }
60-999 .
60-1000 .
60-1001 . if (A != B)
60-1002 . {
60-1003 . A = B + C;
60-1004 . D = E + F;
60-1005 . }
60-1006 .
60-1007 . // max LOC 49
60-1008 .
60-1009 . }
60-1010 .
60-1011 .
60-1012 . /*
60-1013 . -----------------------------------------------------------------------------
60-1014 . --| NAME: wxp.2.5
60-1015 . --|
60-1016 . --| ABSTRACT:
60-1017 . --| This function does wxp stuff.
60-1018 . --|
60-1019 . --| RETURNS:
60-1020 . --| NONE.
60-1021 . --|
60-1022 . ----------------------------------------------------------------------------
60-1023 . */
60-1024 . static void wxp.2.5(void)
60-1025 . {
60-1026 . A = B+C;
60-1027 . A = B*C;
60-1028 . A = B+C;
60-1029 . A = B-C;
60-1030 .
60-1031 . switch (wxp stuff)
60-1032 . {
60-1033 . case one:
60-1034 . {
60-1035 . run_this;
60-1036 . break;
60-1037 . }
60-1038 . case two:
60-1039 . {
60-1040 . run_this;
60-1041 . break;
60-1042 . }
60-1043 . // missing default
60-1044 . }
60-1045 .
60-1046 .
60-1047 . if (A le B)
60-1048 . {
60-1049 . A = B + C;
60-1050 . D = E + F;
60-1051 . }
60-1052 .
60-1053 . A = B/C;
60-1054 . A = B+C;
60-1055 . A = B-C;
60-1056 .
60-1057 . if (A < B)
60-1058 . {
60-1059 . A = B + C;
60-1060 . D = E + F;
60-1061 . }
60-1062 .
60-1063 . /* LE SV TOC-3041 this is a wxp-02.5.10 req to assign*/
60-1064 . A = B+C;
60-1065 . A = B/C;
60-1066 . A = B+C;
60-1067 . A = B*C;
60-1068 . // max LOC 13
60-1069 .
60-1070 . }
60-1071 .
60-1072 .
60-1073 . /*
60-1074 . -----------------------------------------------------------------------------
60-1075 . --| NAME: wxp.2.6
60-1076 . --|
60-1077 . --| ABSTRACT:
60-1078 . --| This function does wxp stuff.
60-1079 . --|
60-1080 . --| RETURNS:
60-1081 . --| NONE.
60-1082 . --|
60-1083 . ----------------------------------------------------------------------------
60-1084 . */
60-1085 . static void wxp.2.6(void)
60-1086 . {
60-1087 . A = B*C;
60-1088 . /* LE SV TOC-3042 this is a wxp-02.6.2 req to store*/
60-1089 . A = B+C;
60-1090 .
60-1091 . if (A ge B)
60-1092 . {
60-1093 . A = B + C;
60-1094 . D = E + F;
60-1095 . }
60-1096 .
60-1097 . A = B-C;
60-1098 . A = B+C;
60-1099 . A = 0x0003;
60-1100 . A = B+C;
60-1101 . A = B-C;
60-1102 . A = B-C;
60-1103 . A = B/C;
60-1104 . A = B-C;
60-1105 . A = B/C;
60-1106 . A = B+C;
60-1107 . A = 0x0007;
60-1108 . A = B*C;
60-1109 . A = B+C;
60-1110 .
60-1111 . if (A lt B)
60-1112 . {
60-1113 . A = B + C;
60-1114 . D = E + F;
60-1115 . }
60-1116 .
60-1117 . A = B-C;
60-1118 . A = B-C;
60-1119 .
60-1120 . if (A gt B)
60-1121 . {
60-1122 . A = B + C;
60-1123 . D = E + F;
60-1124 . }
60-1125 .
60-1126 . A = B+C;
60-1127 .
60-1128 . if (A ge B)
60-1129 . {
60-1130 . A = B + C;
60-1131 . D = E + F;
60-1132 . }
60-1133 .
60-1134 . A = B*C;
60-1135 .
60-1136 . if (A le B)
60-1137 . {
60-1138 . A = B + C;
60-1139 . D = E + F;
60-1140 . }
60-1141 .
60-1142 . A = B-C;
60-1143 .
60-1144 . if (A > = B)
60-1145 . {
60-1146 . A = B + C;
60-1147 . D = E + F;
60-1148 . }
60-1149 .
60-1150 .
60-1151 . if (A lt B)
60-1152 . {
60-1153 . A = B + C;
60-1154 . D = E + F;
60-1155 . }
60-1156 .
60-1157 . A = B+C;
60-1158 . A = B-C;
60-1159 .
60-1160 . switch (wxp stuff)
60-1161 . {
60-1162 . case one:
60-1163 . {
60-1164 . run_this;
60-1165 . break;
60-1166 . }
60-1167 . case two:
60-1168 . {
60-1169 . run_this;
60-1170 . break;
60-1171 . }
60-1172 . default:
60-1173 . {
60-1174 . SwError;
60-1175 . }
60-1176 . }
60-1177 .
60-1178 . A = B-C;
60-1179 . A = B*C;
60-1180 .
60-1181 . if (A le B)
60-1182 . {
60-1183 . A = B + C;
60-1184 . D = E + F;
60-1185 . }
60-1186 .
60-1187 . A = B-C;
60-1188 .
60-1189 . if (A ge B)
60-1190 . {
60-1191 . A = B + C;
60-1192 . D = E + F;
60-1193 . }
60-1194 .
60-1195 . A = B*C;
60-1196 .
60-1197 . switch (wxp stuff)
60-1198 . {
60-1199 . case one:
60-1200 . {
60-1201 . run_this;
60-1202 . break;
60-1203 . }
60-1204 . case two:
60-1205 . {
60-1206 . run_this;
60-1207 . break;
60-1208 . }
60-1209 . default:
60-1210 . {
60-1211 . SwError;
60-1212 . }
60-1213 . }
60-1214 .
60-1215 .
60-1216 . if (A > = B)
60-1217 . {
60-1218 . A = B + C;
60-1219 . D = E + F;
60-1220 . }
60-1221 .
60-1222 . A = B/C;
60-1223 . A = B/C;
60-1224 . A = B/C;
60-1225 .
60-1226 . if (A ne B)
60-1227 . {
60-1228 . A = B + C;
60-1229 . D = E + F;
60-1230 . }
60-1231 .
60-1232 . A = B*C;
60-1233 . A = B+C;
60-1234 . A = B/C;
60-1235 .
60-1236 . if (A lt B)
60-1237 . {
60-1238 . A = B + C;
60-1239 . D = E + F;
60-1240 . }
60-1241 .
60-1242 . A = B-C;
60-1243 . A = B*C;
60-1244 . A = B/C;
60-1245 . A = B/C;
60-1246 . A = B/C;
60-1247 .
60-1248 . if (A eq B)
60-1249 . {
60-1250 . A = B + C;
60-1251 . D = E + F;
60-1252 . }
60-1253 .
60-1254 . /* LE SV TOC-3043 this is a wxp-02.6.51 req to increment*/
60-1255 . A = B+C;
60-1256 . A = B-C;
60-1257 . A = B/C;
60-1258 . A = B-C;
60-1259 . A = B/C;
60-1260 .
60-1261 . switch (wxp stuff)
60-1262 . {
60-1263 . case one:
60-1264 . {
60-1265 . run_this;
60-1266 . break;
60-1267 . }
60-1268 . case two:
60-1269 . {
60-1270 . run_this;
60-1271 . break;
60-1272 . }
60-1273 . default:
60-1274 . {
60-1275 . SwError;
60-1276 . }
60-1277 . }
60-1278 .
60-1279 . A = B-C;
60-1280 .
60-1281 . if (A > B)
60-1282 . {
60-1283 . A = B + C;
60-1284 . D = E + F;
60-1285 . }
60-1286 .
60-1287 . A = B+C;
60-1288 . A = B/C;
60-1289 . A = B*C;
60-1290 .
60-1291 . if (A > B)
60-1292 . {
60-1293 . A = B + C;
60-1294 . D = E + F;
60-1295 . }
60-1296 .
60-1297 .
60-1298 . switch (wxp stuff)
60-1299 . {
60-1300 . case one:
60-1301 . {
60-1302 . run_this;
60-1303 . break;
60-1304 . }
60-1305 . case two:
60-1306 . {
60-1307 . run_this;
60-1308 . break;
60-1309 . }
60-1310 . default:
60-1311 . {
60-1312 . SwError;
60-1313 . }
60-1314 . }
60-1315 .
60-1316 . A = B-C;
60-1317 . A = B+C;
60-1318 .
60-1319 . if (A le B)
60-1320 . {
60-1321 . A = B + C;
60-1322 . D = E + F;
60-1323 . }
60-1324 .
60-1325 . A = B/C;
60-1326 . A = B+C;
60-1327 . // TBS - I need to figure this out
60-1328 . A = B/C;
60-1329 . A = B-C;
60-1330 .
60-1331 . if (A > B)
60-1332 . {
60-1333 . A = B + C;
60-1334 . D = E + F;
60-1335 . }
60-1336 .
60-1337 . A = B/C;
60-1338 .
60-1339 . if (A == B)
60-1340 . {
60-1341 . A = B + C;
60-1342 . D = E + F;
60-1343 . }
60-1344 .
60-1345 .
60-1346 . switch (wxp stuff)
60-1347 . {
60-1348 . case one:
60-1349 . {
60-1350 . run_this;
60-1351 . break;
60-1352 . }
60-1353 . case two:
60-1354 . {
60-1355 . run_this;
60-1356 . break;
60-1357 . }
60-1358 . default:
60-1359 . {
60-1360 . SwError;
60-1361 . }
60-1362 . }
60-1363 .
60-1364 . A = B+C;
60-1365 . free(FreePtr);
60-1366 . A = B/C;
60-1367 . A = B/C;
60-1368 . rcv_buffer = (U16 *) alloc(size+1);
60-1369 .
60-1370 . if (A le B)
60-1371 . {
60-1372 . A = B + C;
60-1373 . D = E + F;
60-1374 . }
60-1375 .
60-1376 . // max LOC 78
60-1377 .
60-1378 . }
60-1379 .
60-1380 .
60-1381 . /*
60-1382 . -----------------------------------------------------------------------------
60-1383 . --| NAME: wxp.2.7
60-1384 . --|
60-1385 . --| ABSTRACT:
60-1386 . --| This function does wxp stuff.
60-1387 . --|
60-1388 . --| RETURNS:
60-1389 . --| NONE.
60-1390 . --|
60-1391 . ----------------------------------------------------------------------------
60-1392 . */
60-1393 . static void wxp.2.7(void)
60-1394 . {
60-1395 .
60-1396 . if (A < B)
60-1397 . {
60-1398 . A = B + C;
60-1399 . D = E + F;
60-1400 . }
60-1401 .
60-1402 .
60-1403 . if (A < = B)
60-1404 . {
60-1405 . A = B + C;
60-1406 . D = E + F;
60-1407 . }
60-1408 .
60-1409 . A = B+C;
60-1410 . /* LE SV TOC-3044 this is a wxp-02.7.4 req to validate*/
60-1411 .
60-1412 . if (A lt B)
60-1413 . {
60-1414 . A = B + C;
60-1415 . D = E + F;
60-1416 . }
60-1417 .
60-1418 .
60-1419 . if (A != B)
60-1420 . {
60-1421 . A = B + C;
60-1422 . D = E + F;
60-1423 . }
60-1424 .
60-1425 . A = B-C;
60-1426 . A = B-C;
60-1427 .
60-1428 . switch (wxp stuff)
60-1429 . {
60-1430 . case one:
60-1431 . {
60-1432 . run_this;
60-1433 . break;
60-1434 . }
60-1435 . case two:
60-1436 . {
60-1437 . run_this;
60-1438 . break;
60-1439 . }
60-1440 . default:
60-1441 . {
60-1442 . SwError;
60-1443 . }
60-1444 . }
60-1445 .
60-1446 .
60-1447 . if (A < B)
60-1448 . {
60-1449 . A = B + C;
60-1450 . D = E + F;
60-1451 . }
60-1452 .
60-1453 . /* LE SV TOC-3045 this is a wxp-02.7.10 req to halt*/
60-1454 . A = B*C;
60-1455 . /* LE SV TOC-3046 this is a wxp-02.7.11 req to verify*/
60-1456 . A = B-C;
60-1457 . A = B/C;
60-1458 .
60-1459 . if (A < B)
60-1460 . {
60-1461 . A = B + C;
60-1462 . D = E + F;
60-1463 . }
60-1464 .
60-1465 . A = B+C;
60-1466 .
60-1467 . if (A eq B)
60-1468 . {
60-1469 . A = B + C;
60-1470 . D = E + F;
60-1471 . }
60-1472 .
60-1473 . A = B+C;
60-1474 . A = B-C;
60-1475 . A = B*C;
60-1476 . A = B*C;
60-1477 . A = B+C;
60-1478 . A = B/C;
60-1479 . A = B+C;
60-1480 . A = B/C;
60-1481 . A = B+C;
60-1482 . A = B+C;
60-1483 .
60-1484 . if (A lt B)
60-1485 . {
60-1486 . A = B + C;
60-1487 . D = E + F;
60-1488 . }
60-1489 .
60-1490 .
60-1491 . if (A lt B)
60-1492 . {
60-1493 . A = B + C;
60-1494 . D = E + F;
60-1495 . }
60-1496 .
60-1497 .
60-1498 . if (A eq B)
60-1499 . {
60-1500 . A = B + C;
60-1501 . D = E + F;
60-1502 . }
60-1503 .
60-1504 . A = B-C;
60-1505 .
60-1506 . if (A > = B)
60-1507 . {
60-1508 . A = B + C;
60-1509 . D = E + F;
60-1510 . }
60-1511 .
60-1512 . // max LOC 30
60-1513 .
60-1514 . }
60-1515 .
60-1516 .
60-1517 . /*
60-1518 . -----------------------------------------------------------------------------
60-1519 . --| NAME: wxp.2.8
60-1520 . --|
60-1521 . --| ABSTRACT:
60-1522 . --| This function does wxp stuff.
60-1523 . --|
60-1524 . --| RETURNS:
60-1525 . --| NONE.
60-1526 . --|
60-1527 . ----------------------------------------------------------------------------
60-1528 . */
60-1529 . static void wxp.2.8(void)
60-1530 . {
60-1531 . A = B+C;
60-1532 . A = B*C;
60-1533 .
60-1534 . if (A eq B)
60-1535 . {
60-1536 . A = B + C;
60-1537 . D = E + F;
60-1538 . }
60-1539 .
60-1540 . A = B-C;
60-1541 .
60-1542 . if (A le B)
60-1543 . {
60-1544 . A = B + C;
60-1545 . D = E + F;
60-1546 . }
60-1547 .
60-1548 . A = B+C;
60-1549 . A = B+C;
60-1550 . A = B*C;
60-1551 . A = B-C;
60-1552 . A = 0x0009;
60-1553 . A = B+C;
60-1554 .
60-1555 . switch (wxp stuff)
60-1556 . {
60-1557 . case one:
60-1558 . {
60-1559 . run_this;
60-1560 . // missing break
60-1561 . }
60-1562 . case two:
60-1563 . {
60-1564 . run_this;
60-1565 . break;
60-1566 . }
60-1567 . default:
60-1568 . {
60-1569 . SwError;
60-1570 . }
60-1571 . }
60-1572 .
60-1573 .
60-1574 . if (A > = B)
60-1575 . {
60-1576 . A = B + C;
60-1577 . D = E + F;
60-1578 . }
60-1579 .
60-1580 . rcv_buffer = (U16 *) alloc(size+1);
60-1581 . A = B-C;
60-1582 . A = B*C;
60-1583 . A = B*C;
60-1584 .
60-1585 . if (A ne B)
60-1586 . {
60-1587 . A = B + C;
60-1588 . D = E + F;
60-1589 . }
60-1590 .
60-1591 . A = B/C;
60-1592 .
60-1593 . switch (wxp stuff)
60-1594 . {
60-1595 . case one:
60-1596 . {
60-1597 . run_this;
60-1598 . break;
60-1599 . }
60-1600 . case two:
60-1601 . {
60-1602 . run_this;
60-1603 . break;
60-1604 . }
60-1605 . default:
60-1606 . {
60-1607 . SwError;
60-1608 . }
60-1609 . }
60-1610 .
60-1611 .
60-1612 . if (A gt B)
60-1613 . {
60-1614 . A = B + C;
60-1615 . D = E + F;
60-1616 . }
60-1617 .
60-1618 . A = B+C;
60-1619 . A = B*C;
60-1620 . A = B/C;
60-1621 . A = B-C;
60-1622 . A = B*C;
60-1623 .
60-1624 . if (A < = B)
60-1625 . {
60-1626 . A = B + C;
60-1627 . D = E + F;
60-1628 . }
60-1629 .
60-1630 . A = B+C;
60-1631 . A = B-C;
60-1632 . A = B-C;
60-1633 . A = B/C;
60-1634 . A = B/C;
60-1635 .
60-1636 . if (A < B)
60-1637 . {
60-1638 . A = B + C;
60-1639 . D = E + F;
60-1640 . }
60-1641 .
60-1642 . /* LE SV TOC-3047 this is a wxp-02.8.31 req to disable*/
60-1643 . A = B+C;
60-1644 . A = 0x0002;
60-1645 . A = B+C;
60-1646 .
60-1647 . if (A ne B)
60-1648 . {
60-1649 . A = B + C;
60-1650 . D = E + F;
60-1651 . }
60-1652 .
60-1653 .
60-1654 . if (A ge B)
60-1655 . {
60-1656 . A = B + C;
60-1657 . D = E + F;
60-1658 . }
60-1659 .
60-1660 . goto error;
60-1661 . A = B+C;
60-1662 .
60-1663 . if (A == B)
60-1664 . {
60-1665 . A = B + C;
60-1666 . D = E + F;
60-1667 . }
60-1668 .
60-1669 . A = B+C;
60-1670 . A = B-C;
60-1671 . A = B/C;
60-1672 . A = B+C;
60-1673 . A = B/C;
60-1674 .
60-1675 . if (A == B)
60-1676 . {
60-1677 . A = B + C;
60-1678 . D = E + F;
60-1679 . }
60-1680 .
60-1681 .
60-1682 . if (A le B)
60-1683 . {
60-1684 . A = B + C;
60-1685 . D = E + F;
60-1686 . }
60-1687 .
60-1688 . A = B*C;
60-1689 . A = B-C;
60-1690 .
60-1691 . if (A < = B)
60-1692 . {
60-1693 . A = B + C;
60-1694 . D = E + F;
60-1695 . }
60-1696 .
60-1697 . A = B+C;
60-1698 . A = B*C;
60-1699 . A = B+C;
60-1700 . A = B*C;
60-1701 . /* LE SV TOC-3048 this is a wxp-02.8.51 req to compare*/
60-1702 . A = B-C;
60-1703 . A = B/C;
60-1704 .
60-1705 . if (A le B)
60-1706 . {
60-1707 . A = B + C;
60-1708 . D = E + F;
60-1709 . }
60-1710 .
60-1711 . A = B*C;
60-1712 .
60-1713 . if (A ne B)
60-1714 . {
60-1715 . A = B + C;
60-1716 . D = E + F;
60-1717 . }
60-1718 .
60-1719 . A = B*C;
60-1720 . A = B*C;
60-1721 .
60-1722 . if (A != B)
60-1723 . {
60-1724 . A = B + C;
60-1725 . D = E + F;
60-1726 . }
60-1727 .
60-1728 .
60-1729 . if (A le B)
60-1730 . {
60-1731 . A = B + C;
60-1732 . D = E + F;
60-1733 . }
60-1734 .
60-1735 .
60-1736 . if (A != B)
60-1737 . {
60-1738 . A = B + C;
60-1739 . D = E + F;
60-1740 . }
60-1741 .
60-1742 . A = B*C;
60-1743 . A = B-C;
60-1744 . A = B+C;
60-1745 . A = B-C;
60-1746 . A = B*C;
60-1747 . A = B*C;
60-1748 . A = B/C;
60-1749 . A = B+C;
60-1750 . A = B+C;
60-1751 . A = B-C;
60-1752 . A = B+C;
60-1753 . // max LOC 71
60-1754 .
60-1755 . }
60-1756 .
60-1757 .
60-1758 . /*
60-1759 . -----------------------------------------------------------------------------
60-1760 . --| NAME: wxp.2.9
60-1761 . --|
60-1762 . --| ABSTRACT:
60-1763 . --| This function does wxp stuff.
60-1764 . --|
60-1765 . --| RETURNS:
60-1766 . --| NONE.
60-1767 . --|
60-1768 . ----------------------------------------------------------------------------
60-1769 . */
60-1770 . static void wxp.2.9(void)
60-1771 . {
60-1772 .
60-1773 . switch (wxp stuff)
60-1774 . {
60-1775 . case one:
60-1776 . {
60-1777 . run_this;
60-1778 . break;
60-1779 . }
60-1780 . case two:
60-1781 . {
60-1782 . run_this;
60-1783 . break;
60-1784 . }
60-1785 . default:
60-1786 . {
60-1787 . SwError;
60-1788 . }
60-1789 . }
60-1790 .
60-1791 .
60-1792 . if (A ge B)
60-1793 . {
60-1794 . A = B + C;
60-1795 . D = E + F;
60-1796 . }
60-1797 .
60-1798 . A = B-C;
60-1799 . A = B+C;
60-1800 . A = B-C;
60-1801 .
60-1802 . if (A == B)
60-1803 . {
60-1804 . A = B + C;
60-1805 . D = E + F;
60-1806 . }
60-1807 .
60-1808 .
60-1809 . if (A ge B)
60-1810 . {
60-1811 . A = B + C;
60-1812 . D = E + F;
60-1813 . }
60-1814 .
60-1815 . A = B*C;
60-1816 .
60-1817 . if (A lt B)
60-1818 . {
60-1819 . A = B + C;
60-1820 . D = E + F;
60-1821 . }
60-1822 .
60-1823 . A = B/C;
60-1824 . A = B/C;
60-1825 . A = B-C;
60-1826 .
60-1827 . if (A > = B)
60-1828 . {
60-1829 . A = B + C;
60-1830 . D = E + F;
60-1831 . }
60-1832 .
60-1833 . A = B+C;
60-1834 .
60-1835 . if (A ge B)
60-1836 . {
60-1837 . A = B + C;
60-1838 . D = E + F;
60-1839 . }
60-1840 .
60-1841 . A = B*C;
60-1842 . A = B+C;
60-1843 .
60-1844 . if (A ge B)
60-1845 . {
60-1846 . A = B + C;
60-1847 . D = E + F;
60-1848 . }
60-1849 .
60-1850 . /* LE SV TOC-3049 this is a wxp-02.9.19 req to translate*/
60-1851 . A = B*C;
60-1852 . /* LE SV TOC-3050 this is a wxp-02.9.20 req to store*/
60-1853 . A = B+C;
60-1854 . A = B-C;
60-1855 .
60-1856 . if (A > B)
60-1857 . {
60-1858 . A = B + C;
60-1859 . D = E + F;
60-1860 . }
60-1861 .
60-1862 . A = B-C;
60-1863 . A = B/C;
60-1864 .
60-1865 . if (A < = B)
60-1866 . {
60-1867 . A = B + C;
60-1868 . D = E + F;
60-1869 . }
60-1870 .
60-1871 . A = B/C;
60-1872 . /* LE SV TOC-3051 this is a wxp-02.9.27 req to fail*/
60-1873 . A = B-C;
60-1874 . A = B-C;
60-1875 . A = B+C;
60-1876 . A = B/C;
60-1877 . A = B/C;
60-1878 . A = 0x0007;
60-1879 . A = B*C;
60-1880 . A = B*C;
60-1881 . /* LE SV TOC-3052 this is a wxp-02.9.34 req to inhibit*/
60-1882 . A = B/C;
60-1883 .
60-1884 . if (A > = B)
60-1885 . {
60-1886 . A = B + C;
60-1887 . D = E + F;
60-1888 . }
60-1889 .
60-1890 . A = B+C;
60-1891 . A = 0x0001;
60-1892 . A = B+C;
60-1893 . /* LE SV TOC-3053 this is a wxp-02.9.38 req to inhibit*/
60-1894 .
60-1895 . if (A != B)
60-1896 . {
60-1897 . A = B + C;
60-1898 . D = E + F;
60-1899 . }
60-1900 .
60-1901 . A = B-C;
60-1902 .
60-1903 . if (A lt B)
60-1904 . {
60-1905 . A = B + C;
60-1906 . D = E + F;
60-1907 . }
60-1908 .
60-1909 . A = B/C;
60-1910 . A = B*C;
60-1911 .
60-1912 . switch (wxp stuff)
60-1913 . {
60-1914 . case one:
60-1915 . {
60-1916 . run_this;
60-1917 . break;
60-1918 . }
60-1919 . case two:
60-1920 . {
60-1921 . run_this;
60-1922 . break;
60-1923 . }
60-1924 . default:
60-1925 . {
60-1926 . SwError;
60-1927 . }
60-1928 . }
60-1929 .
60-1930 . // max LOC 43
60-1931 .
60-1932 . }
60-1933 .
60-1934 .
60-1935 . /*
60-1936 . -----------------------------------------------------------------------------
60-1937 . --| NAME: wxp.2.10
60-1938 . --|
60-1939 . --| ABSTRACT:
60-1940 . --| This function does wxp stuff.
60-1941 . --|
60-1942 . --| RETURNS:
60-1943 . --| NONE.
60-1944 . --|
60-1945 . ----------------------------------------------------------------------------
60-1946 . */
60-1947 . static void wxp.2.10(void)
60-1948 . {
60-1949 . A = B-C;
60-1950 . A = B-C;
60-1951 . A = B/C;
60-1952 . A = B+C;
60-1953 . A = B/C;
60-1954 . A = B*C;
60-1955 . A = B+C;
60-1956 . A = B+C;
60-1957 . A = B*C;
60-1958 . A = B-C;
60-1959 . /* LE SV TOC-3054 this is a wxp-02.10.11 req to translate*/
60-1960 . A = B/C;
60-1961 . A = B*C;
60-1962 . /* LE SV TOC-3055 this is a wxp-02.10.13 req to process*/
60-1963 .
60-1964 . if (A != B)
60-1965 . {
60-1966 . A = B + C;
60-1967 . D = E + F;
60-1968 . }
60-1969 .
60-1970 . /* LE SV TOC-3056 this is a wxp-02.10.14 req to reject*/
60-1971 . A = B-C;
60-1972 .
60-1973 . if (A > = B)
60-1974 . {
60-1975 . A = B + C;
60-1976 . D = E + F;
60-1977 . }
60-1978 .
60-1979 . A = B-C;
60-1980 .
60-1981 . if (A == B)
60-1982 . {
60-1983 . A = B + C;
60-1984 . D = E + F;
60-1985 . }
60-1986 .
60-1987 . A = B*C;
60-1988 . A = B/C;
60-1989 . A = B/C;
60-1990 . A = B*C;
60-1991 . A = B-C;
60-1992 .
60-1993 . if (A ge B)
60-1994 . {
60-1995 . A = B + C;
60-1996 . D = E + F;
60-1997 . }
60-1998 .
60-1999 .
60-2000 . if (A != B)
60-2001 . {
60-2002 . A = B + C;
60-2003 . D = E + F;
60-2004 . }
60-2005 .
60-2006 . A = B+C;
60-2007 . A = B-C;
60-2008 .
60-2009 . if (A < B)
60-2010 . {
60-2011 . A = B + C;
60-2012 . D = E + F;
60-2013 . }
60-2014 .
60-2015 .
60-2016 . if (A < B)
60-2017 . {
60-2018 . A = B + C;
60-2019 . D = E + F;
60-2020 . }
60-2021 .
60-2022 . /* LE SV TOC-3057 this is a wxp-02.10.29 req to halt*/
60-2023 .
60-2024 . if ($wxp stuff > $otherwxp stuff)
60-2025 . /* LE SV TOC-008 we really should log all error calls */
60-2026 . {
60-2027 . A = B + C;
60-2028 . }
60-2029 .
60-2030 . A = B/C;
60-2031 .
60-2032 . if (A > = B)
60-2033 . {
60-2034 . A = B + C;
60-2035 . D = E + F;
60-2036 . }
60-2037 .
60-2038 .
60-2039 . if (A le B)
60-2040 . {
60-2041 . A = B + C;
60-2042 . D = E + F;
60-2043 . }
60-2044 .
60-2045 . A = B/C;
60-2046 . A = B+C;
60-2047 . A = B+C;
60-2048 .
60-2049 . if (A < = B)
60-2050 . {
60-2051 . A = B + C;
60-2052 . D = E + F;
60-2053 . }
60-2054 .
60-2055 . A = B-C;
60-2056 . A = B/C;
60-2057 .
60-2058 . if (A == B)
60-2059 . {
60-2060 . A = B + C;
60-2061 . D = E + F;
60-2062 . }
60-2063 .
60-2064 . A = B-C;
60-2065 .
60-2066 . if (A ge B)
60-2067 . {
60-2068 . A = B + C;
60-2069 . D = E + F;
60-2070 . }
60-2071 .
60-2072 . A = B-C;
60-2073 . A = B/C;
60-2074 . // max LOC 42
60-2075 .
60-2076 . }
60-2077 .
60-2078 .
60-2079 . /*
60-2080 . -----------------------------------------------------------------------------
60-2081 . --| NAME: wxp.2.11
60-2082 . --|
60-2083 . --| ABSTRACT:
60-2084 . --| This function does wxp stuff.
60-2085 . --|
60-2086 . --| RETURNS:
60-2087 . --| NONE.
60-2088 . --|
60-2089 . ----------------------------------------------------------------------------
60-2090 . */
60-2091 . static void wxp.2.11(void)
60-2092 . {
60-2093 . A = B*C;
60-2094 . A = B*C;
60-2095 .
60-2096 . if (A ge B)
60-2097 . {
60-2098 . A = B + C;
60-2099 . D = E + F;
60-2100 . }
60-2101 .
60-2102 . A = B*C;
60-2103 . A = B*C;
60-2104 . A = 0x0006;
60-2105 .
60-2106 . if (A le B)
60-2107 . {
60-2108 . A = B + C;
60-2109 . D = E + F;
60-2110 . }
60-2111 .
60-2112 . A = B+C;
60-2113 . /* LE SV TOC-3058 this is a wxp-02.11.8 req to reject*/
60-2114 .
60-2115 . if (A < = B)
60-2116 . {
60-2117 . A = B + C;
60-2118 . D = E + F;
60-2119 . }
60-2120 .
60-2121 .
60-2122 . if (A < = B)
60-2123 . {
60-2124 . A = B + C;
60-2125 . D = E + F;
60-2126 . }
60-2127 .
60-2128 . A = B-C;
60-2129 . A = B-C;
60-2130 . A = B/C;
60-2131 . /* LE SV TOC-3059 this is a wxp-02.11.13 req to convert*/
60-2132 . A = B+C;
60-2133 .
60-2134 . if (A < = B)
60-2135 . {
60-2136 . A = B + C;
60-2137 . D = E + F;
60-2138 . }
60-2139 .
60-2140 .
60-2141 . if (A gt B)
60-2142 . {
60-2143 . A = B + C;
60-2144 . D = E + F;
60-2145 . }
60-2146 .
60-2147 .
60-2148 . if (A < B)
60-2149 . {
60-2150 . A = B + C;
60-2151 . D = E + F;
60-2152 . }
60-2153 .
60-2154 .
60-2155 . if (A lt B)
60-2156 . {
60-2157 . A = B + C;
60-2158 . D = E + F;
60-2159 . }
60-2160 .
60-2161 . A = B/C;
60-2162 . A = B-C;
60-2163 . A = B*C;
60-2164 .
60-2165 . if (A < B)
60-2166 . {
60-2167 . A = B + C;
60-2168 . D = E + F;
60-2169 . }
60-2170 .
60-2171 . A = B-C;
60-2172 . A = B-C;
60-2173 . A = B-C;
60-2174 . A = B/C;
60-2175 . A = (long)B + C;
60-2176 .
60-2177 . if (A gt B)
60-2178 . {
60-2179 . A = B + C;
60-2180 . D = E + F;
60-2181 . }
60-2182 .
60-2183 . /* LE SV TOC-3060 this is a wxp-02.11.27 req to call admin*/
60-2184 .
60-2185 . if (A == B)
60-2186 . {
60-2187 . A = B + C;
60-2188 . D = E + F;
60-2189 . }
60-2190 .
60-2191 . A = B*C;
60-2192 . A = B+C;
60-2193 . A = B-C;
60-2194 . A = B*C;
60-2195 .
60-2196 . /*
60-2197 . dead_block = C * D;
60-2198 . dead_block = E * F;
60-2199 . */
60-2200 .
60-2201 . A = B-C;
60-2202 .
60-2203 . if (A eq B)
60-2204 . {
60-2205 . A = B + C;
60-2206 . D = E + F;
60-2207 . }
60-2208 .
60-2209 . A = B+C;
60-2210 . A = B-C;
60-2211 . A = B+C;
60-2212 . A = B+C;
60-2213 . A = B*C;
60-2214 . A = B*C;
60-2215 .
60-2216 . switch (wxp stuff)
60-2217 . {
60-2218 . case one:
60-2219 . {
60-2220 . run_this;
60-2221 . break;
60-2222 . }
60-2223 . case two:
60-2224 . {
60-2225 . run_this;
60-2226 . break;
60-2227 . }
60-2228 . default:
60-2229 . {
60-2230 . SwError;
60-2231 . }
60-2232 . }
60-2233 .
60-2234 . A = B/C;
60-2235 .
60-2236 . if {
60-2237 . X = Y + Z;
60-2238 . }
60-2239 . else {
60-2240 . halt;
60-2241 . }
60-2242 .
60-2243 . A = B/C;
60-2244 . A = B*C;
60-2245 . // max LOC 43
60-2246 .
60-2247 . }
60-2248 .
60 60 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-02.c
61 61 Source: source/ft-app/ft-app-B1.1/wxp/wxp-03.c
61-0 . /*
61-1 . ----------------------------------------------------------------------------
61-2 . --| BEGIN PROLOGUE
61-3 . --|
61-4 . --| CLASSIFICATION: UNCLASSIFIED
61-5 . --|
61-6 . --| FILE NAME: wxp-03.c
61-7 . --|
61-8 . --| ABSTRACT:
61-9 . --| This file contains the 2 functions that do file wxp stuff.
61-10 . --|
61-11 . --| HISTORY:
61-12 . --| CCCQ_NAME:
61-13 . --| CCCQ_VER:
61-14 . --|
61-15 . --| END PROLOGUE
61-16 . ----------------------------------------------------------------------------
61-17 . */
61-18 .
61-19 . #include D;
61-20 .
61-21 .
61-22 .
61-23 . /*
61-24 . -----------------------------------------------------------------------------
61-25 . --| NAME: wxp.3.1
61-26 . --|
61-27 . --| ABSTRACT:
61-28 . --| This function does wxp stuff.
61-29 . --|
61-30 . --| RETURNS:
61-31 . --| NONE.
61-32 . --|
61-33 . ----------------------------------------------------------------------------
61-34 . */
61-35 . static void wxp.3.1(void)
61-36 . {
61-37 . A = B+C;
61-38 . A = B+C;
61-39 .
61-40 . if (A eq B)
61-41 . {
61-42 . A = B + C;
61-43 . D = E + F;
61-44 . }
61-45 .
61-46 .
61-47 . switch (wxp stuff)
61-48 . {
61-49 . case one:
61-50 . {
61-51 . run_this;
61-52 . break;
61-53 . }
61-54 . case two:
61-55 . {
61-56 . run_this;
61-57 . break;
61-58 . }
61-59 . default:
61-60 . {
61-61 . SwError;
61-62 . }
61-63 . }
61-64 .
61-65 . A = B*C;
61-66 . A = B/C;
61-67 .
61-68 . if (A le B)
61-69 . {
61-70 . A = B + C;
61-71 . D = E + F;
61-72 . }
61-73 .
61-74 . A = B+C;
61-75 . A = B/C;
61-76 . A = B/C;
61-77 . A = B*C;
61-78 . A = B+C;
61-79 .
61-80 . if (A == B)
61-81 . {
61-82 . A = B + C;
61-83 . D = E + F;
61-84 . }
61-85 .
61-86 . A = B-C;
61-87 . A = B/C;
61-88 . A = B+C;
61-89 . A = B*C;
61-90 .
61-91 . if (A le B)
61-92 . {
61-93 . A = B + C;
61-94 . D = E + F;
61-95 . }
61-96 .
61-97 .
61-98 . if (A > = B)
61-99 . {
61-100 . A = B + C;
61-101 . D = E + F;
61-102 . }
61-103 .
61-104 .
61-105 . if (A > B)
61-106 . {
61-107 . A = B + C;
61-108 . D = E + F;
61-109 . }
61-110 .
61-111 . A = B/C;
61-112 . A = B-C;
61-113 . A = B+C;
61-114 . // max LOC 23
61-115 .
61-116 . }
61-117 .
61-118 .
61-119 . /*
61-120 . -----------------------------------------------------------------------------
61-121 . --| NAME: wxp.3.2
61-122 . --|
61-123 . --| ABSTRACT:
61-124 . --| This function does wxp stuff.
61-125 . --|
61-126 . --| RETURNS:
61-127 . --| NONE.
61-128 . --|
61-129 . ----------------------------------------------------------------------------
61-130 . */
61-131 . static void wxp.3.2(void)
61-132 . {
61-133 . A = B/C;
61-134 . A = B+C;
61-135 .
61-136 . switch (wxp stuff)
61-137 . {
61-138 . case one:
61-139 . {
61-140 . run_this;
61-141 . break;
61-142 . }
61-143 . case two:
61-144 . {
61-145 . run_this;
61-146 . break;
61-147 . }
61-148 . default:
61-149 . {
61-150 . SwError;
61-151 . }
61-152 . }
61-153 .
61-154 .
61-155 . switch (wxp stuff)
61-156 . {
61-157 . case one:
61-158 . {
61-159 . run_this;
61-160 . break;
61-161 . }
61-162 . case two:
61-163 . {
61-164 . run_this;
61-165 . break;
61-166 . }
61-167 . default:
61-168 . {
61-169 . // missing error call
61-170 . }
61-171 . }
61-172 .
61-173 . A = B/C;
61-174 . /* LE SV TOC-3061 this is a wxp-03.2.5 req to increment*/
61-175 . A = B-C;
61-176 .
61-177 . switch (wxp stuff)
61-178 . {
61-179 . case one:
61-180 . {
61-181 . run_this;
61-182 . break;
61-183 . }
61-184 . case two:
61-185 . {
61-186 . run_this;
61-187 . break;
61-188 . }
61-189 . default:
61-190 . {
61-191 . SwError;
61-192 . }
61-193 . }
61-194 .
61-195 . A = B+C;
61-196 . A = B+C;
61-197 . A = B/C;
61-198 . A = B+C;
61-199 . A = B/C;
61-200 . A = B+C;
61-201 . A = B/C;
61-202 . rcv_buffer = (U16 *) alloc(size+1);
61-203 . A = B+C;
61-204 . A = B/C;
61-205 . A = B+C;
61-206 . /* LE SV TOC-3062 this is a wxp-03.2.17 req to call admin*/
61-207 . A = B-C;
61-208 . send_buffer = (U16 *) malloc(size+1);
61-209 . A = B+C;
61-210 . A = B*C;
61-211 . FreePtr = HmiStringPtr;
61-212 . A = B*C;
61-213 . A = B/C;
61-214 .
61-215 . if (A ne B)
61-216 . {
61-217 . A = B + C;
61-218 . D = E + F;
61-219 . }
61-220 .
61-221 . A = B-C;
61-222 . A = B+C;
61-223 . A = B*C;
61-224 . A = B*C;
61-225 . A = B+C;
61-226 . A = B-C;
61-227 .
61-228 . if (A != B)
61-229 . {
61-230 . A = B + C;
61-231 . D = E + F;
61-232 . }
61-233 .
61-234 . A = B*C;
61-235 . A = B*C;
61-236 .
61-237 . if (A != B)
61-238 . {
61-239 . A = B + C;
61-240 . D = E + F;
61-241 . }
61-242 .
61-243 .
61-244 . switch (wxp stuff)
61-245 . {
61-246 . case one:
61-247 . {
61-248 . switch (nested)
61-249 . {
61-250 . case:
61-251 . X = Y + Z;
61-252 . case:
61-253 . X = Y + Z;
61-254 . default:
61-255 . SwError;
61-256 . }
61-257 . }
61-258 . case two:
61-259 . {
61-260 . run_this;
61-261 . break;
61-262 . }
61-263 . default:
61-264 . {
61-265 . SwError;
61-266 . }
61-267 . }
61-268 .
61-269 . A = B/C;
61-270 . A = B+C;
61-271 . A = B*C;
61-272 . A = B*C;
61-273 . A = B*C;
61-274 . A = B-C;
61-275 .
61-276 . if (A ge B)
61-277 . {
61-278 . A = B + C;
61-279 . D = E + F;
61-280 . }
61-281 .
61-282 . A = B/C;
61-283 . A = B/C;
61-284 .
61-285 . if (A != B)
61-286 . {
61-287 . A = B + C;
61-288 . D = E + F;
61-289 . }
61-290 .
61-291 . /* LE SV TOC-3063 this is a wxp-03.2.43 req to verify*/
61-292 . A = B+C;
61-293 . A = B/C;
61-294 .
61-295 . if (A lt B)
61-296 . {
61-297 . A = B + C;
61-298 . D = E + F;
61-299 . }
61-300 .
61-301 . A = B-C;
61-302 .
61-303 . if (A ne B)
61-304 . {
61-305 . A = B + C;
61-306 . D = E + F;
61-307 . }
61-308 .
61-309 . A = B/C;
61-310 .
61-311 . if (A < B)
61-312 . {
61-313 . A = B + C;
61-314 . D = E + F;
61-315 . }
61-316 .
61-317 . A = B*C;
61-318 . A = B+C;
61-319 . /* LE SV TOC-3064 this is a wxp-03.2.52 req to reject*/
61-320 .
61-321 . if (A > = B)
61-322 . {
61-323 . A = B + C;
61-324 . D = E + F;
61-325 . }
61-326 .
61-327 . A = B/C;
61-328 .
61-329 . if {
61-330 . X = Y + Z;
61-331 . }
61-332 . else {
61-333 . halt;
61-334 . }
61-335 .
61-336 . A = B/C;
61-337 . A = B+C;
61-338 . A = B-C;
61-339 . A = B+C;
61-340 . A = B-C;
61-341 . A = B+C;
61-342 . A = B+C;
61-343 . A = B/C;
61-344 . A = B-C;
61-345 . A = B-C;
61-346 . A = B*C;
61-347 . A = B*C;
61-348 . A = B*C;
61-349 .
61-350 . if (A lt B)
61-351 . {
61-352 . A = B + C;
61-353 . D = E + F;
61-354 . }
61-355 .
61-356 .
61-357 . if {
61-358 . X = Y + Z;
61-359 . }
61-360 . else {
61-361 . halt;
61-362 . }
61-363 .
61-364 .
61-365 . if (A lt B)
61-366 . {
61-367 . A = B + C;
61-368 . D = E + F;
61-369 . }
61-370 .
61-371 . A = B/C;
61-372 .
61-373 . if (A eq B)
61-374 . {
61-375 . A = B + C;
61-376 . D = E + F;
61-377 . }
61-378 .
61-379 . A = B+C;
61-380 . A = B/C;
61-381 . A = B-C;
61-382 . // max LOC 73
61-383 .
61-384 . }
61-385 .
61 61 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-03.c
62 62 Source: source/ft-app/ft-app-B1.1/wxp/wxp-04.c
62-0 .
62-1 .
62-2 . char D;
62-3 . #include C;
62-4 . #include A;
62-5 . #include B;
62-6 . #define A;
62-7 . char D;
62-8 .
62-9 .
62-10 .
62-11 . /*
62-12 . -----------------------------------------------------------------------------
62-13 . --| NAME: wxp.4.1
62-14 . --|
62-15 . --| ABSTRACT:
62-16 . --| This function does wxp stuff.
62-17 . --|
62-18 . --| RETURNS:
62-19 . --| NONE.
62-20 . --|
62-21 . ----------------------------------------------------------------------------
62-22 . */
62-23 . static void wxp.4.1(void)
62-24 . {
62-25 . /* LE SV TOC-3065 this is a wxp-04.1.1 req to check pSOS*/
62-26 . A = B+C;
62-27 .
62-28 . if (A ne B)
62-29 . {
62-30 . A = B + C;
62-31 . D = E + F;
62-32 . }
62-33 .
62-34 . A = B/C;
62-35 .
62-36 . if (A lt B)
62-37 . {
62-38 . A = B + C;
62-39 . D = E + F;
62-40 . }
62-41 .
62-42 .
62-43 . if (A < B)
62-44 . {
62-45 . A = B + C;
62-46 . D = E + F;
62-47 . }
62-48 .
62-49 . A = B+C;
62-50 .
62-51 . switch (wxp stuff)
62-52 . {
62-53 . case one:
62-54 . {
62-55 . run_this;
62-56 . break;
62-57 . }
62-58 . case two:
62-59 . {
62-60 . run_this;
62-61 . break;
62-62 . }
62-63 . default:
62-64 . {
62-65 . SwError;
62-66 . }
62-67 . }
62-68 .
62-69 . A = B+C;
62-70 . A = B+C;
62-71 .
62-72 . if (A > B)
62-73 . {
62-74 . A = B + C;
62-75 . D = E + F;
62-76 . }
62-77 .
62-78 .
62-79 . if (A < = B)
62-80 . {
62-81 . A = B + C;
62-82 . D = E + F;
62-83 . }
62-84 .
62-85 . A = B+C;
62-86 . A = B*C;
62-87 . A = B/C;
62-88 . A = B-C;
62-89 . A = B-C;
62-90 . A = B-C;
62-91 .
62-92 . if (A ge B)
62-93 . {
62-94 . A = B + C;
62-95 . D = E + F;
62-96 . }
62-97 .
62-98 . A = B+C;
62-99 .
62-100 . if (A gt B)
62-101 . {
62-102 . A = B + C;
62-103 . D = E + F;
62-104 . }
62-105 .
62-106 . A = B-C;
62-107 . A = B/C;
62-108 . A = B/C;
62-109 .
62-110 . if (A > = B)
62-111 . {
62-112 . A = B + C;
62-113 . D = E + F;
62-114 . }
62-115 .
62-116 .
62-117 . if (A < = B)
62-118 . {
62-119 . A = B + C;
62-120 . D = E + F;
62-121 . }
62-122 .
62-123 . A = B*C;
62-124 . A = B*C;
62-125 .
62-126 . if (A < = B)
62-127 . {
62-128 . A = B + C;
62-129 . D = E + F;
62-130 . }
62-131 .
62-132 . A = B+C;
62-133 .
62-134 . if (A eq B)
62-135 . {
62-136 . A = B + C;
62-137 . D = E + F;
62-138 . }
62-139 .
62-140 . A = B-C;
62-141 . /* LE SV TOC-3066 this is a wxp-04.1.32 req to call admin*/
62-142 . A = B/C;
62-143 . A = B-C;
62-144 . A = B/C;
62-145 . A = B+C;
62-146 . A = B/C;
62-147 .
62-148 . switch (wxp stuff)
62-149 . {
62-150 . case one:
62-151 . {
62-152 . run_this;
62-153 . break;
62-154 . }
62-155 . case two:
62-156 . {
62-157 . run_this;
62-158 . break;
62-159 . }
62-160 . default:
62-161 . {
62-162 . SwError;
62-163 . }
62-164 . }
62-165 .
62-166 . A = B*C;
62-167 . A = B/C;
62-168 . A = B/C;
62-169 . send_buffer = (U16 *) malloc(size+1);
62-170 . A = B*C;
62-171 . /* LE SV TOC-3067 this is a wxp-04.1.42 req to convert*/
62-172 . A = B-C;
62-173 .
62-174 . if (A ge B)
62-175 . {
62-176 . A = B + C;
62-177 . D = E + F;
62-178 . }
62-179 .
62-180 . A = B*C;
62-181 . A = B-C;
62-182 .
62-183 . if (A == B)
62-184 . {
62-185 . A = B + C;
62-186 . D = E + F;
62-187 . }
62-188 .
62-189 .
62-190 . switch (wxp stuff)
62-191 . {
62-192 . case:
62-193 . case:
62-194 . // stacked case statements but only if there is a new line in between
62-195 .
62-196 . case:
62-197 . case:
62-198 . case:
62-199 . {
62-200 . run_this;
62-201 . break;
62-202 . }
62-203 . default:
62-204 . {
62-205 . halt;
62-206 . }
62-207 . }
62-208 .
62-209 . A = B*C;
62-210 .
62-211 . if (A ge B)
62-212 . {
62-213 . A = B + C;
62-214 . D = E + F;
62-215 . }
62-216 .
62-217 . A = B/C;
62-218 . A = B-C;
62-219 . A = B*C;
62-220 . A = B/C;
62-221 . A = B/C;
62-222 . A = B/C;
62-223 . A = B-C;
62-224 . A = B+C;
62-225 . A = B/C;
62-226 .
62-227 . if (A > = B)
62-228 . {
62-229 . A = B + C;
62-230 . D = E + F;
62-231 . }
62-232 .
62-233 .
62-234 . if (A != B)
62-235 . {
62-236 . A = B + C;
62-237 . D = E + F;
62-238 . }
62-239 .
62-240 . A = B-C;
62-241 . /* LE SV TOC-3068 this is a wxp-04.1.61 req to verify*/
62-242 . A = B/C;
62-243 . A = B*C;
62-244 .
62-245 . if (A gt B)
62-246 . {
62-247 . A = B + C;
62-248 . D = E + F;
62-249 . }
62-250 .
62-251 . A = B/C;
62-252 .
62-253 . if (A ge B)
62-254 . {
62-255 . A = B + C;
62-256 . D = E + F;
62-257 . }
62-258 .
62-259 . A = B+C;
62-260 . A = B/C;
62-261 . A = B-C;
62-262 . A = B+C;
62-263 . A = B/C;
62-264 . A = B+C;
62-265 . A = B*C;
62-266 .
62-267 . if (A < = B)
62-268 . {
62-269 . A = B + C;
62-270 . D = E + F;
62-271 . }
62-272 .
62-273 . A = B-C;
62-274 . // max LOC 74
62-275 .
62-276 . }
62-277 .
62-278 .
62-279 . /*
62-280 . -----------------------------------------------------------------------------
62-281 . --| NAME: wxp.4.2
62-282 . --|
62-283 . --| ABSTRACT:
62-284 . --| This function does wxp stuff.
62-285 . --|
62-286 . --| RETURNS:
62-287 . --| NONE.
62-288 . --|
62-289 . ----------------------------------------------------------------------------
62-290 . */
62-291 . static void wxp.4.2(void)
62-292 . {
62-293 . A = B+C;
62-294 .
62-295 . if (A != B)
62-296 . {
62-297 . A = B + C;
62-298 . D = E + F;
62-299 . }
62-300 .
62-301 .
62-302 . switch (wxp stuff)
62-303 . {
62-304 . case one:
62-305 . {
62-306 . run_this;
62-307 . break;
62-308 . }
62-309 . case two:
62-310 . {
62-311 . run_this;
62-312 . break;
62-313 . }
62-314 . default:
62-315 . {
62-316 . SwError;
62-317 . }
62-318 . }
62-319 .
62-320 . A = B+C;
62-321 . A = B+C;
62-322 . /* LE SV TOC-3069 this is a wxp-04.2.6 req to detect error*/
62-323 . A = B/C;
62-324 . A = B/C;
62-325 .
62-326 . if (A == B)
62-327 . {
62-328 . A = B + C;
62-329 . D = E + F;
62-330 . }
62-331 .
62-332 .
62-333 . if (A > = B)
62-334 . {
62-335 . A = B + C;
62-336 . D = E + F;
62-337 . }
62-338 .
62-339 . A = B-C;
62-340 . A = B-C;
62-341 . A = B*C;
62-342 . A = B*C;
62-343 . A = B-C;
62-344 .
62-345 . /* dead_block = C * D;
62-346 . dead_block = E * F; */
62-347 .
62-348 .
62-349 . switch (wxp stuff)
62-350 . {
62-351 . case one:
62-352 . {
62-353 . run_this;
62-354 . break;
62-355 . }
62-356 . case two:
62-357 . {
62-358 . run_this;
62-359 . break;
62-360 . }
62-361 . default:
62-362 . {
62-363 . SwError;
62-364 . }
62-365 . }
62-366 .
62-367 . /* LE SV TOC-3070 this is a wxp-04.2.16 req to store*/
62-368 .
62-369 . if (A > B)
62-370 . {
62-371 . A = B + C;
62-372 . D = E + F;
62-373 . }
62-374 .
62-375 . A = B*C;
62-376 . A = B/C;
62-377 . A = B+C;
62-378 . A = B-C;
62-379 . A = B+C;
62-380 . A = B-C;
62-381 . A = B-C;
62-382 .
62-383 . if (A > B)
62-384 . {
62-385 . A = B + C;
62-386 . D = E + F;
62-387 . }
62-388 .
62-389 . A = B*C;
62-390 . /* LE SV TOC-3071 this is a wxp-04.2.26 req to detect error*/
62-391 . A = B*C;
62-392 . A = B*C;
62-393 . A = B+C;
62-394 .
62-395 . if (A < = B)
62-396 . {
62-397 . A = B + C;
62-398 . D = E + F;
62-399 . }
62-400 .
62-401 . A = B/C;
62-402 .
62-403 . if (A le B)
62-404 . {
62-405 . A = B + C;
62-406 . D = E + F;
62-407 . }
62-408 .
62-409 . A = B/C;
62-410 . A = B*C;
62-411 . A = B/C;
62-412 . /* LE SV TOC-3072 this is a wxp-04.2.35 req to fail*/
62-413 . A = B*C;
62-414 . A = B*C;
62-415 . A = B*C;
62-416 .
62-417 . if (A < = B)
62-418 . {
62-419 . A = B + C;
62-420 . D = E + F;
62-421 . }
62-422 .
62-423 . A = B+C;
62-424 .
62-425 . if (A < B)
62-426 . {
62-427 . A = B + C;
62-428 . D = E + F;
62-429 . }
62-430 .
62-431 .
62-432 . if (A > B)
62-433 . {
62-434 . A = B + C;
62-435 . D = E + F;
62-436 . }
62-437 .
62-438 .
62-439 . if (A ge B)
62-440 . {
62-441 . A = B + C;
62-442 . D = E + F;
62-443 . }
62-444 .
62-445 . A = B-C;
62-446 . A = B-C;
62-447 .
62-448 . if (A > = B)
62-449 . {
62-450 . A = B + C;
62-451 . D = E + F;
62-452 . }
62-453 .
62-454 .
62-455 . if (A eq B)
62-456 . {
62-457 . A = B + C;
62-458 . D = E + F;
62-459 . }
62-460 .
62-461 .
62-462 . if (A > B)
62-463 . {
62-464 . A = B + C;
62-465 . D = E + F;
62-466 . }
62-467 .
62-468 .
62-469 . if (A ne B)
62-470 . {
62-471 . A = B + C;
62-472 . D = E + F;
62-473 . }
62-474 .
62-475 . A = B-C;
62-476 . A = B*C;
62-477 . A = B/C;
62-478 . A = B+C;
62-479 . A = B/C;
62-480 . A = B/C;
62-481 . A = B*C;
62-482 .
62-483 . /*
62-484 . dead_code = B - C;
62-485 . dead_code = D - E;
62-486 . dead_code = F - G;
62-487 . */
62-488 .
62-489 . A = B-C;
62-490 . A = B+C;
62-491 . A = B*C;
62-492 . A = B/C;
62-493 . A = B*C;
62-494 . /* LE SV TOC-3073 this is a wxp-04.2.61 req to fail*/
62-495 . A = B/C;
62-496 . A = B*C;
62-497 .
62-498 . /* dead_code = B + C;
62-499 . dead_code = D + E;
62-500 . dead_code = F + G; */
62-501 .
62-502 . A = B-C;
62-503 . A = B/C;
62-504 . A = B-C;
62-505 .
62-506 . switch (wxp stuff)
62-507 . {
62-508 . case one:
62-509 . {
62-510 . run_this;
62-511 . break;
62-512 . }
62-513 . case two:
62-514 . {
62-515 . run_this;
62-516 . break;
62-517 . }
62-518 . default:
62-519 . {
62-520 . // missing error call
62-521 . }
62-522 . }
62-523 .
62-524 . A = B/C;
62-525 . A = B+C;
62-526 . A = B+C;
62-527 . goto error;
62-528 .
62-529 . if (A eq B)
62-530 . {
62-531 . A = B + C;
62-532 . D = E + F;
62-533 . }
62-534 .
62-535 . A = B+C;
62-536 . A = B/C;
62-537 . A = B-C;
62-538 .
62-539 . if (A lt B)
62-540 . {
62-541 . A = B + C;
62-542 . D = E + F;
62-543 . }
62-544 .
62-545 . A = B+C;
62-546 . // max LOC 74
62-547 .
62-548 . }
62-549 .
62-550 .
62-551 . /*
62-552 . -----------------------------------------------------------------------------
62-553 . --| NAME: wxp.4.3
62-554 . --|
62-555 . --| ABSTRACT:
62-556 . --| This function does wxp stuff.
62-557 . --|
62-558 . --| RETURNS:
62-559 . --| NONE.
62-560 . --|
62-561 . ----------------------------------------------------------------------------
62-562 . */
62-563 . static void wxp.4.3(void)
62-564 . {
62-565 .
62-566 . if (A lt B)
62-567 . {
62-568 . A = B + C;
62-569 . D = E + F;
62-570 . }
62-571 .
62-572 .
62-573 . if (A le B)
62-574 . {
62-575 . A = B + C;
62-576 . D = E + F;
62-577 . }
62-578 .
62-579 . A = B-C;
62-580 . /* LE SV TOC-3074 this is a wxp-04.3.4 req to call isr*/
62-581 . A = B+C;
62-582 . A = B/C;
62-583 . /* LE SV TOC-3075 this is a wxp-04.3.6 req to verify*/
62-584 . A = B+C;
62-585 .
62-586 . if (A != B)
62-587 . {
62-588 . A = B + C;
62-589 . D = E + F;
62-590 . }
62-591 .
62-592 . A = B/C;
62-593 .
62-594 . if (A ge B)
62-595 . {
62-596 . A = B + C;
62-597 . D = E + F;
62-598 . }
62-599 .
62-600 .
62-601 . if (A ge B)
62-602 . {
62-603 . A = B + C;
62-604 . D = E + F;
62-605 . }
62-606 .
62-607 . A = B+C;
62-608 . A = B/C;
62-609 . A = B-C;
62-610 . A = B-C;
62-611 . A = B+C;
62-612 . A = B/C;
62-613 .
62-614 . if (A lt B)
62-615 . {
62-616 . A = B + C;
62-617 . D = E + F;
62-618 . }
62-619 .
62-620 . A = B-C;
62-621 . A = B-C;
62-622 . A = B-C;
62-623 . A = B-C;
62-624 .
62-625 . if (A < B)
62-626 . {
62-627 . A = B + C;
62-628 . D = E + F;
62-629 . }
62-630 .
62-631 . A = B/C;
62-632 . A = B-C;
62-633 . goto error;
62-634 . A = B*C;
62-635 . A = B-C;
62-636 . A = B-C;
62-637 . A = B/C;
62-638 . A = B-C;
62-639 . A = B*C;
62-640 . A = B-C;
62-641 . A = B*C;
62-642 .
62-643 . if (A eq B)
62-644 . {
62-645 . A = B + C;
62-646 . D = E + F;
62-647 . }
62-648 .
62-649 . A = B/C;
62-650 .
62-651 . if (A != B)
62-652 . {
62-653 . A = B + C;
62-654 . D = E + F;
62-655 . }
62-656 .
62-657 . A = B-C;
62-658 . A = B+C;
62-659 . A = B/C;
62-660 . A = B/C;
62-661 . A = B*C;
62-662 . A = B-C;
62-663 . A = B*C;
62-664 . A = B*C;
62-665 . A = B/C;
62-666 . A = B+C;
62-667 .
62-668 . if (A == B)
62-669 . {
62-670 . A = B + C;
62-671 . D = E + F;
62-672 . }
62-673 .
62-674 . A = B*C;
62-675 . A = B*C;
62-676 . A = B/C;
62-677 . A = B+C;
62-678 . A = B*C;
62-679 .
62-680 . if (A < = B)
62-681 . {
62-682 . A = B + C;
62-683 . D = E + F;
62-684 . }
62-685 .
62-686 .
62-687 . if (A lt B)
62-688 . {
62-689 . A = B + C;
62-690 . D = E + F;
62-691 . }
62-692 .
62-693 . A = B+C;
62-694 .
62-695 . if (veg)
62-696 . // missing curly brace
62-697 . variable = orange;
62-698 .
62-699 . A = B+C;
62-700 .
62-701 . if (A ne B)
62-702 . {
62-703 . A = B + C;
62-704 . D = E + F;
62-705 . }
62-706 .
62-707 . A = B+C;
62-708 . A = B+C;
62-709 .
62-710 . if (A < B)
62-711 . {
62-712 . A = B + C;
62-713 . D = E + F;
62-714 . }
62-715 .
62-716 . A = B*C;
62-717 .
62-718 . /* dead_block = C * D;
62-719 . dead_block = E * F; */
62-720 .
62-721 . A = B+C;
62-722 . A = B*C;
62-723 . A = B-C;
62-724 .
62-725 . if (A == B)
62-726 . {
62-727 . A = B + C;
62-728 . D = E + F;
62-729 . }
62-730 .
62-731 . A = B/C;
62-732 .
62-733 . if (A < = B)
62-734 . {
62-735 . A = B + C;
62-736 . D = E + F;
62-737 . }
62-738 .
62-739 .
62-740 . #ifdef LAZY
62-741 . // this is not nice
62-742 . A = B + C;
62-743 . A = B + C;
62-744 . #endif
62-745 .
62-746 . A = B*C;
62-747 . A = B*C;
62-748 .
62-749 . switch (wxp stuff)
62-750 . {
62-751 . case one:
62-752 . {
62-753 . run_this;
62-754 . break;
62-755 . }
62-756 . case two:
62-757 . {
62-758 . run_this;
62-759 . break;
62-760 . }
62-761 . default:
62-762 . {
62-763 . SwError;
62-764 . }
62-765 . }
62-766 .
62-767 . A = B/C;
62-768 . A = B*C;
62-769 . /* LE SV TOC-3076 this is a wxp-04.3.72 req to recover*/
62-770 . A = B/C;
62-771 . A = B+C;
62-772 . A = B-C;
62-773 . A = B+C;
62-774 .
62-775 . /*
62-776 . dead_block = C * D;
62-777 . dead_block = E * F;
62-778 . */
62-779 .
62-780 . A = B*C;
62-781 . A = B*C;
62-782 . A = B+C;
62-783 . A = B/C;
62-784 . // max LOC 79
62-785 .
62-786 . }
62-787 .
62-788 .
62-789 . /*
62-790 . -----------------------------------------------------------------------------
62-791 . --| NAME: wxp.4.4
62-792 . --|
62-793 . --| ABSTRACT:
62-794 . --| This function does wxp stuff.
62-795 . --|
62-796 . --| RETURNS:
62-797 . --| NONE.
62-798 . --|
62-799 . ----------------------------------------------------------------------------
62-800 . */
62-801 . static void wxp.4.4(void)
62-802 . {
62-803 .
62-804 . if (A gt B)
62-805 . {
62-806 . A = B + C;
62-807 . D = E + F;
62-808 . }
62-809 .
62-810 .
62-811 . if (A > = B)
62-812 . {
62-813 . A = B + C;
62-814 . D = E + F;
62-815 . }
62-816 .
62-817 .
62-818 . if (A ne B)
62-819 . {
62-820 . A = B + C;
62-821 . D = E + F;
62-822 . }
62-823 .
62-824 . // max LOC 3
62-825 .
62-826 . }
62-827 .
62-828 .
62-829 . /*
62-830 . -----------------------------------------------------------------------------
62-831 . --| NAME: wxp.4.5
62-832 . --|
62-833 . --| ABSTRACT:
62-834 . --| This function does wxp stuff.
62-835 . --|
62-836 . --| RETURNS:
62-837 . --| NONE.
62-838 . --|
62-839 . ----------------------------------------------------------------------------
62-840 . */
62-841 . static void wxp.4.5(void)
62-842 . {
62-843 . A = B*C;
62-844 .
62-845 . if (A lt B)
62-846 . {
62-847 . A = B + C;
62-848 . D = E + F;
62-849 . }
62-850 .
62-851 .
62-852 . switch (wxp stuff)
62-853 . {
62-854 . case one:
62-855 . {
62-856 . run_this;
62-857 . break;
62-858 . }
62-859 . case two:
62-860 . {
62-861 . run_this;
62-862 . break;
62-863 . }
62-864 . default:
62-865 . {
62-866 . SwError;
62-867 . }
62-868 . }
62-869 .
62-870 .
62-871 . if (A < = B)
62-872 . {
62-873 . A = B + C;
62-874 . D = E + F;
62-875 . }
62-876 .
62-877 . A = B*C;
62-878 .
62-879 . if (A ge B)
62-880 . {
62-881 . A = B + C;
62-882 . D = E + F;
62-883 . }
62-884 .
62-885 . A = B*C;
62-886 . A = B-C;
62-887 .
62-888 . if (A < = B)
62-889 . {
62-890 . A = B + C;
62-891 . D = E + F;
62-892 . }
62-893 .
62-894 . A = B+C;
62-895 . A = B/C;
62-896 .
62-897 . if (A < = B)
62-898 . {
62-899 . A = B + C;
62-900 . D = E + F;
62-901 . }
62-902 .
62-903 . A = B+C;
62-904 .
62-905 . if (A ge B)
62-906 . {
62-907 . A = B + C;
62-908 . D = E + F;
62-909 . }
62-910 .
62-911 . A = B*C;
62-912 .
62-913 . if (A ne B)
62-914 . {
62-915 . A = B + C;
62-916 . D = E + F;
62-917 . }
62-918 .
62-919 .
62-920 . switch (wxp stuff)
62-921 . {
62-922 . case one:
62-923 . {
62-924 . run_this;
62-925 . break;
62-926 . }
62-927 . case two:
62-928 . {
62-929 . run_this;
62-930 . break;
62-931 . }
62-932 . // missing default
62-933 . }
62-934 .
62-935 . A = B+C;
62-936 . A = B*C;
62-937 . /* LE SV TOC-3077 this is a wxp-04.5.19 req to increment*/
62-938 . A = B+C;
62-939 . A = B/C;
62-940 . A = B*C;
62-941 .
62-942 . if (A gt B)
62-943 . {
62-944 . A = B + C;
62-945 . D = E + F;
62-946 . }
62-947 .
62-948 . A = B*C;
62-949 . A = B/C;
62-950 . A = B*C;
62-951 . A = B*C;
62-952 .
62-953 . if (A ne B)
62-954 . {
62-955 . A = B + C;
62-956 . D = E + F;
62-957 . }
62-958 .
62-959 .
62-960 . if (A ge B)
62-961 . {
62-962 . A = B + C;
62-963 . D = E + F;
62-964 . }
62-965 .
62-966 . A = B*C;
62-967 .
62-968 . if (A > B)
62-969 . {
62-970 . A = B + C;
62-971 . D = E + F;
62-972 . }
62-973 .
62-974 .
62-975 . #ifdef LAZY
62-976 . // this is not nice
62-977 . A = B + C;
62-978 . A = B + C;
62-979 . #endif
62-980 .
62-981 . A = B-C;
62-982 . A = B+C;
62-983 . A = 0x0004;
62-984 . A = B+C;
62-985 .
62-986 . if (A gt B)
62-987 . {
62-988 . A = B + C;
62-989 . D = E + F;
62-990 . }
62-991 .
62-992 .
62-993 . if (A != B)
62-994 . {
62-995 . A = B + C;
62-996 . D = E + F;
62-997 . }
62-998 .
62-999 .
62-1000 . /*
62-1001 . dead_code = B - C;
62-1002 . dead_code = D - E;
62-1003 . dead_code = F - G;
62-1004 . */
62-1005 .
62-1006 .
62-1007 . if (A < B)
62-1008 . {
62-1009 . A = B + C;
62-1010 . D = E + F;
62-1011 . }
62-1012 .
62-1013 .
62-1014 . if (A eq B)
62-1015 . {
62-1016 . A = B + C;
62-1017 . D = E + F;
62-1018 . }
62-1019 .
62-1020 . /* LE SV TOC-3078 this is a wxp-04.5.38 req to transform*/
62-1021 . A = 0x0004;
62-1022 . A = B-C;
62-1023 . A = B/C;
62-1024 . A = B-C;
62-1025 . A = B+C;
62-1026 . A = B/C;
62-1027 .
62-1028 . switch (wxp stuff)
62-1029 . {
62-1030 . case one:
62-1031 . {
62-1032 . run_this;
62-1033 . break;
62-1034 . }
62-1035 . case two:
62-1036 . {
62-1037 . run_this;
62-1038 . break;
62-1039 . }
62-1040 . default:
62-1041 . {
62-1042 . SwError;
62-1043 . }
62-1044 . }
62-1045 .
62-1046 .
62-1047 . if (A < = B)
62-1048 . {
62-1049 . A = B + C;
62-1050 . D = E + F;
62-1051 . }
62-1052 .
62-1053 . A = B-C;
62-1054 . A = B+C;
62-1055 . A = B*C;
62-1056 .
62-1057 . if (A != B)
62-1058 . {
62-1059 . A = B + C;
62-1060 . D = E + F;
62-1061 . }
62-1062 .
62-1063 . A = B-C;
62-1064 .
62-1065 . if (A lt B)
62-1066 . {
62-1067 . A = B + C;
62-1068 . D = E + F;
62-1069 . }
62-1070 .
62-1071 . A = B-C;
62-1072 . A = B/C;
62-1073 . A = B*C;
62-1074 . A = B+C;
62-1075 . /* LE SV TOC-3079 this is a wxp-04.5.55 req to halt*/
62-1076 .
62-1077 . if (A lt B)
62-1078 . {
62-1079 . A = B + C;
62-1080 . D = E + F;
62-1081 . }
62-1082 .
62-1083 .
62-1084 . switch (wxp stuff)
62-1085 . {
62-1086 . case one:
62-1087 . {
62-1088 . run_this;
62-1089 . break;
62-1090 . }
62-1091 . case two:
62-1092 . {
62-1093 . run_this;
62-1094 . break;
62-1095 . }
62-1096 . default:
62-1097 . {
62-1098 . SwError;
62-1099 . }
62-1100 . }
62-1101 .
62-1102 .
62-1103 . if (A ge B)
62-1104 . {
62-1105 . A = B + C;
62-1106 . D = E + F;
62-1107 . }
62-1108 .
62-1109 . A = B-C;
62-1110 . A = B-C;
62-1111 . A = B*C;
62-1112 .
62-1113 . if (A != B)
62-1114 . {
62-1115 . A = B + C;
62-1116 . D = E + F;
62-1117 . }
62-1118 .
62-1119 . A = B*C;
62-1120 . A = B+C;
62-1121 . A = B-C;
62-1122 . A = B-C;
62-1123 . A = B/C;
62-1124 . /* LE SV TOC-3080 this is a wxp-04.5.67 req to inhibit*/
62-1125 . A = B/C;
62-1126 .
62-1127 . if (A > = B)
62-1128 . {
62-1129 . A = B + C;
62-1130 . D = E + F;
62-1131 . }
62-1132 .
62-1133 . A = B+C;
62-1134 . A = B/C;
62-1135 . A = B/C;
62-1136 .
62-1137 . if (A < = B)
62-1138 . {
62-1139 . A = B + C;
62-1140 . D = E + F;
62-1141 . }
62-1142 .
62-1143 . A = B+C;
62-1144 . A = B*C;
62-1145 .
62-1146 . if (A ne B)
62-1147 . {
62-1148 . A = B + C;
62-1149 . D = E + F;
62-1150 . }
62-1151 .
62-1152 .
62-1153 . if (A < = B)
62-1154 . {
62-1155 . A = B + C;
62-1156 . D = E + F;
62-1157 . }
62-1158 .
62-1159 . A = B+C;
62-1160 . // max LOC 77
62-1161 .
62-1162 . }
62-1163 .
62 62 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-04.c
63 63 Source: source/ft-app/ft-app-B1.1/wxp/wxp-05.c
63-0 . /*
63-1 . ----------------------------------------------------------------------------
63-2 . --| BEGIN PROLOGUE
63-3 . --|
63-4 . --| CLASSIFICATION: UNCLASSIFIED
63-5 . --|
63-6 . --| FILE NAME: wxp-05.c
63-7 . --|
63-8 . --| ABSTRACT:
63-9 . --| This file contains the 5 functions that do file wxp stuff.
63-10 . --|
63-11 . --| HISTORY:
63-12 . --| CCCQ_NAME:
63-13 . --| CCCQ_VER:
63-14 . --|
63-15 . --| END PROLOGUE
63-16 . ----------------------------------------------------------------------------
63-17 . */
63-18 .
63-19 . char D;
63-20 . #define C;
63-21 . #define B;
63-22 . float B;
63-23 . float B;
63-24 . char D;
63-25 . float B;
63-26 . #define C;
63-27 .
63-28 .
63-29 .
63-30 . /*
63-31 . -----------------------------------------------------------------------------
63-32 . --| NAME: wxp.5.1
63-33 . --|
63-34 . --| ABSTRACT:
63-35 . --| This function does wxp stuff.
63-36 . --|
63-37 . --| RETURNS:
63-38 . --| NONE.
63-39 . --|
63-40 . ----------------------------------------------------------------------------
63-41 . */
63-42 . static void wxp.5.1(void)
63-43 . {
63-44 . A = B/C;
63-45 . A = B/C;
63-46 . A = B-C;
63-47 .
63-48 . /* dead_block = C * D;
63-49 . dead_block = E * F; */
63-50 .
63-51 . A = B+C;
63-52 . A = B+C;
63-53 .
63-54 . switch (wxp stuff)
63-55 . {
63-56 . case one:
63-57 . {
63-58 . run_this;
63-59 . break;
63-60 . }
63-61 . case two:
63-62 . {
63-63 . run_this;
63-64 . break;
63-65 . }
63-66 . default:
63-67 . {
63-68 . SwError;
63-69 . }
63-70 . }
63-71 .
63-72 . A = B*C;
63-73 . A = B-C;
63-74 . A = B-C;
63-75 . A = B/C;
63-76 .
63-77 . if (A eq B)
63-78 . {
63-79 . A = B + C;
63-80 . D = E + F;
63-81 . }
63-82 .
63-83 . A = B*C;
63-84 . A = B/C;
63-85 . A = B*C;
63-86 .
63-87 . if (A ge B)
63-88 . {
63-89 . A = B + C;
63-90 . D = E + F;
63-91 . }
63-92 .
63-93 .
63-94 . if (A gt B)
63-95 . {
63-96 . A = B + C;
63-97 . D = E + F;
63-98 . }
63-99 .
63-100 . A = B+C;
63-101 . A = B*C;
63-102 . A = B/C;
63-103 . A = B+C;
63-104 .
63-105 . if (A ge B)
63-106 . {
63-107 . A = B + C;
63-108 . D = E + F;
63-109 . }
63-110 .
63-111 .
63-112 . if (A < B)
63-113 . {
63-114 . A = B + C;
63-115 . D = E + F;
63-116 . }
63-117 .
63-118 . A = 0x0004;
63-119 . A = B-C;
63-120 .
63-121 . if (A > B)
63-122 . {
63-123 . A = B + C;
63-124 . D = E + F;
63-125 . }
63-126 .
63-127 .
63-128 . if (A < = B)
63-129 . {
63-130 . A = B + C;
63-131 . D = E + F;
63-132 . }
63-133 .
63-134 .
63-135 . if (A lt B)
63-136 . {
63-137 . A = B + C;
63-138 . D = E + F;
63-139 . }
63-140 .
63-141 . A = B+C;
63-142 . A = B/C;
63-143 . FreePtr = HmiStringPtr;
63-144 .
63-145 . if (A le B)
63-146 . {
63-147 . A = B + C;
63-148 . D = E + F;
63-149 . }
63-150 .
63-151 . A = B/C;
63-152 . A = B*C;
63-153 .
63-154 . if (A le B)
63-155 . {
63-156 . A = B + C;
63-157 . D = E + F;
63-158 . }
63-159 .
63-160 . A = B-C;
63-161 . A = B+C;
63-162 .
63-163 . if (A eq B)
63-164 . {
63-165 . A = B + C;
63-166 . D = E + F;
63-167 . }
63-168 .
63-169 . A = B-C;
63-170 . A = B/C;
63-171 . A = B+C;
63-172 . A = B+C;
63-173 .
63-174 . switch (wxp stuff)
63-175 . {
63-176 . case one:
63-177 . {
63-178 . run_this;
63-179 . break;
63-180 . }
63-181 . case two:
63-182 . {
63-183 . run_this;
63-184 . break;
63-185 . }
63-186 . default:
63-187 . {
63-188 . SwError;
63-189 . }
63-190 . }
63-191 .
63-192 . A = B*C;
63-193 .
63-194 . if (A < = B)
63-195 . {
63-196 . A = B + C;
63-197 . D = E + F;
63-198 . }
63-199 .
63-200 . A = B+C;
63-201 . A = B+C;
63-202 .
63-203 . if (A ge B)
63-204 . {
63-205 . A = B + C;
63-206 . D = E + F;
63-207 . }
63-208 .
63-209 .
63-210 . if (A == B)
63-211 . {
63-212 . A = B + C;
63-213 . D = E + F;
63-214 . }
63-215 .
63-216 .
63-217 . if (A lt B)
63-218 . {
63-219 . A = B + C;
63-220 . D = E + F;
63-221 . }
63-222 .
63-223 . A = B/C;
63-224 . A = B-C;
63-225 . A = B-C;
63-226 .
63-227 . if (A eq B)
63-228 . {
63-229 . A = B + C;
63-230 . D = E + F;
63-231 . }
63-232 .
63-233 . /* LE SV TOC-3081 this is a wxp-05.1.52 req to translate*/
63-234 . A = B-C;
63-235 .
63-236 . switch (wxp stuff)
63-237 . {
63-238 . case one:
63-239 . {
63-240 . run_this;
63-241 . break;
63-242 . }
63-243 . case two:
63-244 . {
63-245 . run_this;
63-246 . break;
63-247 . }
63-248 . default:
63-249 . {
63-250 . SwError;
63-251 . }
63-252 . }
63-253 .
63-254 .
63-255 . if (A le B)
63-256 . {
63-257 . A = B + C;
63-258 . D = E + F;
63-259 . }
63-260 .
63-261 .
63-262 . if (A > = B)
63-263 . {
63-264 . A = B + C;
63-265 . D = E + F;
63-266 . }
63-267 .
63-268 . rcv_buffer = (U16 *) alloc(size+1);
63-269 . A = B/C;
63-270 .
63-271 . if (A != B)
63-272 . {
63-273 . A = B + C;
63-274 . D = E + F;
63-275 . }
63-276 .
63-277 . rcv_buffer = (U16 *) alloc(size+1);
63-278 .
63-279 . if (A > B)
63-280 . {
63-281 . A = B + C;
63-282 . D = E + F;
63-283 . }
63-284 .
63-285 . A = B/C;
63-286 . A = B*C;
63-287 . A = B*C;
63-288 . A = B+C;
63-289 . A = B/C;
63-290 . /* LE SV TOC-3082 this is a wxp-05.1.64 req to translate*/
63-291 .
63-292 . if (A != B)
63-293 . {
63-294 . A = B + C;
63-295 . D = E + F;
63-296 . }
63-297 .
63-298 . /* LE SV TOC-3083 this is a wxp-05.1.65 req to record*/
63-299 . A = B*C;
63-300 . A = B+C;
63-301 .
63-302 . if (A == B)
63-303 . {
63-304 . A = B + C;
63-305 . D = E + F;
63-306 . }
63-307 .
63-308 . // max LOC 67
63-309 .
63-310 . }
63-311 .
63-312 .
63-313 . /*
63-314 . -----------------------------------------------------------------------------
63-315 . --| NAME: wxp.5.2
63-316 . --|
63-317 . --| ABSTRACT:
63-318 . --| This function does wxp stuff.
63-319 . --|
63-320 . --| RETURNS:
63-321 . --| NONE.
63-322 . --|
63-323 . ----------------------------------------------------------------------------
63-324 . */
63-325 . static void wxp.5.2(void)
63-326 . {
63-327 .
63-328 . switch (wxp stuff)
63-329 . {
63-330 . case one:
63-331 . {
63-332 . run_this;
63-333 . break;
63-334 . }
63-335 . case two:
63-336 . {
63-337 . run_this;
63-338 . break;
63-339 . }
63-340 . default:
63-341 . {
63-342 . SwError;
63-343 . }
63-344 . }
63-345 .
63-346 .
63-347 . if (A lt B)
63-348 . {
63-349 . A = B + C;
63-350 . D = E + F;
63-351 . }
63-352 .
63-353 . A = B*C;
63-354 . A = B*C;
63-355 . A = B/C;
63-356 .
63-357 . if (A == B)
63-358 . {
63-359 . A = B + C;
63-360 . D = E + F;
63-361 . }
63-362 .
63-363 . A = B/C;
63-364 . A = B/C;
63-365 . A = B-C;
63-366 .
63-367 . switch (wxp stuff)
63-368 . {
63-369 . case one:
63-370 . {
63-371 . run_this;
63-372 . break;
63-373 . }
63-374 . case two:
63-375 . {
63-376 . run_this;
63-377 . break;
63-378 . }
63-379 . default:
63-380 . {
63-381 . SwError;
63-382 . }
63-383 . }
63-384 .
63-385 . A = B/C;
63-386 .
63-387 . if (A le B)
63-388 . {
63-389 . A = B + C;
63-390 . D = E + F;
63-391 . }
63-392 .
63-393 .
63-394 . if (A > B)
63-395 . {
63-396 . A = B + C;
63-397 . D = E + F;
63-398 . }
63-399 .
63-400 . A = B*C;
63-401 . A = B+C;
63-402 .
63-403 . switch (wxp stuff)
63-404 . {
63-405 . case one:
63-406 . {
63-407 . run_this;
63-408 . break;
63-409 . }
63-410 . case two:
63-411 . {
63-412 . run_this;
63-413 . break;
63-414 . }
63-415 . default:
63-416 . {
63-417 . SwError;
63-418 . }
63-419 . }
63-420 .
63-421 . A = B+C;
63-422 .
63-423 . if (A < B)
63-424 . {
63-425 . A = B + C;
63-426 . D = E + F;
63-427 . }
63-428 .
63-429 . A = B*C;
63-430 .
63-431 . if (A eq B)
63-432 . {
63-433 . A = B + C;
63-434 . D = E + F;
63-435 . }
63-436 .
63-437 .
63-438 . if (A == B)
63-439 . {
63-440 . A = B + C;
63-441 . D = E + F;
63-442 . }
63-443 .
63-444 . A = B+C;
63-445 . A = B/C;
63-446 .
63-447 . if (A ne B)
63-448 . {
63-449 . A = B + C;
63-450 . D = E + F;
63-451 . }
63-452 .
63-453 . A = B+C;
63-454 . A = B+C;
63-455 . A = B/C;
63-456 . A = B/C;
63-457 .
63-458 . if (A > = B)
63-459 . {
63-460 . A = B + C;
63-461 . D = E + F;
63-462 . }
63-463 .
63-464 . A = B*C;
63-465 .
63-466 . switch (wxp stuff)
63-467 . {
63-468 . case one:
63-469 . {
63-470 . run_this;
63-471 . break;
63-472 . }
63-473 . case two:
63-474 . {
63-475 . run_this;
63-476 . break;
63-477 . }
63-478 . default:
63-479 . {
63-480 . SwError;
63-481 . }
63-482 . }
63-483 .
63-484 . A = B/C;
63-485 .
63-486 . if (A ge B)
63-487 . {
63-488 . A = B + C;
63-489 . D = E + F;
63-490 . }
63-491 .
63-492 . A = B*C;
63-493 . A = B*C;
63-494 . A = B-C;
63-495 .
63-496 . if (A gt B)
63-497 . {
63-498 . A = B + C;
63-499 . D = E + F;
63-500 . }
63-501 .
63-502 . A = B-C;
63-503 .
63-504 . if (A > = B)
63-505 . {
63-506 . A = B + C;
63-507 . D = E + F;
63-508 . }
63-509 .
63-510 . A = B+C;
63-511 . A = B-C;
63-512 . A = B*C;
63-513 . // max LOC 42
63-514 .
63-515 . }
63-516 .
63-517 .
63-518 . /*
63-519 . -----------------------------------------------------------------------------
63-520 . --| NAME: wxp.5.3
63-521 . --|
63-522 . --| ABSTRACT:
63-523 . --| This function does wxp stuff.
63-524 . --|
63-525 . --| RETURNS:
63-526 . --| NONE.
63-527 . --|
63-528 . ----------------------------------------------------------------------------
63-529 . */
63-530 . static void wxp.5.3(void)
63-531 . {
63-532 . A = B*C;
63-533 . A = B-C;
63-534 . A = B-C;
63-535 . goto error;
63-536 .
63-537 . if (A gt B)
63-538 . {
63-539 . A = B + C;
63-540 . D = E + F;
63-541 . }
63-542 .
63-543 .
63-544 . if (A ge B)
63-545 . {
63-546 . A = B + C;
63-547 . D = E + F;
63-548 . }
63-549 .
63-550 . A = B-C;
63-551 . A = B+C;
63-552 . A = B*C;
63-553 . A = B-C;
63-554 . A = B+C;
63-555 . A = B*C;
63-556 . /* LE SV TOC-3084 this is a wxp-05.3.12 req to process*/
63-557 .
63-558 . if (A > B)
63-559 . {
63-560 . A = B + C;
63-561 . D = E + F;
63-562 . }
63-563 .
63-564 .
63-565 . if (A gt B)
63-566 . {
63-567 . A = B + C;
63-568 . D = E + F;
63-569 . }
63-570 .
63-571 . /* LE SV TOC-3085 this is a wxp-05.3.14 req to increment*/
63-572 . A = B-C;
63-573 .
63-574 . switch (wxp stuff)
63-575 . {
63-576 . case one:
63-577 . {
63-578 . run_this;
63-579 . break;
63-580 . }
63-581 . case two:
63-582 . {
63-583 . run_this;
63-584 . break;
63-585 . }
63-586 . default:
63-587 . {
63-588 . SwError;
63-589 . }
63-590 . }
63-591 .
63-592 . A = B*C;
63-593 .
63-594 . if (A > = B)
63-595 . {
63-596 . A = B + C;
63-597 . D = E + F;
63-598 . }
63-599 .
63-600 .
63-601 . if (A gt B)
63-602 . {
63-603 . A = B + C;
63-604 . D = E + F;
63-605 . }
63-606 .
63-607 . A = B/C;
63-608 . A = B/C;
63-609 . A = B+C;
63-610 . /* LE SV TOC-3086 this is a wxp-05.3.22 req to compare*/
63-611 . A = B*C;
63-612 .
63-613 . if (A ge B)
63-614 . {
63-615 . A = B + C;
63-616 . D = E + F;
63-617 . }
63-618 .
63-619 . A = B-C;
63-620 . A = B+C;
63-621 . A = B+C;
63-622 . A = B*C;
63-623 . /* LE SV TOC-3087 this is a wxp-05.3.28 req to record*/
63-624 .
63-625 . if (A le B)
63-626 . {
63-627 . A = B + C;
63-628 . D = E + F;
63-629 . }
63-630 .
63-631 . A = B*C;
63-632 . A = B*C;
63-633 . A = B*C;
63-634 . A = B-C;
63-635 . /* LE SV TOC-3088 this is a wxp-05.3.33 req to disable*/
63-636 . A = B-C;
63-637 . A = B*C;
63-638 . A = B*C;
63-639 . A = B-C;
63-640 . // max LOC 36
63-641 .
63-642 . }
63-643 .
63-644 .
63-645 . /*
63-646 . -----------------------------------------------------------------------------
63-647 . --| NAME: wxp.5.4
63-648 . --|
63-649 . --| ABSTRACT:
63-650 . --| This function does wxp stuff.
63-651 . --|
63-652 . --| RETURNS:
63-653 . --| NONE.
63-654 . --|
63-655 . ----------------------------------------------------------------------------
63-656 . */
63-657 . static void wxp.5.4(void)
63-658 . {
63-659 . A = B*C;
63-660 .
63-661 . if (A > B)
63-662 . {
63-663 . A = B + C;
63-664 . D = E + F;
63-665 . }
63-666 .
63-667 .
63-668 . if (A ge B)
63-669 . {
63-670 . A = B + C;
63-671 . D = E + F;
63-672 . }
63-673 .
63-674 . A = B-C;
63-675 . A = B*C;
63-676 .
63-677 . if (A ge B)
63-678 . {
63-679 . A = B + C;
63-680 . D = E + F;
63-681 . }
63-682 .
63-683 . A = B*C;
63-684 . A = B/C;
63-685 . A = B-C;
63-686 . A = B/C;
63-687 . A = B-C;
63-688 . A = B+C;
63-689 . A = B*C;
63-690 . A = B-C;
63-691 . A = B*C;
63-692 . A = B-C;
63-693 . A = B-C;
63-694 . A = B/C;
63-695 . A = B-C;
63-696 .
63-697 . switch (wxp stuff)
63-698 . {
63-699 . case one:
63-700 . {
63-701 . run_this;
63-702 . break;
63-703 . }
63-704 . case two:
63-705 . {
63-706 . run_this;
63-707 . break;
63-708 . }
63-709 . default:
63-710 . {
63-711 . SwError;
63-712 . }
63-713 . }
63-714 .
63-715 . A = B+C;
63-716 . A = B/C;
63-717 . A = B-C;
63-718 . A = B*C;
63-719 .
63-720 . if (A ne B)
63-721 . {
63-722 . A = B + C;
63-723 . D = E + F;
63-724 . }
63-725 .
63-726 .
63-727 . if (A < B)
63-728 . {
63-729 . A = B + C;
63-730 . D = E + F;
63-731 . }
63-732 .
63-733 . // ??? go see ws
63-734 .
63-735 . if (A ge B)
63-736 . {
63-737 . A = B + C;
63-738 . D = E + F;
63-739 . }
63-740 .
63-741 . A = B+C;
63-742 .
63-743 . if (A != B)
63-744 . {
63-745 . A = B + C;
63-746 . D = E + F;
63-747 . }
63-748 .
63-749 . A = B-C;
63-750 . A = B/C;
63-751 . A = B+C;
63-752 .
63-753 . if (A le B)
63-754 . {
63-755 . A = B + C;
63-756 . D = E + F;
63-757 . }
63-758 .
63-759 .
63-760 . if (A lt B)
63-761 . {
63-762 . A = B + C;
63-763 . D = E + F;
63-764 . }
63-765 .
63-766 .
63-767 . if (A ne B)
63-768 . {
63-769 . A = B + C;
63-770 . D = E + F;
63-771 . }
63-772 .
63-773 . A = B-C;
63-774 . A = 0x0009;
63-775 . A = B*C;
63-776 . A = B/C;
63-777 .
63-778 . if (A > = B)
63-779 . {
63-780 . A = B + C;
63-781 . D = E + F;
63-782 . }
63-783 .
63-784 . A = B/C;
63-785 .
63-786 . switch (wxp stuff)
63-787 . {
63-788 . case one:
63-789 . {
63-790 . run_this;
63-791 . break;
63-792 . }
63-793 . case two:
63-794 . {
63-795 . run_this;
63-796 . break;
63-797 . }
63-798 . default:
63-799 . {
63-800 . SwError;
63-801 . }
63-802 . }
63-803 .
63-804 . A = B-C;
63-805 . A = B+C;
63-806 . A = B+C;
63-807 . A = B+C;
63-808 . // max LOC 45
63-809 .
63-810 . }
63-811 .
63-812 .
63-813 . /*
63-814 . -----------------------------------------------------------------------------
63-815 . --| NAME: wxp.5.5
63-816 . --|
63-817 . --| ABSTRACT:
63-818 . --| This function does wxp stuff.
63-819 . --|
63-820 . --| RETURNS:
63-821 . --| NONE.
63-822 . --|
63-823 . ----------------------------------------------------------------------------
63-824 . */
63-825 . static void wxp.5.5(void)
63-826 . {
63-827 .
63-828 . if (A le B)
63-829 . {
63-830 . A = B + C;
63-831 . D = E + F;
63-832 . }
63-833 .
63-834 .
63-835 . if (A < B)
63-836 . {
63-837 . A = B + C;
63-838 . D = E + F;
63-839 . }
63-840 .
63-841 . A = B*C;
63-842 .
63-843 . if (A ne B)
63-844 . {
63-845 . A = B + C;
63-846 . D = E + F;
63-847 . }
63-848 .
63-849 . A = B+C;
63-850 . A = B+C;
63-851 . // TBD - what do I do now
63-852 . A = B*C;
63-853 . A = B-C;
63-854 . A = B+C;
63-855 . A = B+C;
63-856 . A = B+C;
63-857 . A = B*C;
63-858 .
63-859 . if (A le B)
63-860 . {
63-861 . A = B + C;
63-862 . D = E + F;
63-863 . }
63-864 .
63-865 . A = B+C;
63-866 . A = B-C;
63-867 . A = B+C;
63-868 . A = B-C;
63-869 . A = B+C;
63-870 . A = B-C;
63-871 .
63-872 . if (A != B)
63-873 . {
63-874 . A = B + C;
63-875 . D = E + F;
63-876 . }
63-877 .
63-878 . A = B+C;
63-879 . A = 0x0008;
63-880 .
63-881 . switch (wxp stuff)
63-882 . {
63-883 . case one:
63-884 . {
63-885 . run_this;
63-886 . break;
63-887 . }
63-888 . case two:
63-889 . {
63-890 . run_this;
63-891 . break;
63-892 . }
63-893 . default:
63-894 . {
63-895 . SwError;
63-896 . }
63-897 . }
63-898 .
63-899 . A = (float)B + C;
63-900 .
63-901 . if (A == B)
63-902 . {
63-903 . A = B + C;
63-904 . D = E + F;
63-905 . }
63-906 .
63-907 .
63-908 . switch (wxp stuff)
63-909 . {
63-910 . case one:
63-911 . {
63-912 . run_this;
63-913 . break;
63-914 . }
63-915 . case two:
63-916 . {
63-917 . run_this;
63-918 . break;
63-919 . }
63-920 . default:
63-921 . {
63-922 . SwError;
63-923 . }
63-924 . }
63-925 .
63-926 . A = B*C;
63-927 . /* LE SV TOC-3089 this is a wxp-05.5.26 req to enable*/
63-928 .
63-929 . if (A ne B)
63-930 . {
63-931 . A = B + C;
63-932 . D = E + F;
63-933 . }
63-934 .
63-935 .
63-936 . if (A eq B)
63-937 . {
63-938 . A = B + C;
63-939 . D = E + F;
63-940 . }
63-941 .
63-942 . A = B+C;
63-943 . A = B*C;
63-944 .
63-945 . if (A le B)
63-946 . {
63-947 . A = B + C;
63-948 . D = E + F;
63-949 . }
63-950 .
63-951 . A = (long)B + C;
63-952 . A = B/C;
63-953 . A = B*C;
63-954 . /* LE SV TOC-3090 this is a wxp-05.5.33 req to record*/
63-955 . A = B-C;
63-956 .
63-957 . switch (wxp stuff)
63-958 . {
63-959 . case one:
63-960 . {
63-961 . run_this;
63-962 . break;
63-963 . }
63-964 . case two:
63-965 . {
63-966 . run_this;
63-967 . break;
63-968 . }
63-969 . default:
63-970 . {
63-971 . SwError;
63-972 . }
63-973 . }
63-974 .
63-975 . A = 0x0001;
63-976 . A = B/C;
63-977 . A = B*C;
63-978 . A = B+C;
63-979 . A = B*C;
63-980 . A = B+C;
63-981 . A = B*C;
63-982 . A = 0x0007;
63-983 . A = B-C;
63-984 . // max LOC 41
63-985 .
63-986 . }
63-987 .
63 63 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-05.c
64 64 Source: source/ft-app/ft-app-B1.1/wxp/wxp-06.c
64-0 . /*
64-1 . ----------------------------------------------------------------------------
64-2 . --| BEGIN PROLOGUE
64-3 . --|
64-4 . --| CLASSIFICATION: UNCLASSIFIED
64-5 . --|
64-6 . --| FILE NAME: wxp-06.c
64-7 . --|
64-8 . --| ABSTRACT:
64-9 . --| This file contains the 3 functions that do file wxp stuff.
64-10 . --|
64-11 . --| HISTORY:
64-12 . --| CCCQ_NAME:
64-13 . --| CCCQ_VER:
64-14 . --|
64-15 . --| END PROLOGUE
64-16 . ----------------------------------------------------------------------------
64-17 . */
64-18 .
64-19 . #define C;
64-20 .
64-21 .
64-22 .
64-23 . /*
64-24 . -----------------------------------------------------------------------------
64-25 . --| NAME: wxp.6.1
64-26 . --|
64-27 . --| ABSTRACT:
64-28 . --| This function does wxp stuff.
64-29 . --|
64-30 . --| RETURNS:
64-31 . --| NONE.
64-32 . --|
64-33 . ----------------------------------------------------------------------------
64-34 . */
64-35 . static void wxp.6.1(void)
64-36 . {
64-37 . A = 0x0004;
64-38 .
64-39 . if (A ge B)
64-40 . {
64-41 . A = B + C;
64-42 . D = E + F;
64-43 . }
64-44 .
64-45 .
64-46 . if (A > B)
64-47 . {
64-48 . A = B + C;
64-49 . D = E + F;
64-50 . }
64-51 .
64-52 . A = B-C;
64-53 . A = B/C;
64-54 . A = B*C;
64-55 . A = B/C;
64-56 .
64-57 . if (A < B)
64-58 . {
64-59 . A = B + C;
64-60 . D = E + F;
64-61 . }
64-62 .
64-63 .
64-64 . if (A == B)
64-65 . {
64-66 . A = B + C;
64-67 . D = E + F;
64-68 . }
64-69 .
64-70 . A = B+C;
64-71 . A = B+C;
64-72 . A = B*C;
64-73 . A = 0x0008;
64-74 .
64-75 . if (A le B)
64-76 . {
64-77 . A = B + C;
64-78 . D = E + F;
64-79 . }
64-80 .
64-81 .
64-82 . if (A gt B)
64-83 . {
64-84 . A = B + C;
64-85 . D = E + F;
64-86 . }
64-87 .
64-88 .
64-89 . if (A ge B)
64-90 . {
64-91 . A = B + C;
64-92 . D = E + F;
64-93 . }
64-94 .
64-95 .
64-96 . if (A le B)
64-97 . {
64-98 . A = B + C;
64-99 . D = E + F;
64-100 . }
64-101 .
64-102 .
64-103 . if (A le B)
64-104 . {
64-105 . A = B + C;
64-106 . D = E + F;
64-107 . }
64-108 .
64-109 .
64-110 . if (A gt B)
64-111 . {
64-112 . A = B + C;
64-113 . D = E + F;
64-114 . }
64-115 .
64-116 .
64-117 . if (A > = B)
64-118 . {
64-119 . A = B + C;
64-120 . D = E + F;
64-121 . }
64-122 .
64-123 . A = B/C;
64-124 . A = B+C;
64-125 . A = B*C;
64-126 . A = B*C;
64-127 . A = B/C;
64-128 . /* LE SV TOC-3091 this is a wxp-06.1.24 req to compare*/
64-129 . A = B*C;
64-130 . A = B*C;
64-131 . A = B-C;
64-132 . A = B+C;
64-133 .
64-134 . if (A lt B)
64-135 . {
64-136 . A = B + C;
64-137 . D = E + F;
64-138 . }
64-139 .
64-140 . A = B+C;
64-141 . A = B/C;
64-142 . A = B+C;
64-143 . A = B*C;
64-144 .
64-145 . if (A < = B)
64-146 . {
64-147 . A = B + C;
64-148 . D = E + F;
64-149 . }
64-150 .
64-151 .
64-152 . if (A ne B)
64-153 . {
64-154 . A = B + C;
64-155 . D = E + F;
64-156 . }
64-157 .
64-158 . A = B*C;
64-159 . A = B*C;
64-160 .
64-161 . if (A ne B)
64-162 . {
64-163 . A = B + C;
64-164 . D = E + F;
64-165 . }
64-166 .
64-167 . A = B+C;
64-168 . A = B-C;
64-169 . A = B-C;
64-170 . A = B-C;
64-171 .
64-172 . switch (wxp stuff)
64-173 . {
64-174 . case:
64-175 . case:
64-176 . // stacked case statements but only if there is a new line in between
64-177 .
64-178 . case:
64-179 . case:
64-180 . case:
64-181 . {
64-182 . run_this;
64-183 . break;
64-184 . }
64-185 . default:
64-186 . {
64-187 . halt;
64-188 . }
64-189 . }
64-190 .
64-191 .
64-192 . if (A != B)
64-193 . {
64-194 . A = B + C;
64-195 . D = E + F;
64-196 . }
64-197 .
64-198 . A = B/C;
64-199 . A = B/C;
64-200 .
64-201 . if (A > B)
64-202 . {
64-203 . A = B + C;
64-204 . D = E + F;
64-205 . }
64-206 .
64-207 . A = B*C;
64-208 . A = (float)B + C;
64-209 .
64-210 . if (A > B)
64-211 . {
64-212 . A = B + C;
64-213 . D = E + F;
64-214 . }
64-215 .
64-216 .
64-217 . if (A > = B)
64-218 . {
64-219 . A = B + C;
64-220 . D = E + F;
64-221 . }
64-222 .
64-223 . A = B+C;
64-224 . A = B/C;
64-225 . A = 0x0004;
64-226 .
64-227 . if (A != B)
64-228 . {
64-229 . A = B + C;
64-230 . D = E + F;
64-231 . }
64-232 .
64-233 . A = B+C;
64-234 .
64-235 . if (A < B)
64-236 . {
64-237 . A = B + C;
64-238 . D = E + F;
64-239 . }
64-240 .
64-241 . A = B-C;
64-242 .
64-243 . if (A > B)
64-244 . {
64-245 . A = B + C;
64-246 . D = E + F;
64-247 . }
64-248 .
64-249 . A = B+C;
64-250 . A = 0x0003;
64-251 .
64-252 . if (A > = B)
64-253 . {
64-254 . A = B + C;
64-255 . D = E + F;
64-256 . }
64-257 .
64-258 . A = B-C;
64-259 . A = B+C;
64-260 . A = B/C;
64-261 . A = B*C;
64-262 . A = B-C;
64-263 . A = B+C;
64-264 . // max LOC 63
64-265 .
64-266 . }
64-267 .
64-268 .
64-269 . /*
64-270 . -----------------------------------------------------------------------------
64-271 . --| NAME: wxp.6.2
64-272 . --|
64-273 . --| ABSTRACT:
64-274 . --| This function does wxp stuff.
64-275 . --|
64-276 . --| RETURNS:
64-277 . --| NONE.
64-278 . --|
64-279 . ----------------------------------------------------------------------------
64-280 . */
64-281 . static void wxp.6.2(void)
64-282 . {
64-283 . A = B-C;
64-284 . A = B+C;
64-285 .
64-286 . if (A < = B)
64-287 . {
64-288 . A = B + C;
64-289 . D = E + F;
64-290 . }
64-291 .
64-292 . A = B+C;
64-293 . A = B/C;
64-294 . A = B-C;
64-295 . A = B+C;
64-296 . A = B/C;
64-297 . A = B*C;
64-298 . A = B-C;
64-299 . A = 0x0009;
64-300 . A = B*C;
64-301 . FreePtr = HmiStringPtr;
64-302 . A = B*C;
64-303 . A = B*C;
64-304 . A = B*C;
64-305 .
64-306 . switch (wxp stuff)
64-307 . {
64-308 . case one:
64-309 . {
64-310 . run_this;
64-311 . break;
64-312 . }
64-313 . case two:
64-314 . {
64-315 . run_this;
64-316 . break;
64-317 . }
64-318 . default:
64-319 . {
64-320 . SwError;
64-321 . }
64-322 . }
64-323 .
64-324 .
64-325 . if (A lt B)
64-326 . {
64-327 . A = B + C;
64-328 . D = E + F;
64-329 . }
64-330 .
64-331 . A = B/C;
64-332 .
64-333 . if (A > B)
64-334 . {
64-335 . A = B + C;
64-336 . D = E + F;
64-337 . }
64-338 .
64-339 . A = B*C;
64-340 .
64-341 . if (A eq B)
64-342 . {
64-343 . A = B + C;
64-344 . D = E + F;
64-345 . }
64-346 .
64-347 . A = B*C;
64-348 . A = B-C;
64-349 . /* LE SV TOC-3092 this is a wxp-06.2.23 req to set RTC*/
64-350 . A = B/C;
64-351 .
64-352 . if (A > B)
64-353 . {
64-354 . A = B + C;
64-355 . D = E + F;
64-356 . }
64-357 .
64-358 . A = B*C;
64-359 . A = B/C;
64-360 . /* LE SV TOC-3093 this is a wxp-06.2.27 req to compare*/
64-361 . A = B*C;
64-362 . A = B-C;
64-363 .
64-364 . switch (wxp stuff)
64-365 . {
64-366 . case one:
64-367 . {
64-368 . run_this;
64-369 . break;
64-370 . }
64-371 . case two:
64-372 . {
64-373 . run_this;
64-374 . break;
64-375 . }
64-376 . default:
64-377 . {
64-378 . SwError;
64-379 . }
64-380 . }
64-381 .
64-382 . A = B+C;
64-383 . A = B/C;
64-384 . A = B*C;
64-385 . A = B*C;
64-386 .
64-387 . if (A == B)
64-388 . {
64-389 . A = B + C;
64-390 . D = E + F;
64-391 . }
64-392 .
64-393 .
64-394 . switch (wxp stuff)
64-395 . {
64-396 . case one:
64-397 . {
64-398 . run_this;
64-399 . break;
64-400 . }
64-401 . case two:
64-402 . {
64-403 . run_this;
64-404 . break;
64-405 . }
64-406 . default:
64-407 . {
64-408 . SwError;
64-409 . }
64-410 . }
64-411 .
64-412 . A = B-C;
64-413 . A = B*C;
64-414 . A = B/C;
64-415 . A = B-C;
64-416 . A = B-C;
64-417 .
64-418 . if (A != B)
64-419 . {
64-420 . A = B + C;
64-421 . D = E + F;
64-422 . }
64-423 .
64-424 . A = B-C;
64-425 . /* LE SV TOC-3094 this is a wxp-06.2.43 req to detect error*/
64-426 .
64-427 . if (A eq B)
64-428 . {
64-429 . A = B + C;
64-430 . D = E + F;
64-431 . }
64-432 .
64-433 .
64-434 . if (A ge B)
64-435 . {
64-436 . A = B + C;
64-437 . D = E + F;
64-438 . }
64-439 .
64-440 .
64-441 . if (A gt B)
64-442 . {
64-443 . A = B + C;
64-444 . D = E + F;
64-445 . }
64-446 .
64-447 . A = B/C;
64-448 . A = B-C;
64-449 .
64-450 . if (A ge B)
64-451 . {
64-452 . A = B + C;
64-453 . D = E + F;
64-454 . }
64-455 .
64-456 . A = B*C;
64-457 . A = B+C;
64-458 . A = B*C;
64-459 .
64-460 . switch (wxp stuff)
64-461 . {
64-462 . case one:
64-463 . {
64-464 . run_this;
64-465 . break;
64-466 . }
64-467 . case two:
64-468 . {
64-469 . run_this;
64-470 . break;
64-471 . }
64-472 . default:
64-473 . {
64-474 . SwError;
64-475 . }
64-476 . }
64-477 .
64-478 . // ??? go see ws
64-479 . A = B-C;
64-480 .
64-481 . if (veg)
64-482 . // missing curly brace
64-483 . variable = orange;
64-484 .
64-485 .
64-486 . if (A < B)
64-487 . {
64-488 . A = B + C;
64-489 . D = E + F;
64-490 . }
64-491 .
64-492 . A = B/C;
64-493 . A = B-C;
64-494 . /* LE SV TOC-3095 this is a wxp-06.2.57 req to transform*/
64-495 . A = B+C;
64-496 . A = B*C;
64-497 . A = B/C;
64-498 .
64-499 . if (A == B)
64-500 . {
64-501 . A = B + C;
64-502 . D = E + F;
64-503 . }
64-504 .
64-505 . A = B-C;
64-506 . A = B+C;
64-507 . /* LE SV TOC-3096 this is a wxp-06.2.63 req to compare*/
64-508 . A = B-C;
64-509 .
64-510 . if (A eq B)
64-511 . {
64-512 . A = B + C;
64-513 . D = E + F;
64-514 . }
64-515 .
64-516 . /* LE SV TOC-3097 this is a wxp-06.2.65 req to check unix*/
64-517 . A = B-C;
64-518 . A = B+C;
64-519 . A = B-C;
64-520 .
64-521 . if (A > B)
64-522 . {
64-523 . A = B + C;
64-524 . D = E + F;
64-525 . }
64-526 .
64-527 . A = B*C;
64-528 .
64-529 . if (A ne B)
64-530 . {
64-531 . A = B + C;
64-532 . D = E + F;
64-533 . }
64-534 .
64-535 .
64-536 . switch (wxp stuff)
64-537 . {
64-538 . case one:
64-539 . {
64-540 . run_this;
64-541 . break;
64-542 . }
64-543 . case two:
64-544 . {
64-545 . run_this;
64-546 . break;
64-547 . }
64-548 . default:
64-549 . {
64-550 . SwError;
64-551 . }
64-552 . }
64-553 .
64-554 . A = B-C;
64-555 . A = B+C;
64-556 . // max LOC 73
64-557 .
64-558 . }
64-559 .
64-560 .
64-561 . /*
64-562 . -----------------------------------------------------------------------------
64-563 . --| NAME: wxp.6.3
64-564 . --|
64-565 . --| ABSTRACT:
64-566 . --| This function does wxp stuff.
64-567 . --|
64-568 . --| RETURNS:
64-569 . --| NONE.
64-570 . --|
64-571 . ----------------------------------------------------------------------------
64-572 . */
64-573 . static void wxp.6.3(void)
64-574 . {
64-575 . A = B/C;
64-576 .
64-577 . if (A < = B)
64-578 . {
64-579 . A = B + C;
64-580 . D = E + F;
64-581 . }
64-582 .
64-583 . A = B*C;
64-584 . A = B*C;
64-585 . A = B+C;
64-586 . A = B/C;
64-587 . A = B/C;
64-588 . A = B/C;
64-589 .
64-590 . if (A > = B)
64-591 . {
64-592 . A = B + C;
64-593 . D = E + F;
64-594 . }
64-595 .
64-596 .
64-597 . if (A != B)
64-598 . {
64-599 . A = B + C;
64-600 . D = E + F;
64-601 . }
64-602 .
64-603 . A = B*C;
64-604 . A = 0x0004;
64-605 . A = B+C;
64-606 . A = B-C;
64-607 . A = B*C;
64-608 .
64-609 . if (A > = B)
64-610 . {
64-611 . A = B + C;
64-612 . D = E + F;
64-613 . }
64-614 .
64-615 .
64-616 . if (A ge B)
64-617 . {
64-618 . A = B + C;
64-619 . D = E + F;
64-620 . }
64-621 .
64-622 . A = B+C;
64-623 . A = B*C;
64-624 .
64-625 . if (A != B)
64-626 . {
64-627 . A = B + C;
64-628 . D = E + F;
64-629 . }
64-630 .
64-631 . A = B*C;
64-632 . A = B+C;
64-633 .
64-634 . if (A == B)
64-635 . {
64-636 . A = B + C;
64-637 . D = E + F;
64-638 . }
64-639 .
64-640 .
64-641 . /* dead_code = B + C;
64-642 . dead_code = D + E;
64-643 . dead_code = F + G; */
64-644 .
64-645 . A = B+C;
64-646 .
64-647 . /*
64-648 . dead_code = B - C;
64-649 . dead_code = D - E;
64-650 . dead_code = F - G;
64-651 . */
64-652 .
64-653 .
64-654 . if (A lt B)
64-655 . {
64-656 . A = B + C;
64-657 . D = E + F;
64-658 . }
64-659 .
64-660 . A = B-C;
64-661 . // max LOC 25
64-662 .
64-663 . }
64-664 .
64 64 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-06.c
65 65 Source: source/ft-app/ft-app-B1.1/wxp/wxp-07.c
65-0 . /*
65-1 . ----------------------------------------------------------------------------
65-2 . --| BEGIN PROLOGUE
65-3 . --|
65-4 . --| CLASSIFICATION: UNCLASSIFIED
65-5 . --|
65-6 . --| FILE NAME: wxp-07.c
65-7 . --|
65-8 . --| :
65-9 . --| This file contains the 13 functions that do file wxp stuff.
65-10 . --|
65-11 . --| HISTORY:
65-12 . --| CCCQ_NAME:
65-13 . --| CCCQ_VER:
65-14 . --|
65-15 . --| END PROLOGUE
65-16 . ----------------------------------------------------------------------------
65-17 . */
65-18 .
65-19 . float B;
65-20 . float B;
65-21 . #include D;
65-22 . int A;
65-23 .
65-24 .
65-25 .
65-26 . /*
65-27 . -----------------------------------------------------------------------------
65-28 . --| NAME: wxp.7.1
65-29 . --|
65-30 . --| ABSTRACT:
65-31 . --| This function does wxp stuff.
65-32 . --|
65-33 . --| RETURNS:
65-34 . --| NONE.
65-35 . --|
65-36 . ----------------------------------------------------------------------------
65-37 . */
65-38 . static void wxp.7.1(void)
65-39 . {
65-40 .
65-41 . if (A < = B)
65-42 . {
65-43 . A = B + C;
65-44 . D = E + F;
65-45 . }
65-46 .
65-47 . A = B-C;
65-48 . A = B-C;
65-49 . A = B*C;
65-50 . A = B+C;
65-51 .
65-52 . #ifdef LAZY
65-53 . // this is not nice
65-54 . A = B + C;
65-55 . A = B + C;
65-56 . #endif
65-57 .
65-58 . A = B*C;
65-59 . goto error;
65-60 . A = B/C;
65-61 . // ??? go see ws
65-62 .
65-63 . if (A < = B)
65-64 . {
65-65 . A = B + C;
65-66 . D = E + F;
65-67 . }
65-68 .
65-69 . A = B/C;
65-70 .
65-71 . if (A < = B)
65-72 . {
65-73 . A = B + C;
65-74 . D = E + F;
65-75 . }
65-76 .
65-77 .
65-78 . if (A lt B)
65-79 . {
65-80 . A = B + C;
65-81 . D = E + F;
65-82 . }
65-83 .
65-84 . do forever;
65-85 .
65-86 . if (A == B)
65-87 . {
65-88 . A = B + C;
65-89 . D = E + F;
65-90 . }
65-91 .
65-92 .
65-93 . if (A gt B)
65-94 . {
65-95 . A = B + C;
65-96 . D = E + F;
65-97 . }
65-98 .
65-99 . // max LOC 13
65-100 .
65-101 . }
65-102 .
65-103 .
65-104 . /*
65-105 . -----------------------------------------------------------------------------
65-106 . --| NAME: wxp.7.2
65-107 . --|
65-108 . --| ABSTRACT:
65-109 . --| This function does wxp stuff.
65-110 . --|
65-111 . --| RETURNS:
65-112 . --| NONE.
65-113 . --|
65-114 . ----------------------------------------------------------------------------
65-115 . */
65-116 . static void wxp.7.2(void)
65-117 . {
65-118 . A = B+C;
65-119 .
65-120 . if (A < B)
65-121 . {
65-122 . A = B + C;
65-123 . D = E + F;
65-124 . }
65-125 .
65-126 .
65-127 . if (A lt B)
65-128 . {
65-129 . A = B + C;
65-130 . D = E + F;
65-131 . }
65-132 .
65-133 . A = B*C;
65-134 .
65-135 . if (A == B)
65-136 . {
65-137 . A = B + C;
65-138 . D = E + F;
65-139 . }
65-140 .
65-141 .
65-142 . if (A ge B)
65-143 . {
65-144 . A = B + C;
65-145 . D = E + F;
65-146 . }
65-147 .
65-148 .
65-149 . if (A ge B)
65-150 . {
65-151 . A = B + C;
65-152 . D = E + F;
65-153 . }
65-154 .
65-155 . A = B/C;
65-156 .
65-157 . if (A > = B)
65-158 . {
65-159 . A = B + C;
65-160 . D = E + F;
65-161 . }
65-162 .
65-163 . A = B-C;
65-164 .
65-165 . if (A == B)
65-166 . {
65-167 . A = B + C;
65-168 . D = E + F;
65-169 . }
65-170 .
65-171 . A = B+C;
65-172 .
65-173 . if (A eq B)
65-174 . {
65-175 . A = B + C;
65-176 . D = E + F;
65-177 . }
65-178 .
65-179 . A = B-C;
65-180 . A = B/C;
65-181 . A = B-C;
65-182 .
65-183 . if (A < = B)
65-184 . {
65-185 . A = B + C;
65-186 . D = E + F;
65-187 . }
65-188 .
65-189 . // max LOC 17
65-190 .
65-191 . }
65-192 .
65-193 .
65-194 . /*
65-195 . -----------------------------------------------------------------------------
65-196 . --| NAME: wxp.7.3
65-197 . --|
65-198 . --| ABSTRACT:
65-199 . --| This function does wxp stuff.
65-200 . --|
65-201 . --| RETURNS:
65-202 . --| NONE.
65-203 . --|
65-204 . ----------------------------------------------------------------------------
65-205 . */
65-206 . static void wxp.7.3(void)
65-207 . {
65-208 .
65-209 . if (A eq B)
65-210 . {
65-211 . A = B + C;
65-212 . D = E + F;
65-213 . }
65-214 .
65-215 .
65-216 . if (A > B)
65-217 . {
65-218 . A = B + C;
65-219 . D = E + F;
65-220 . }
65-221 .
65-222 .
65-223 . if (A > B)
65-224 . {
65-225 . A = B + C;
65-226 . D = E + F;
65-227 . }
65-228 .
65-229 . A = B/C;
65-230 . A = B-C;
65-231 . /* LE SV TOC-3098 this is a wxp-07.3.6 req to audit*/
65-232 .
65-233 . if (A ge B)
65-234 . {
65-235 . A = B + C;
65-236 . D = E + F;
65-237 . }
65-238 .
65-239 .
65-240 . if (A > = B)
65-241 . {
65-242 . A = B + C;
65-243 . D = E + F;
65-244 . }
65-245 .
65-246 .
65-247 . if (A < B)
65-248 . {
65-249 . A = B + C;
65-250 . D = E + F;
65-251 . }
65-252 .
65-253 . A = B*C;
65-254 . A = B*C;
65-255 . A = B-C;
65-256 . A = B-C;
65-257 . A = B-C;
65-258 . A = B-C;
65-259 . A = B/C;
65-260 . A = B-C;
65-261 .
65-262 . if (A eq B)
65-263 . {
65-264 . A = B + C;
65-265 . D = E + F;
65-266 . }
65-267 .
65-268 . A = B*C;
65-269 . A = B+C;
65-270 . A = B-C;
65-271 . A = B/C;
65-272 . A = B-C;
65-273 . A = B*C;
65-274 . A = B+C;
65-275 .
65-276 . switch (wxp stuff)
65-277 . {
65-278 . case one:
65-279 . {
65-280 . run_this;
65-281 . // missing break
65-282 . }
65-283 . case two:
65-284 . {
65-285 . run_this;
65-286 . break;
65-287 . }
65-288 . default:
65-289 . {
65-290 . SwError;
65-291 . }
65-292 . }
65-293 .
65-294 . A = B/C;
65-295 . A = B/C;
65-296 . A = B-C;
65-297 . A = B-C;
65-298 . A = B/C;
65-299 . A = B*C;
65-300 . A = B-C;
65-301 . A = B/C;
65-302 . A = B+C;
65-303 . A = B-C;
65-304 .
65-305 . if (A < B)
65-306 . {
65-307 . A = B + C;
65-308 . D = E + F;
65-309 . }
65-310 .
65-311 . A = B/C;
65-312 .
65-313 . if (A > = B)
65-314 . {
65-315 . A = B + C;
65-316 . D = E + F;
65-317 . }
65-318 .
65-319 . A = B*C;
65-320 . A = B*C;
65-321 . A = B*C;
65-322 . A = B*C;
65-323 . A = B-C;
65-324 . A = B-C;
65-325 .
65-326 . if (A < B)
65-327 . {
65-328 . A = B + C;
65-329 . D = E + F;
65-330 . }
65-331 .
65-332 . // max LOC 44
65-333 .
65-334 . }
65-335 .
65-336 .
65-337 . /*
65-338 . -----------------------------------------------------------------------------
65-339 . --| NAME: wxp.7.4
65-340 . --|
65-341 . --| ABSTRACT:
65-342 . --| This function does wxp stuff.
65-343 . --|
65-344 . --| RETURNS:
65-345 . --| NONE.
65-346 . --|
65-347 . ----------------------------------------------------------------------------
65-348 . */
65-349 . static void wxp.7.4(void)
65-350 . {
65-351 . A = B*C;
65-352 .
65-353 . if (A < = B)
65-354 . {
65-355 . A = B + C;
65-356 . D = E + F;
65-357 . }
65-358 .
65-359 .
65-360 . if (A lt B)
65-361 . {
65-362 . A = B + C;
65-363 . D = E + F;
65-364 . }
65-365 .
65-366 . A = B+C;
65-367 .
65-368 . if (A lt B)
65-369 . {
65-370 . A = B + C;
65-371 . D = E + F;
65-372 . }
65-373 .
65-374 .
65-375 . if (A > B)
65-376 . {
65-377 . A = B + C;
65-378 . D = E + F;
65-379 . }
65-380 .
65-381 . A = B*C;
65-382 .
65-383 . if (A > = B)
65-384 . {
65-385 . A = B + C;
65-386 . D = E + F;
65-387 . }
65-388 .
65-389 .
65-390 . if (A > = B)
65-391 . {
65-392 . A = B + C;
65-393 . D = E + F;
65-394 . }
65-395 .
65-396 . A = B/C;
65-397 .
65-398 . if (A gt B)
65-399 . {
65-400 . A = B + C;
65-401 . D = E + F;
65-402 . }
65-403 .
65-404 . A = B*C;
65-405 . A = B-C;
65-406 . A = B+C;
65-407 . rcv_buffer = (U16 *) alloc(size+1);
65-408 . A = B/C;
65-409 . A = B*C;
65-410 . A = B/C;
65-411 .
65-412 . /*
65-413 . dead_block = C * D;
65-414 . dead_block = E * F;
65-415 . */
65-416 .
65-417 . A = B-C;
65-418 . A = B*C;
65-419 . A = B+C;
65-420 .
65-421 . if (A gt B)
65-422 . {
65-423 . A = B + C;
65-424 . D = E + F;
65-425 . }
65-426 .
65-427 . A = 0x0006;
65-428 . A = B+C;
65-429 .
65-430 . if (A > B)
65-431 . {
65-432 . A = B + C;
65-433 . D = E + F;
65-434 . }
65-435 .
65-436 . A = B*C;
65-437 . A = B-C;
65-438 . A = B+C;
65-439 .
65-440 . if (A != B)
65-441 . {
65-442 . A = B + C;
65-443 . D = E + F;
65-444 . }
65-445 .
65-446 . A = (float)B + C;
65-447 .
65-448 . if (A == B)
65-449 . {
65-450 . A = B + C;
65-451 . D = E + F;
65-452 . }
65-453 .
65-454 .
65-455 . switch (wxp stuff)
65-456 . {
65-457 . case one:
65-458 . {
65-459 . run_this;
65-460 . break;
65-461 . }
65-462 . case two:
65-463 . {
65-464 . run_this;
65-465 . break;
65-466 . }
65-467 . default:
65-468 . {
65-469 . SwError;
65-470 . }
65-471 . }
65-472 .
65-473 . A = B/C;
65-474 .
65-475 . if (A eq B)
65-476 . {
65-477 . A = B + C;
65-478 . D = E + F;
65-479 . }
65-480 .
65-481 .
65-482 . if (A > B)
65-483 . {
65-484 . A = B + C;
65-485 . D = E + F;
65-486 . }
65-487 .
65-488 . A = B/C;
65-489 .
65-490 . if (A == B)
65-491 . {
65-492 . A = B + C;
65-493 . D = E + F;
65-494 . }
65-495 .
65-496 .
65-497 . if (A gt B)
65-498 . {
65-499 . A = B + C;
65-500 . D = E + F;
65-501 . }
65-502 .
65-503 . A = B+C;
65-504 .
65-505 . if (A gt B)
65-506 . {
65-507 . A = B + C;
65-508 . D = E + F;
65-509 . }
65-510 .
65-511 . A = B+C;
65-512 . A = B-C;
65-513 .
65-514 . #ifdef LAZY
65-515 . // this is not nice
65-516 . A = B + C;
65-517 . A = B + C;
65-518 . #endif
65-519 .
65-520 .
65-521 . if (A > = B)
65-522 . {
65-523 . A = B + C;
65-524 . D = E + F;
65-525 . }
65-526 .
65-527 . A = B/C;
65-528 . A = B*C;
65-529 . A = B+C;
65-530 .
65-531 . if (A > = B)
65-532 . {
65-533 . A = B + C;
65-534 . D = E + F;
65-535 . }
65-536 .
65-537 . A = 0x0007;
65-538 . A = B*C;
65-539 .
65-540 . if (A > B)
65-541 . {
65-542 . A = B + C;
65-543 . D = E + F;
65-544 . }
65-545 .
65-546 . /* LE SV TOC-3099 this is a wxp-07.4.47 req to inhibit*/
65-547 . A = B+C;
65-548 . A = B+C;
65-549 .
65-550 . if (A lt B)
65-551 . {
65-552 . A = B + C;
65-553 . D = E + F;
65-554 . }
65-555 .
65-556 . A = B+C;
65-557 . A = B+C;
65-558 . A = B*C;
65-559 . A = B/C;
65-560 .
65-561 . if (A != B)
65-562 . {
65-563 . A = B + C;
65-564 . D = E + F;
65-565 . }
65-566 .
65-567 .
65-568 . if (A le B)
65-569 . {
65-570 . A = B + C;
65-571 . D = E + F;
65-572 . }
65-573 .
65-574 . A = B-C;
65-575 . /* LE SV TOC-3100 this is a wxp-07.4.57 req to transform*/
65-576 . A = B*C;
65-577 .
65-578 . if (A ge B)
65-579 . {
65-580 . A = B + C;
65-581 . D = E + F;
65-582 . }
65-583 .
65-584 .
65-585 . if (A != B)
65-586 . {
65-587 . A = B + C;
65-588 . D = E + F;
65-589 . }
65-590 .
65-591 . A = B/C;
65-592 .
65-593 . if (A != B)
65-594 . {
65-595 . A = B + C;
65-596 . D = E + F;
65-597 . }
65-598 .
65-599 . A = B-C;
65-600 . A = B+C;
65-601 . // max LOC 63
65-602 .
65-603 . }
65-604 .
65-605 .
65-606 . /*
65-607 . -----------------------------------------------------------------------------
65-608 . --| NAME: wxp.7.5
65-609 . --|
65-610 . --| ABSTRACT:
65-611 . --| This function does wxp stuff.
65-612 . --|
65-613 . --| RETURNS:
65-614 . --| NONE.
65-615 . --|
65-616 . ----------------------------------------------------------------------------
65-617 . */
65-618 . static void wxp.7.5(void)
65-619 . {
65-620 .
65-621 . if (A != B)
65-622 . {
65-623 . A = B + C;
65-624 . D = E + F;
65-625 . }
65-626 .
65-627 .
65-628 . if (A > B)
65-629 . {
65-630 . A = B + C;
65-631 . D = E + F;
65-632 . }
65-633 .
65-634 .
65-635 . #ifdef LAZY
65-636 . // this is not nice
65-637 . A = B + C;
65-638 . A = B + C;
65-639 . #endif
65-640 .
65-641 . A = B-C;
65-642 . A = B/C;
65-643 . A = B/C;
65-644 . A = B-C;
65-645 . A = B/C;
65-646 . /* LE SV TOC-3101 this is a wxp-07.5.8 req to translate*/
65-647 . A = B*C;
65-648 . A = B-C;
65-649 . A = B/C;
65-650 . A = B*C;
65-651 .
65-652 . switch (wxp stuff)
65-653 . {
65-654 . case:
65-655 . case:
65-656 . // stacked case statements but only if there is a new line in between
65-657 .
65-658 . case:
65-659 . case:
65-660 . case:
65-661 . {
65-662 . run_this;
65-663 . break;
65-664 . }
65-665 . default:
65-666 . {
65-667 . halt;
65-668 . }
65-669 . }
65-670 .
65-671 . A = B+C;
65-672 . A = B+C;
65-673 . A = 0x0008;
65-674 .
65-675 . switch (wxp stuff)
65-676 . {
65-677 . case one:
65-678 . {
65-679 . switch (nested)
65-680 . {
65-681 . case:
65-682 . X = Y + Z;
65-683 . case:
65-684 . X = Y + Z;
65-685 . default:
65-686 . SwError;
65-687 . }
65-688 . }
65-689 . case two:
65-690 . {
65-691 . run_this;
65-692 . break;
65-693 . }
65-694 . default:
65-695 . {
65-696 . SwError;
65-697 . }
65-698 . }
65-699 .
65-700 . A = B*C;
65-701 . A = B+C;
65-702 . A = B+C;
65-703 . A = B+C;
65-704 .
65-705 . if (A < B)
65-706 . {
65-707 . A = B + C;
65-708 . D = E + F;
65-709 . }
65-710 .
65-711 . A = B*C;
65-712 . A = B/C;
65-713 . A = B/C;
65-714 . A = B+C;
65-715 .
65-716 . if (A < = B)
65-717 . {
65-718 . A = B + C;
65-719 . D = E + F;
65-720 . }
65-721 .
65-722 . /* LE SV TOC-3102 this is a wxp-07.5.24 req to verify*/
65-723 . A = B+C;
65-724 . A = B+C;
65-725 . /* LE SV TOC-3103 this is a wxp-07.5.26 req to check pSOS*/
65-726 . A = B-C;
65-727 . A = B/C;
65-728 .
65-729 . if (A != B)
65-730 . {
65-731 . A = B + C;
65-732 . D = E + F;
65-733 . }
65-734 .
65-735 . A = B-C;
65-736 . A = B*C;
65-737 . A = B+C;
65-738 . A = B+C;
65-739 . // max LOC 32
65-740 .
65-741 . }
65-742 .
65-743 .
65-744 . /*
65-745 . -----------------------------------------------------------------------------
65-746 . --| NAME: wxp.7.6
65-747 . --|
65-748 . --| ABSTRACT:
65-749 . --| This function does wxp stuff.
65-750 . --|
65-751 . --| RETURNS:
65-752 . --| NONE.
65-753 . --|
65-754 . ----------------------------------------------------------------------------
65-755 . */
65-756 . static void wxp.7.6(void)
65-757 . {
65-758 .
65-759 . if (A > B)
65-760 . {
65-761 . A = B + C;
65-762 . D = E + F;
65-763 . }
65-764 .
65-765 .
65-766 . if (A eq B)
65-767 . {
65-768 . A = B + C;
65-769 . D = E + F;
65-770 . }
65-771 .
65-772 . A = B-C;
65-773 . A = B-C;
65-774 .
65-775 . if (A != B)
65-776 . {
65-777 . A = B + C;
65-778 . D = E + F;
65-779 . }
65-780 .
65-781 . A = B-C;
65-782 . A = B/C;
65-783 . A = B+C;
65-784 .
65-785 . if (A < B)
65-786 . {
65-787 . A = B + C;
65-788 . D = E + F;
65-789 . }
65-790 .
65-791 . A = B*C;
65-792 .
65-793 . if (A > = B)
65-794 . {
65-795 . A = B + C;
65-796 . D = E + F;
65-797 . }
65-798 .
65-799 . A = B/C;
65-800 . A = B-C;
65-801 . A = B-C;
65-802 .
65-803 . if (A eq B)
65-804 . {
65-805 . A = B + C;
65-806 . D = E + F;
65-807 . }
65-808 .
65-809 . A = B-C;
65-810 . A = B+C;
65-811 . A = B/C;
65-812 .
65-813 . if (A gt B)
65-814 . {
65-815 . A = B + C;
65-816 . D = E + F;
65-817 . }
65-818 .
65-819 .
65-820 . if (A != B)
65-821 . {
65-822 . A = B + C;
65-823 . D = E + F;
65-824 . }
65-825 .
65-826 .
65-827 . if (A < B)
65-828 . {
65-829 . A = B + C;
65-830 . D = E + F;
65-831 . }
65-832 .
65-833 . A = B/C;
65-834 .
65-835 . /* dead_code = B + C;
65-836 . dead_code = D + E;
65-837 . dead_code = F + G; */
65-838 .
65-839 . A = B-C;
65-840 . A = B-C;
65-841 . A = B-C;
65-842 .
65-843 . if (A lt B)
65-844 . {
65-845 . A = B + C;
65-846 . D = E + F;
65-847 . }
65-848 .
65-849 . A = B-C;
65-850 .
65-851 . if (A lt B)
65-852 . {
65-853 . A = B + C;
65-854 . D = E + F;
65-855 . }
65-856 .
65-857 . A = B*C;
65-858 . /* LE SV TOC-3104 this is a wxp-07.6.30 req to halt*/
65-859 . A = B+C;
65-860 . A = B/C;
65-861 .
65-862 . if (A ne B)
65-863 . {
65-864 . A = B + C;
65-865 . D = E + F;
65-866 . }
65-867 .
65-868 . A = B/C;
65-869 . A = B+C;
65-870 . A = B/C;
65-871 . A = B*C;
65-872 . A = B*C;
65-873 . A = B-C;
65-874 . A = B+C;
65-875 . A = B/C;
65-876 . A = B/C;
65-877 .
65-878 . if (A ne B)
65-879 . {
65-880 . A = B + C;
65-881 . D = E + F;
65-882 . }
65-883 .
65-884 .
65-885 . if (A < = B)
65-886 . {
65-887 . A = B + C;
65-888 . D = E + F;
65-889 . }
65-890 .
65-891 .
65-892 . switch (wxp stuff)
65-893 . {
65-894 . case one:
65-895 . {
65-896 . run_this;
65-897 . break;
65-898 . }
65-899 . case two:
65-900 . {
65-901 . run_this;
65-902 . break;
65-903 . }
65-904 . default:
65-905 . {
65-906 . SwError;
65-907 . }
65-908 . }
65-909 .
65-910 .
65-911 . if (A le B)
65-912 . {
65-913 . A = B + C;
65-914 . D = E + F;
65-915 . }
65-916 .
65-917 . A = B-C;
65-918 . A = B+C;
65-919 . A = B-C;
65-920 .
65-921 . if (A le B)
65-922 . {
65-923 . A = B + C;
65-924 . D = E + F;
65-925 . }
65-926 .
65-927 . A = B/C;
65-928 .
65-929 . if (A > B)
65-930 . {
65-931 . A = B + C;
65-932 . D = E + F;
65-933 . }
65-934 .
65-935 . A = B*C;
65-936 . A = B*C;
65-937 .
65-938 . if (A eq B)
65-939 . {
65-940 . A = B + C;
65-941 . D = E + F;
65-942 . }
65-943 .
65-944 . // max LOC 54
65-945 .
65-946 . }
65-947 .
65-948 .
65-949 . /*
65-950 . -----------------------------------------------------------------------------
65-951 . --| NAME: wxp.7.7
65-952 . --|
65-953 . --| ABSTRACT:
65-954 . --| This function does wxp stuff.
65-955 . --|
65-956 . --| RETURNS:
65-957 . --| NONE.
65-958 . --|
65-959 . ----------------------------------------------------------------------------
65-960 . */
65-961 . static void wxp.7.7(void)
65-962 . {
65-963 . A = B-C;
65-964 . A = B/C;
65-965 . A = B*C;
65-966 . A = B*C;
65-967 . A = B*C;
65-968 . FreePtr = HmiStringPtr;
65-969 . A = B+C;
65-970 . A = B+C;
65-971 .
65-972 . if (A != B)
65-973 . {
65-974 . A = B + C;
65-975 . D = E + F;
65-976 . }
65-977 .
65-978 . A = B-C;
65-979 . A = B+C;
65-980 . do forever;
65-981 .
65-982 . if (A ge B)
65-983 . {
65-984 . A = B + C;
65-985 . D = E + F;
65-986 . }
65-987 .
65-988 .
65-989 . if (A eq B)
65-990 . {
65-991 . A = B + C;
65-992 . D = E + F;
65-993 . }
65-994 .
65-995 . A = B/C;
65-996 .
65-997 . if (A < B)
65-998 . {
65-999 . A = B + C;
65-1000 . D = E + F;
65-1001 . }
65-1002 .
65-1003 . A = 0x0007;
65-1004 . A = B-C;
65-1005 .
65-1006 . if (A eq B)
65-1007 . {
65-1008 . A = B + C;
65-1009 . D = E + F;
65-1010 . }
65-1011 .
65-1012 . A = B-C;
65-1013 . A = B-C;
65-1014 . A = B+C;
65-1015 . A = B/C;
65-1016 . /* LE SV TOC-3105 this is a wxp-07.7.21 req to call isr*/
65-1017 .
65-1018 . switch (wxp stuff)
65-1019 . {
65-1020 . case one:
65-1021 . {
65-1022 . switch (nested)
65-1023 . {
65-1024 . case:
65-1025 . X = Y + Z;
65-1026 . case:
65-1027 . X = Y + Z;
65-1028 . default:
65-1029 . SwError;
65-1030 . }
65-1031 . }
65-1032 . case two:
65-1033 . {
65-1034 . run_this;
65-1035 . break;
65-1036 . }
65-1037 . default:
65-1038 . {
65-1039 . SwError;
65-1040 . }
65-1041 . }
65-1042 .
65-1043 . A = B-C;
65-1044 . A = B*C;
65-1045 . A = B/C;
65-1046 . A = B-C;
65-1047 . A = B-C;
65-1048 . A = 0x0009;
65-1049 .
65-1050 . if (A eq B)
65-1051 . {
65-1052 . A = B + C;
65-1053 . D = E + F;
65-1054 . }
65-1055 .
65-1056 . A = B-C;
65-1057 .
65-1058 . if ($wxp stuff > $otherwxp stuff)
65-1059 . /* LE SV TOC-008 we really should log all error calls */
65-1060 . {
65-1061 . A = B + C;
65-1062 . }
65-1063 .
65-1064 . A = B+C;
65-1065 . A = B*C;
65-1066 . A = B/C;
65-1067 . A = B*C;
65-1068 .
65-1069 . switch (wxp stuff)
65-1070 . {
65-1071 . case one:
65-1072 . {
65-1073 . run_this;
65-1074 . break;
65-1075 . }
65-1076 . case two:
65-1077 . {
65-1078 . run_this;
65-1079 . break;
65-1080 . }
65-1081 . default:
65-1082 . {
65-1083 . SwError;
65-1084 . }
65-1085 . }
65-1086 .
65-1087 . A = B*C;
65-1088 . A = B-C;
65-1089 .
65-1090 . if (A > B)
65-1091 . {
65-1092 . A = B + C;
65-1093 . D = E + F;
65-1094 . }
65-1095 .
65-1096 . A = B*C;
65-1097 .
65-1098 . if (A < = B)
65-1099 . {
65-1100 . A = B + C;
65-1101 . D = E + F;
65-1102 . }
65-1103 .
65-1104 . A = B+C;
65-1105 . A = B/C;
65-1106 .
65-1107 . if (A gt B)
65-1108 . {
65-1109 . A = B + C;
65-1110 . D = E + F;
65-1111 . }
65-1112 .
65-1113 . /* LE SV TOC-3106 this is a wxp-07.7.41 req to enable*/
65-1114 .
65-1115 . /* dead_block = C * D;
65-1116 . dead_block = E * F; */
65-1117 .
65-1118 . A = B-C;
65-1119 . A = B*C;
65-1120 . A = B-C;
65-1121 . A = B+C;
65-1122 . A = B*C;
65-1123 .
65-1124 . if (A ne B)
65-1125 . {
65-1126 . A = B + C;
65-1127 . D = E + F;
65-1128 . }
65-1129 .
65-1130 . A = B-C;
65-1131 .
65-1132 . if (A < = B)
65-1133 . {
65-1134 . A = B + C;
65-1135 . D = E + F;
65-1136 . }
65-1137 .
65-1138 .
65-1139 . switch (wxp stuff)
65-1140 . {
65-1141 . case one:
65-1142 . {
65-1143 . run_this;
65-1144 . // missing break
65-1145 . }
65-1146 . case two:
65-1147 . {
65-1148 . run_this;
65-1149 . break;
65-1150 . }
65-1151 . default:
65-1152 . {
65-1153 . SwError;
65-1154 . }
65-1155 . }
65-1156 .
65-1157 . A = B/C;
65-1158 . A = B+C;
65-1159 . do forever;
65-1160 . A = B/C;
65-1161 . A = B-C;
65-1162 . /* LE SV TOC-3107 this is a wxp-07.7.53 req to increment*/
65-1163 .
65-1164 . if (A le B)
65-1165 . {
65-1166 . A = B + C;
65-1167 . D = E + F;
65-1168 . }
65-1169 .
65-1170 . A = B-C;
65-1171 . A = B/C;
65-1172 . // max LOC 55
65-1173 .
65-1174 . }
65-1175 .
65-1176 .
65-1177 . /*
65-1178 . -----------------------------------------------------------------------------
65-1179 . --| NAME: wxp.7.8
65-1180 . --|
65-1181 . --| ABSTRACT:
65-1182 . --| This function does wxp stuff.
65-1183 . --|
65-1184 . --| RETURNS:
65-1185 . --| NONE.
65-1186 . --|
65-1187 . ----------------------------------------------------------------------------
65-1188 . */
65-1189 . static void wxp.7.8(void)
65-1190 . {
65-1191 . A = B/C;
65-1192 . A = B*C;
65-1193 .
65-1194 . if (A gt B)
65-1195 . {
65-1196 . A = B + C;
65-1197 . D = E + F;
65-1198 . }
65-1199 .
65-1200 . A = B*C;
65-1201 .
65-1202 . switch (wxp stuff)
65-1203 . {
65-1204 . case one:
65-1205 . {
65-1206 . run_this;
65-1207 . break;
65-1208 . }
65-1209 . case two:
65-1210 . {
65-1211 . run_this;
65-1212 . break;
65-1213 . }
65-1214 . default:
65-1215 . {
65-1216 . SwError;
65-1217 . }
65-1218 . }
65-1219 .
65-1220 . A = B/C;
65-1221 .
65-1222 . if (A < = B)
65-1223 . {
65-1224 . A = B + C;
65-1225 . D = E + F;
65-1226 . }
65-1227 .
65-1228 .
65-1229 . if (A eq B)
65-1230 . {
65-1231 . A = B + C;
65-1232 . D = E + F;
65-1233 . }
65-1234 .
65-1235 . A = B/C;
65-1236 . A = B-C;
65-1237 . // max LOC 10
65-1238 .
65-1239 . }
65-1240 .
65-1241 .
65-1242 . /*
65-1243 . -----------------------------------------------------------------------------
65-1244 . --| NAME: wxp.7.9
65-1245 . --|
65-1246 . --| ABSTRACT:
65-1247 . --| This function does wxp stuff.
65-1248 . --|
65-1249 . --| RETURNS:
65-1250 . --| NONE.
65-1251 . --|
65-1252 . ----------------------------------------------------------------------------
65-1253 . */
65-1254 . static void wxp.7.9(void)
65-1255 . {
65-1256 . A = B-C;
65-1257 . A = B/C;
65-1258 .
65-1259 . if (A < = B)
65-1260 . {
65-1261 . A = B + C;
65-1262 . D = E + F;
65-1263 . }
65-1264 .
65-1265 .
65-1266 . if (A < = B)
65-1267 . {
65-1268 . A = B + C;
65-1269 . D = E + F;
65-1270 . }
65-1271 .
65-1272 . A = B/C;
65-1273 . free(FreePtr);
65-1274 .
65-1275 . if (A ge B)
65-1276 . {
65-1277 . A = B + C;
65-1278 . D = E + F;
65-1279 . }
65-1280 .
65-1281 . A = B-C;
65-1282 . A = 0x0001;
65-1283 . A = B+C;
65-1284 . A = B-C;
65-1285 .
65-1286 . if (A > B)
65-1287 . {
65-1288 . A = B + C;
65-1289 . D = E + F;
65-1290 . }
65-1291 .
65-1292 .
65-1293 . if (A lt B)
65-1294 . {
65-1295 . A = B + C;
65-1296 . D = E + F;
65-1297 . }
65-1298 .
65-1299 . A = B*C;
65-1300 . A = B-C;
65-1301 .
65-1302 . if (A < = B)
65-1303 . {
65-1304 . A = B + C;
65-1305 . D = E + F;
65-1306 . }
65-1307 .
65-1308 . A = B-C;
65-1309 .
65-1310 . /*
65-1311 . dead_code = B - C;
65-1312 . dead_code = D - E;
65-1313 . dead_code = F - G;
65-1314 . */
65-1315 .
65-1316 . A = B/C;
65-1317 . A = B/C;
65-1318 . /* LE SV TOC-3108 this is a wxp-07.9.18 req to detect error*/
65-1319 .
65-1320 . switch (wxp stuff)
65-1321 . {
65-1322 . case one:
65-1323 . {
65-1324 . run_this;
65-1325 . break;
65-1326 . }
65-1327 . case two:
65-1328 . {
65-1329 . run_this;
65-1330 . break;
65-1331 . }
65-1332 . default:
65-1333 . {
65-1334 . SwError;
65-1335 . }
65-1336 . }
65-1337 .
65-1338 . A = B/C;
65-1339 .
65-1340 . if (A gt B)
65-1341 . {
65-1342 . A = B + C;
65-1343 . D = E + F;
65-1344 . }
65-1345 .
65-1346 . A = B*C;
65-1347 . A = B*C;
65-1348 .
65-1349 . switch (wxp stuff)
65-1350 . {
65-1351 . case one:
65-1352 . {
65-1353 . run_this;
65-1354 . break;
65-1355 . }
65-1356 . case two:
65-1357 . {
65-1358 . run_this;
65-1359 . break;
65-1360 . }
65-1361 . default:
65-1362 . {
65-1363 . SwError;
65-1364 . }
65-1365 . }
65-1366 .
65-1367 . A = B*C;
65-1368 . // TBS - I need to figure this out
65-1369 . A = B-C;
65-1370 . A = B*C;
65-1371 . A = B+C;
65-1372 . A = B*C;
65-1373 .
65-1374 . if (A eq B)
65-1375 . {
65-1376 . A = B + C;
65-1377 . D = E + F;
65-1378 . }
65-1379 .
65-1380 .
65-1381 . switch (wxp stuff)
65-1382 . {
65-1383 . case one:
65-1384 . {
65-1385 . run_this;
65-1386 . break;
65-1387 . }
65-1388 . case two:
65-1389 . {
65-1390 . run_this;
65-1391 . break;
65-1392 . }
65-1393 . default:
65-1394 . {
65-1395 . SwError;
65-1396 . }
65-1397 . }
65-1398 .
65-1399 . A = B-C;
65-1400 . A = B+C;
65-1401 .
65-1402 . if (A ge B)
65-1403 . {
65-1404 . A = B + C;
65-1405 . D = E + F;
65-1406 . }
65-1407 .
65-1408 . A = B*C;
65-1409 .
65-1410 . if (A ne B)
65-1411 . {
65-1412 . A = B + C;
65-1413 . D = E + F;
65-1414 . }
65-1415 .
65-1416 . A = B/C;
65-1417 .
65-1418 . if (A < B)
65-1419 . {
65-1420 . A = B + C;
65-1421 . D = E + F;
65-1422 . }
65-1423 .
65-1424 .
65-1425 . if (A > B)
65-1426 . {
65-1427 . A = B + C;
65-1428 . D = E + F;
65-1429 . }
65-1430 .
65-1431 .
65-1432 . if (A != B)
65-1433 . {
65-1434 . A = B + C;
65-1435 . D = E + F;
65-1436 . }
65-1437 .
65-1438 . // max LOC 39
65-1439 .
65-1440 . }
65-1441 .
65-1442 .
65-1443 . /*
65-1444 . -----------------------------------------------------------------------------
65-1445 . --| NAME: wxp.7.10
65-1446 . --|
65-1447 . --| ABSTRACT:
65-1448 . --| This function does wxp stuff.
65-1449 . --|
65-1450 . --| RETURNS:
65-1451 . --| NONE.
65-1452 . --|
65-1453 . ----------------------------------------------------------------------------
65-1454 . */
65-1455 . static void wxp.7.10(void)
65-1456 . {
65-1457 . A = B/C;
65-1458 . A = B+C;
65-1459 . A = B*C;
65-1460 . A = B+C;
65-1461 . /* LE SV TOC-3109 this is a wxp-07.10.5 req to set Real Time Clock*/
65-1462 . A = B-C;
65-1463 . A = B/C;
65-1464 . A = B*C;
65-1465 . A = B/C;
65-1466 . A = B+C;
65-1467 . /* LE SV TOC-3110 this is a wxp-07.10.10 req to record*/
65-1468 . A = B*C;
65-1469 .
65-1470 . switch (wxp stuff)
65-1471 . {
65-1472 . case one:
65-1473 . {
65-1474 . run_this;
65-1475 . break;
65-1476 . }
65-1477 . case two:
65-1478 . {
65-1479 . run_this;
65-1480 . break;
65-1481 . }
65-1482 . default:
65-1483 . {
65-1484 . // missing error call
65-1485 . }
65-1486 . }
65-1487 .
65-1488 . A = B+C;
65-1489 . A = B-C;
65-1490 .
65-1491 . if (A > B)
65-1492 . {
65-1493 . A = B + C;
65-1494 . D = E + F;
65-1495 . }
65-1496 .
65-1497 . A = B/C;
65-1498 . A = B*C;
65-1499 . A = B*C;
65-1500 . A = B-C;
65-1501 . A = B*C;
65-1502 . A = 0x0002;
65-1503 . A = B-C;
65-1504 . A = B-C;
65-1505 . A = B/C;
65-1506 . A = B/C;
65-1507 .
65-1508 . if (A < B)
65-1509 . {
65-1510 . A = B + C;
65-1511 . D = E + F;
65-1512 . }
65-1513 .
65-1514 . A = B+C;
65-1515 . A = B/C;
65-1516 .
65-1517 . if (A gt B)
65-1518 . {
65-1519 . A = B + C;
65-1520 . D = E + F;
65-1521 . }
65-1522 .
65-1523 . A = B*C;
65-1524 . A = B+C;
65-1525 . A = B-C;
65-1526 . A = B+C;
65-1527 . A = B*C;
65-1528 . A = B-C;
65-1529 . A = B+C;
65-1530 . A = B+C;
65-1531 . A = B-C;
65-1532 .
65-1533 . if (A lt B)
65-1534 . {
65-1535 . A = B + C;
65-1536 . D = E + F;
65-1537 . }
65-1538 .
65-1539 .
65-1540 . if (A < = B)
65-1541 . {
65-1542 . A = B + C;
65-1543 . D = E + F;
65-1544 . }
65-1545 .
65-1546 .
65-1547 . if (A le B)
65-1548 . {
65-1549 . A = B + C;
65-1550 . D = E + F;
65-1551 . }
65-1552 .
65-1553 . // TBD - what do I do now
65-1554 . A = B+C;
65-1555 .
65-1556 . if (A ne B)
65-1557 . {
65-1558 . A = B + C;
65-1559 . D = E + F;
65-1560 . }
65-1561 .
65-1562 . A = B*C;
65-1563 . A = B-C;
65-1564 . A = B-C;
65-1565 .
65-1566 . if (A lt B)
65-1567 . {
65-1568 . A = B + C;
65-1569 . D = E + F;
65-1570 . }
65-1571 .
65-1572 . // TBS - I need to figure this out
65-1573 . A = B*C;
65-1574 .
65-1575 . if (A == B)
65-1576 . {
65-1577 . A = B + C;
65-1578 . D = E + F;
65-1579 . }
65-1580 .
65-1581 .
65-1582 . if (A < B)
65-1583 . {
65-1584 . A = B + C;
65-1585 . D = E + F;
65-1586 . }
65-1587 .
65-1588 . A = B-C;
65-1589 .
65-1590 . if (A le B)
65-1591 . {
65-1592 . A = B + C;
65-1593 . D = E + F;
65-1594 . }
65-1595 .
65-1596 . A = B+C;
65-1597 . /* LE SV TOC-3111 this is a wxp-07.10.51 req to update*/
65-1598 . A = 0x0009;
65-1599 . A = B*C;
65-1600 . /* LE SV TOC-3112 this is a wxp-07.10.52 req to disable*/
65-1601 . A = B/C;
65-1602 . A = B+C;
65-1603 . A = B/C;
65-1604 .
65-1605 . if (A < = B)
65-1606 . {
65-1607 . A = B + C;
65-1608 . D = E + F;
65-1609 . }
65-1610 .
65-1611 . A = B/C;
65-1612 .
65-1613 . if (A eq B)
65-1614 . {
65-1615 . A = B + C;
65-1616 . D = E + F;
65-1617 . }
65-1618 .
65-1619 .
65-1620 . /*
65-1621 . dead_block = C * D;
65-1622 . dead_block = E * F;
65-1623 . */
65-1624 .
65-1625 . A = B*C;
65-1626 .
65-1627 . if (A eq B)
65-1628 . {
65-1629 . A = B + C;
65-1630 . D = E + F;
65-1631 . }
65-1632 .
65-1633 . // max LOC 59
65-1634 .
65-1635 . }
65-1636 .
65-1637 .
65-1638 . /*
65-1639 . -----------------------------------------------------------------------------
65-1640 . --| NAME: wxp.7.11
65-1641 . --|
65-1642 . --| ABSTRACT:
65-1643 . --| This function does wxp stuff.
65-1644 . --|
65-1645 . --| RETURNS:
65-1646 . --| NONE.
65-1647 . --|
65-1648 . ----------------------------------------------------------------------------
65-1649 . */
65-1650 . static void wxp.7.11(void)
65-1651 . {
65-1652 . FreePtr = HmiStringPtr;
65-1653 .
65-1654 . if (A lt B)
65-1655 . {
65-1656 . A = B + C;
65-1657 . D = E + F;
65-1658 . }
65-1659 .
65-1660 . A = B+C;
65-1661 . A = 0x0003;
65-1662 .
65-1663 . switch (wxp stuff)
65-1664 . {
65-1665 . case one:
65-1666 . {
65-1667 . run_this;
65-1668 . break;
65-1669 . }
65-1670 . case two:
65-1671 . {
65-1672 . run_this;
65-1673 . break;
65-1674 . }
65-1675 . default:
65-1676 . {
65-1677 . SwError;
65-1678 . }
65-1679 . }
65-1680 .
65-1681 . A = B/C;
65-1682 .
65-1683 . if (A ne B)
65-1684 . {
65-1685 . A = B + C;
65-1686 . D = E + F;
65-1687 . }
65-1688 .
65-1689 . A = B*C;
65-1690 . A = B+C;
65-1691 . A = B*C;
65-1692 . A = B-C;
65-1693 . A = B+C;
65-1694 . FreePtr = HmiStringPtr;
65-1695 . A = B/C;
65-1696 . /* LE SV TOC-3113 this is a wxp-07.11.12 req to store*/
65-1697 . A = B+C;
65-1698 . A = B-C;
65-1699 .
65-1700 . if (A lt B)
65-1701 . {
65-1702 . A = B + C;
65-1703 . D = E + F;
65-1704 . }
65-1705 .
65-1706 . A = B*C;
65-1707 .
65-1708 . if (A gt B)
65-1709 . {
65-1710 . A = B + C;
65-1711 . D = E + F;
65-1712 . }
65-1713 .
65-1714 . A = B*C;
65-1715 .
65-1716 . if (A ge B)
65-1717 . {
65-1718 . A = B + C;
65-1719 . D = E + F;
65-1720 . }
65-1721 .
65-1722 . A = B+C;
65-1723 . A = B*C;
65-1724 .
65-1725 . if (A > B)
65-1726 . {
65-1727 . A = B + C;
65-1728 . D = E + F;
65-1729 . }
65-1730 .
65-1731 .
65-1732 . if (A le B)
65-1733 . {
65-1734 . A = B + C;
65-1735 . D = E + F;
65-1736 . }
65-1737 .
65-1738 .
65-1739 . switch (wxp stuff)
65-1740 . {
65-1741 . case one:
65-1742 . {
65-1743 . run_this;
65-1744 . // missing break
65-1745 . }
65-1746 . case two:
65-1747 . {
65-1748 . run_this;
65-1749 . break;
65-1750 . }
65-1751 . default:
65-1752 . {
65-1753 . SwError;
65-1754 . }
65-1755 . }
65-1756 .
65-1757 .
65-1758 . if (A eq B)
65-1759 . {
65-1760 . A = B + C;
65-1761 . D = E + F;
65-1762 . }
65-1763 .
65-1764 . A = B*C;
65-1765 . A = B-C;
65-1766 . A = B+C;
65-1767 . A = B/C;
65-1768 . rcv_buffer = (U16 *) alloc(size+1);
65-1769 . A = B/C;
65-1770 . A = B+C;
65-1771 . A = B/C;
65-1772 . A = B/C;
65-1773 . A = B/C;
65-1774 .
65-1775 . if (A == B)
65-1776 . {
65-1777 . A = B + C;
65-1778 . D = E + F;
65-1779 . }
65-1780 .
65-1781 . A = B/C;
65-1782 . // max LOC 34
65-1783 .
65-1784 . }
65-1785 .
65-1786 .
65-1787 . /*
65-1788 . -----------------------------------------------------------------------------
65-1789 . --| NAME: wxp.7.12
65-1790 . --|
65-1791 . --| ABSTRACT:
65-1792 . --| This function does wxp stuff.
65-1793 . --|
65-1794 . --| RETURNS:
65-1795 . --| NONE.
65-1796 . --|
65-1797 . ----------------------------------------------------------------------------
65-1798 . */
65-1799 . static void wxp.7.12(void)
65-1800 . {
65-1801 . A = B*C;
65-1802 . A = B+C;
65-1803 . A = B-C;
65-1804 . A = B/C;
65-1805 . A = B/C;
65-1806 .
65-1807 . if (A < B)
65-1808 . {
65-1809 . A = B + C;
65-1810 . D = E + F;
65-1811 . }
65-1812 .
65-1813 .
65-1814 . if (A lt B)
65-1815 . {
65-1816 . A = B + C;
65-1817 . D = E + F;
65-1818 . }
65-1819 .
65-1820 . A = B*C;
65-1821 . A = (float)B + C;
65-1822 . A = B*C;
65-1823 . A = B+C;
65-1824 . A = B*C;
65-1825 . A = B*C;
65-1826 . A = B+C;
65-1827 . A = B*C;
65-1828 . A = 0x0001;
65-1829 . A = B*C;
65-1830 .
65-1831 . if (A le B)
65-1832 . {
65-1833 . A = B + C;
65-1834 . D = E + F;
65-1835 . }
65-1836 .
65-1837 .
65-1838 . if (A < B)
65-1839 . {
65-1840 . A = B + C;
65-1841 . D = E + F;
65-1842 . }
65-1843 .
65-1844 . A = B*C;
65-1845 . A = B/C;
65-1846 .
65-1847 . if (A le B)
65-1848 . {
65-1849 . A = B + C;
65-1850 . D = E + F;
65-1851 . }
65-1852 .
65-1853 .
65-1854 . if (A < = B)
65-1855 . {
65-1856 . A = B + C;
65-1857 . D = E + F;
65-1858 . }
65-1859 .
65-1860 . A = B-C;
65-1861 . A = B-C;
65-1862 .
65-1863 . if (A le B)
65-1864 . {
65-1865 . A = B + C;
65-1866 . D = E + F;
65-1867 . }
65-1868 .
65-1869 . A = B*C;
65-1870 . A = B+C;
65-1871 . A = B*C;
65-1872 . A = B/C;
65-1873 .
65-1874 . switch (wxp stuff)
65-1875 . {
65-1876 . case one:
65-1877 . {
65-1878 . run_this;
65-1879 . break;
65-1880 . }
65-1881 . case two:
65-1882 . {
65-1883 . run_this;
65-1884 . break;
65-1885 . }
65-1886 . default:
65-1887 . {
65-1888 . SwError;
65-1889 . }
65-1890 . }
65-1891 .
65-1892 . A = B-C;
65-1893 . A = 0x0001;
65-1894 .
65-1895 . if (A < = B)
65-1896 . {
65-1897 . A = B + C;
65-1898 . D = E + F;
65-1899 . }
65-1900 .
65-1901 . A = B/C;
65-1902 .
65-1903 . if (A == B)
65-1904 . {
65-1905 . A = B + C;
65-1906 . D = E + F;
65-1907 . }
65-1908 .
65-1909 . A = B*C;
65-1910 . A = (long)B + C;
65-1911 . A = B*C;
65-1912 . A = B+C;
65-1913 . A = B*C;
65-1914 .
65-1915 . switch (wxp stuff)
65-1916 . {
65-1917 . case one:
65-1918 . {
65-1919 . run_this;
65-1920 . break;
65-1921 . }
65-1922 . case two:
65-1923 . {
65-1924 . run_this;
65-1925 . break;
65-1926 . }
65-1927 . default:
65-1928 . {
65-1929 . SwError;
65-1930 . }
65-1931 . }
65-1932 .
65-1933 . A = B/C;
65-1934 . A = B+C;
65-1935 . A = B+C;
65-1936 . A = B-C;
65-1937 . A = B*C;
65-1938 . A = B/C;
65-1939 . A = B+C;
65-1940 . /* LE SV TOC-3114 this is a wxp-07.12.46 req to enable*/
65-1941 . A = B*C;
65-1942 . A = B+C;
65-1943 . A = B-C;
65-1944 . A = B+C;
65-1945 . /* LE SV TOC-3115 this is a wxp-07.12.50 req to enable*/
65-1946 .
65-1947 . if (A < B)
65-1948 . {
65-1949 . A = B + C;
65-1950 . D = E + F;
65-1951 . }
65-1952 .
65-1953 . A = B-C;
65-1954 .
65-1955 . if (A le B)
65-1956 . {
65-1957 . A = B + C;
65-1958 . D = E + F;
65-1959 . }
65-1960 .
65-1961 . // max LOC 52
65-1962 .
65-1963 . }
65-1964 .
65-1965 .
65-1966 . /*
65-1967 . -----------------------------------------------------------------------------
65-1968 . --| NAME: wxp.7.13
65-1969 . --|
65-1970 . --| ABSTRACT:
65-1971 . --| This function does wxp stuff.
65-1972 . --|
65-1973 . --| RETURNS:
65-1974 . --| NONE.
65-1975 . --|
65-1976 . ----------------------------------------------------------------------------
65-1977 . */
65-1978 . static void wxp.7.13(void)
65-1979 . {
65-1980 .
65-1981 . if (A > = B)
65-1982 . {
65-1983 . A = B + C;
65-1984 . D = E + F;
65-1985 . }
65-1986 .
65-1987 .
65-1988 . if (A gt B)
65-1989 . {
65-1990 . A = B + C;
65-1991 . D = E + F;
65-1992 . }
65-1993 .
65-1994 .
65-1995 . if (A == B)
65-1996 . {
65-1997 . A = B + C;
65-1998 . D = E + F;
65-1999 . }
65-2000 .
65-2001 . /* LE SV TOC-3116 this is a wxp-07.13.4 req to halt*/
65-2002 .
65-2003 . if (A < = B)
65-2004 . {
65-2005 . A = B + C;
65-2006 . D = E + F;
65-2007 . }
65-2008 .
65-2009 . A = B/C;
65-2010 . A = B*C;
65-2011 .
65-2012 . if (A == B)
65-2013 . {
65-2014 . A = B + C;
65-2015 . D = E + F;
65-2016 . }
65-2017 .
65-2018 . A = B/C;
65-2019 .
65-2020 . switch (wxp stuff)
65-2021 . {
65-2022 . case one:
65-2023 . {
65-2024 . run_this;
65-2025 . break;
65-2026 . }
65-2027 . case two:
65-2028 . {
65-2029 . run_this;
65-2030 . break;
65-2031 . }
65-2032 . default:
65-2033 . {
65-2034 . SwError;
65-2035 . }
65-2036 . }
65-2037 .
65-2038 . A = B/C;
65-2039 . A = B/C;
65-2040 . A = B/C;
65-2041 .
65-2042 . if (A < B)
65-2043 . {
65-2044 . A = B + C;
65-2045 . D = E + F;
65-2046 . }
65-2047 .
65-2048 .
65-2049 . switch (wxp stuff)
65-2050 . {
65-2051 . case one:
65-2052 . {
65-2053 . run_this;
65-2054 . // missing break
65-2055 . }
65-2056 . case two:
65-2057 . {
65-2058 . run_this;
65-2059 . break;
65-2060 . }
65-2061 . default:
65-2062 . {
65-2063 . SwError;
65-2064 . }
65-2065 . }
65-2066 .
65-2067 . A = B+C;
65-2068 . A = B*C;
65-2069 . A = B-C;
65-2070 . A = B+C;
65-2071 . /* LE SV TOC-3117 this is a wxp-07.13.18 req to convert*/
65-2072 . A = B-C;
65-2073 .
65-2074 . if (A < = B)
65-2075 . {
65-2076 . A = B + C;
65-2077 . D = E + F;
65-2078 . }
65-2079 .
65-2080 .
65-2081 . if (A != B)
65-2082 . {
65-2083 . A = B + C;
65-2084 . D = E + F;
65-2085 . }
65-2086 .
65-2087 . A = B*C;
65-2088 . A = B/C;
65-2089 . A = B*C;
65-2090 . A = B*C;
65-2091 . A = B-C;
65-2092 . A = B-C;
65-2093 .
65-2094 . if {
65-2095 . X = Y + Z;
65-2096 . }
65-2097 . else {
65-2098 . halt;
65-2099 . }
65-2100 .
65-2101 . A = B*C;
65-2102 . A = B+C;
65-2103 . A = B/C;
65-2104 . A = 0x0007;
65-2105 .
65-2106 . if (A eq B)
65-2107 . {
65-2108 . A = B + C;
65-2109 . D = E + F;
65-2110 . }
65-2111 .
65-2112 . A = B-C;
65-2113 .
65-2114 . if (A eq B)
65-2115 . {
65-2116 . A = B + C;
65-2117 . D = E + F;
65-2118 . }
65-2119 .
65-2120 . A = B+C;
65-2121 . A = B/C;
65-2122 . A = B+C;
65-2123 .
65-2124 . if (A gt B)
65-2125 . {
65-2126 . A = B + C;
65-2127 . D = E + F;
65-2128 . }
65-2129 .
65-2130 .
65-2131 . if (A ne B)
65-2132 . {
65-2133 . A = B + C;
65-2134 . D = E + F;
65-2135 . }
65-2136 .
65-2137 . A = B-C;
65-2138 . A = B+C;
65-2139 .
65-2140 . if (A gt B)
65-2141 . {
65-2142 . A = B + C;
65-2143 . D = E + F;
65-2144 . }
65-2145 .
65-2146 .
65-2147 . if (A le B)
65-2148 . {
65-2149 . A = B + C;
65-2150 . D = E + F;
65-2151 . }
65-2152 .
65-2153 . A = B*C;
65-2154 . A = B+C;
65-2155 . A = B+C;
65-2156 .
65-2157 . if (A == B)
65-2158 . {
65-2159 . A = B + C;
65-2160 . D = E + F;
65-2161 . }
65-2162 .
65-2163 .
65-2164 . if (A eq B)
65-2165 . {
65-2166 . A = B + C;
65-2167 . D = E + F;
65-2168 . }
65-2169 .
65-2170 . A = B-C;
65-2171 .
65-2172 . if (A != B)
65-2173 . {
65-2174 . A = B + C;
65-2175 . D = E + F;
65-2176 . }
65-2177 .
65-2178 . A = B+C;
65-2179 .
65-2180 . if (A < B)
65-2181 . {
65-2182 . A = B + C;
65-2183 . D = E + F;
65-2184 . }
65-2185 .
65-2186 . A = B-C;
65-2187 .
65-2188 . if (A == B)
65-2189 . {
65-2190 . A = B + C;
65-2191 . D = E + F;
65-2192 . }
65-2193 .
65-2194 . A = B*C;
65-2195 . A = B-C;
65-2196 . A = B-C;
65-2197 . A = B/C;
65-2198 . A = B+C;
65-2199 . A = B/C;
65-2200 .
65-2201 . if (A eq B)
65-2202 . {
65-2203 . A = B + C;
65-2204 . D = E + F;
65-2205 . }
65-2206 .
65-2207 . A = B+C;
65-2208 . A = B-C;
65-2209 . A = B*C;
65-2210 .
65-2211 . if (A eq B)
65-2212 . {
65-2213 . A = B + C;
65-2214 . D = E + F;
65-2215 . }
65-2216 .
65-2217 . A = B/C;
65-2218 .
65-2219 . switch (wxp stuff)
65-2220 . {
65-2221 . case one:
65-2222 . {
65-2223 . run_this;
65-2224 . break;
65-2225 . }
65-2226 . case two:
65-2227 . {
65-2228 . run_this;
65-2229 . break;
65-2230 . }
65-2231 . // missing default
65-2232 . }
65-2233 .
65-2234 . A = B*C;
65-2235 .
65-2236 . if (A ge B)
65-2237 . {
65-2238 . A = B + C;
65-2239 . D = E + F;
65-2240 . }
65-2241 .
65-2242 .
65-2243 . if (A < = B)
65-2244 . {
65-2245 . A = B + C;
65-2246 . D = E + F;
65-2247 . }
65-2248 .
65-2249 . A = B+C;
65-2250 .
65-2251 . if (A ne B)
65-2252 . {
65-2253 . A = B + C;
65-2254 . D = E + F;
65-2255 . }
65-2256 .
65-2257 .
65-2258 . if (A < B)
65-2259 . {
65-2260 . A = B + C;
65-2261 . D = E + F;
65-2262 . }
65-2263 .
65-2264 . A = B-C;
65-2265 . A = B-C;
65-2266 .
65-2267 . if (A == B)
65-2268 . {
65-2269 . A = B + C;
65-2270 . D = E + F;
65-2271 . }
65-2272 .
65-2273 . A = B-C;
65-2274 . A = B-C;
65-2275 . A = B/C;
65-2276 . // max LOC 76
65-2277 .
65-2278 . }
65-2279 .
65 65 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-07.c
66 66 Source: source/ft-app/ft-app-B1.1/wxp/wxp-08.c
66-0 . /*
66-1 . ----------------------------------------------------------------------------
66-2 . --| BEGIN PROLOGUE
66-3 . --|
66-4 . --| CLASSIFICATION: UNCLASSIFIED
66-5 . --|
66-6 . --| FILE NAME: wxp-08.c
66-7 . --|
66-8 . --| ABSTRACT:
66-9 . --| This file contains the 12 functions that do file wxp stuff.
66-10 . --|
66-11 . --| HISTORY:
66-12 . --| CCCQ_NAME:
66-13 . --| CCCQ_VER:
66-14 . --|
66-15 . --| END PROLOGUE
66-16 . ----------------------------------------------------------------------------
66-17 . */
66-18 .
66-19 . #define D;
66-20 . #define A;
66-21 . float B;
66-22 . double C;
66-23 . float B;
66-24 . #include C;
66-25 . #include B;
66-26 .
66-27 .
66-28 .
66-29 . /*
66-30 . -----------------------------------------------------------------------------
66-31 . --| NAME: wxp.8.1
66-32 . --|
66-33 . --| ABSTRACT:
66-34 . --| This function does wxp stuff.
66-35 . --|
66-36 . --| RETURNS:
66-37 . --| NONE.
66-38 . --|
66-39 . ----------------------------------------------------------------------------
66-40 . */
66-41 . static void wxp.8.1(void)
66-42 . {
66-43 . A = B/C;
66-44 . A = B-C;
66-45 . A = B-C;
66-46 .
66-47 . if (A gt B)
66-48 . {
66-49 . A = B + C;
66-50 . D = E + F;
66-51 . }
66-52 .
66-53 . A = B+C;
66-54 . A = B/C;
66-55 . A = B/C;
66-56 . A = B-C;
66-57 . A = B-C;
66-58 . // max LOC 9
66-59 .
66-60 . }
66-61 .
66-62 .
66-63 . /*
66-64 . -----------------------------------------------------------------------------
66-65 . --| NAME: wxp.8.2
66-66 . --|
66-67 . --| ABSTRACT:
66-68 . --| This function does wxp stuff.
66-69 . --|
66-70 . --| RETURNS:
66-71 . --| NONE.
66-72 . --|
66-73 . ----------------------------------------------------------------------------
66-74 . */
66-75 . static void wxp.8.2(void)
66-76 . {
66-77 . A = B/C;
66-78 . A = B+C;
66-79 .
66-80 . if (A < B)
66-81 . {
66-82 . A = B + C;
66-83 . D = E + F;
66-84 . }
66-85 .
66-86 . A = B*C;
66-87 .
66-88 . switch (wxp stuff)
66-89 . {
66-90 . case one:
66-91 . {
66-92 . run_this;
66-93 . break;
66-94 . }
66-95 . case two:
66-96 . {
66-97 . run_this;
66-98 . break;
66-99 . }
66-100 . default:
66-101 . {
66-102 . SwError;
66-103 . }
66-104 . }
66-105 .
66-106 .
66-107 . if (A > B)
66-108 . {
66-109 . A = B + C;
66-110 . D = E + F;
66-111 . }
66-112 .
66-113 . A = B/C;
66-114 . A = B*C;
66-115 . A = B/C;
66-116 . /* LE SV TOC-3118 this is a wxp-08.2.10 req to call admin*/
66-117 . A = B+C;
66-118 . A = B-C;
66-119 . A = B+C;
66-120 . A = B+C;
66-121 . A = B-C;
66-122 .
66-123 . if (A le B)
66-124 . {
66-125 . A = B + C;
66-126 . D = E + F;
66-127 . }
66-128 .
66-129 .
66-130 . if (A > B)
66-131 . {
66-132 . A = B + C;
66-133 . D = E + F;
66-134 . }
66-135 .
66-136 .
66-137 . if (A < B)
66-138 . {
66-139 . A = B + C;
66-140 . D = E + F;
66-141 . }
66-142 .
66-143 . /* LE SV TOC-3119 this is a wxp-08.2.18 req to check unix*/
66-144 . A = B+C;
66-145 .
66-146 . switch (wxp stuff)
66-147 . {
66-148 . case one:
66-149 . {
66-150 . run_this;
66-151 . break;
66-152 . }
66-153 . case two:
66-154 . {
66-155 . run_this;
66-156 . break;
66-157 . }
66-158 . default:
66-159 . {
66-160 . SwError;
66-161 . }
66-162 . }
66-163 .
66-164 .
66-165 . if (A == B)
66-166 . {
66-167 . A = B + C;
66-168 . D = E + F;
66-169 . }
66-170 .
66-171 . A = B*C;
66-172 . A = B*C;
66-173 . A = B/C;
66-174 . A = B+C;
66-175 . A = B/C;
66-176 . A = B*C;
66-177 . A = B/C;
66-178 .
66-179 . if (A != B)
66-180 . {
66-181 . A = B + C;
66-182 . D = E + F;
66-183 . }
66-184 .
66-185 . A = B/C;
66-186 . A = B-C;
66-187 . A = B/C;
66-188 . A = B+C;
66-189 .
66-190 . if (A le B)
66-191 . {
66-192 . A = B + C;
66-193 . D = E + F;
66-194 . }
66-195 .
66-196 .
66-197 . if (A != B)
66-198 . {
66-199 . A = B + C;
66-200 . D = E + F;
66-201 . }
66-202 .
66-203 .
66-204 . if (A > = B)
66-205 . {
66-206 . A = B + C;
66-207 . D = E + F;
66-208 . }
66-209 .
66-210 .
66-211 . if (A ge B)
66-212 . {
66-213 . A = B + C;
66-214 . D = E + F;
66-215 . }
66-216 .
66-217 .
66-218 . if (A ge B)
66-219 . {
66-220 . A = B + C;
66-221 . D = E + F;
66-222 . }
66-223 .
66-224 .
66-225 . if (A < = B)
66-226 . {
66-227 . A = B + C;
66-228 . D = E + F;
66-229 . }
66-230 .
66-231 .
66-232 . if (A < B)
66-233 . {
66-234 . A = B + C;
66-235 . D = E + F;
66-236 . }
66-237 .
66-238 . A = B-C;
66-239 . A = B-C;
66-240 . A = B-C;
66-241 . A = B/C;
66-242 . A = B-C;
66-243 . A = B+C;
66-244 . A = B-C;
66-245 . A = B/C;
66-246 . A = B-C;
66-247 . A = B+C;
66-248 . A = B+C;
66-249 . /* LE SV TOC-3120 this is a wxp-08.2.51 req to call admin*/
66-250 . A = B-C;
66-251 . A = B/C;
66-252 .
66-253 . if (A gt B)
66-254 . {
66-255 . A = B + C;
66-256 . D = E + F;
66-257 . }
66-258 .
66-259 .
66-260 . if (A gt B)
66-261 . {
66-262 . A = B + C;
66-263 . D = E + F;
66-264 . }
66-265 .
66-266 . A = B*C;
66-267 . A = B*C;
66-268 . // max LOC 56
66-269 .
66-270 . }
66-271 .
66-272 .
66-273 . /*
66-274 . -----------------------------------------------------------------------------
66-275 . --| NAME: wxp.8.3
66-276 . --|
66-277 . --| ABSTRACT:
66-278 . --| This function does wxp stuff.
66-279 . --|
66-280 . --| RETURNS:
66-281 . --| NONE.
66-282 . --|
66-283 . ----------------------------------------------------------------------------
66-284 . */
66-285 . static void wxp.8.3(void)
66-286 . {
66-287 . A = B-C;
66-288 . A = 0x0007;
66-289 . A = B-C;
66-290 . A = B*C;
66-291 .
66-292 . if (A eq B)
66-293 . {
66-294 . A = B + C;
66-295 . D = E + F;
66-296 . }
66-297 .
66-298 . A = B+C;
66-299 . goto error;
66-300 . A = B-C;
66-301 . A = B/C;
66-302 .
66-303 . if (A < B)
66-304 . {
66-305 . A = B + C;
66-306 . D = E + F;
66-307 . }
66-308 .
66-309 . A = B*C;
66-310 . A = B-C;
66-311 . A = B-C;
66-312 . A = B-C;
66-313 . A = B+C;
66-314 .
66-315 . if (A ge B)
66-316 . {
66-317 . A = B + C;
66-318 . D = E + F;
66-319 . }
66-320 .
66-321 . A = B*C;
66-322 . A = B/C;
66-323 . A = B*C;
66-324 . A = B+C;
66-325 .
66-326 . if (A lt B)
66-327 . {
66-328 . A = B + C;
66-329 . D = E + F;
66-330 . }
66-331 .
66-332 . A = B*C;
66-333 .
66-334 . if (A != B)
66-335 . {
66-336 . A = B + C;
66-337 . D = E + F;
66-338 . }
66-339 .
66-340 . A = B*C;
66-341 . A = B/C;
66-342 . /* LE SV TOC-3121 this is a wxp-08.3.24 req to enable*/
66-343 . A = B*C;
66-344 . A = B/C;
66-345 .
66-346 . if (A ne B)
66-347 . {
66-348 . A = B + C;
66-349 . D = E + F;
66-350 . }
66-351 .
66-352 . A = B/C;
66-353 . A = B+C;
66-354 .
66-355 . if (A gt B)
66-356 . {
66-357 . A = B + C;
66-358 . D = E + F;
66-359 . }
66-360 .
66-361 . A = 0x0001;
66-362 .
66-363 . if (A ge B)
66-364 . {
66-365 . A = B + C;
66-366 . D = E + F;
66-367 . }
66-368 .
66-369 .
66-370 . if (A lt B)
66-371 . {
66-372 . A = B + C;
66-373 . D = E + F;
66-374 . }
66-375 .
66-376 .
66-377 . if (A ge B)
66-378 . {
66-379 . A = B + C;
66-380 . D = E + F;
66-381 . }
66-382 .
66-383 . A = 0x0009;
66-384 . A = B-C;
66-385 . A = B*C;
66-386 .
66-387 . if (A < B)
66-388 . {
66-389 . A = B + C;
66-390 . D = E + F;
66-391 . }
66-392 .
66-393 . A = B+C;
66-394 . A = B+C;
66-395 . A = B/C;
66-396 . A = B*C;
66-397 .
66-398 . if (A ge B)
66-399 . {
66-400 . A = B + C;
66-401 . D = E + F;
66-402 . }
66-403 .
66-404 .
66-405 . switch (wxp stuff)
66-406 . {
66-407 . case one:
66-408 . {
66-409 . run_this;
66-410 . // missing break
66-411 . }
66-412 . case two:
66-413 . {
66-414 . run_this;
66-415 . break;
66-416 . }
66-417 . default:
66-418 . {
66-419 . SwError;
66-420 . }
66-421 . }
66-422 .
66-423 . A = B+C;
66-424 . A = B-C;
66-425 . A = B*C;
66-426 .
66-427 . if (A != B)
66-428 . {
66-429 . A = B + C;
66-430 . D = E + F;
66-431 . }
66-432 .
66-433 . A = B*C;
66-434 .
66-435 . if (A > = B)
66-436 . {
66-437 . A = B + C;
66-438 . D = E + F;
66-439 . }
66-440 .
66-441 . /* LE SV TOC-3122 this is a wxp-08.3.47 req to update*/
66-442 .
66-443 . if (A < = B)
66-444 . {
66-445 . A = B + C;
66-446 . D = E + F;
66-447 . }
66-448 .
66-449 . A = (float)B + C;
66-450 . A = B-C;
66-451 . A = B*C;
66-452 .
66-453 . if (A > = B)
66-454 . {
66-455 . A = B + C;
66-456 . D = E + F;
66-457 . }
66-458 .
66-459 . A = B+C;
66-460 . A = B-C;
66-461 . A = B*C;
66-462 .
66-463 . if (A lt B)
66-464 . {
66-465 . A = B + C;
66-466 . D = E + F;
66-467 . }
66-468 .
66-469 . A = B-C;
66-470 . A = 0x0004;
66-471 . A = B/C;
66-472 .
66-473 . if (A != B)
66-474 . {
66-475 . A = B + C;
66-476 . D = E + F;
66-477 . }
66-478 .
66-479 . A = B-C;
66-480 .
66-481 . if (A ne B)
66-482 . {
66-483 . A = B + C;
66-484 . D = E + F;
66-485 . }
66-486 .
66-487 . A = B*C;
66-488 . A = B-C;
66-489 . /* LE SV TOC-3123 this is a wxp-08.3.62 req to call isr*/
66-490 .
66-491 . if (A > B)
66-492 . {
66-493 . A = B + C;
66-494 . D = E + F;
66-495 . }
66-496 .
66-497 . A = B/C;
66-498 . A = B+C;
66-499 . A = B+C;
66-500 . A = B+C;
66-501 .
66-502 . if (A > B)
66-503 . {
66-504 . A = B + C;
66-505 . D = E + F;
66-506 . }
66-507 .
66-508 . A = B/C;
66-509 .
66-510 . switch (wxp stuff)
66-511 . {
66-512 . case one:
66-513 . {
66-514 . run_this;
66-515 . break;
66-516 . }
66-517 . case two:
66-518 . {
66-519 . run_this;
66-520 . break;
66-521 . }
66-522 . default:
66-523 . {
66-524 . SwError;
66-525 . }
66-526 . }
66-527 .
66-528 .
66-529 . if (A lt B)
66-530 . {
66-531 . A = B + C;
66-532 . D = E + F;
66-533 . }
66-534 .
66-535 .
66-536 . if (A gt B)
66-537 . {
66-538 . A = B + C;
66-539 . D = E + F;
66-540 . }
66-541 .
66-542 .
66-543 . if (A le B)
66-544 . {
66-545 . A = B + C;
66-546 . D = E + F;
66-547 . }
66-548 .
66-549 .
66-550 . if (A == B)
66-551 . {
66-552 . A = B + C;
66-553 . D = E + F;
66-554 . }
66-555 .
66-556 . A = B*C;
66-557 . A = B*C;
66-558 .
66-559 . if (A > = B)
66-560 . {
66-561 . A = B + C;
66-562 . D = E + F;
66-563 . }
66-564 .
66-565 .
66-566 . if (A lt B)
66-567 . {
66-568 . A = B + C;
66-569 . D = E + F;
66-570 . }
66-571 .
66-572 . A = B/C;
66-573 . A = B*C;
66-574 . A = B/C;
66-575 .
66-576 . if (A == B)
66-577 . {
66-578 . A = B + C;
66-579 . D = E + F;
66-580 . }
66-581 .
66-582 .
66-583 . if (veg)
66-584 . // missing curly brace
66-585 . variable = orange;
66-586 .
66-587 .
66-588 . if (A < = B)
66-589 . {
66-590 . A = B + C;
66-591 . D = E + F;
66-592 . }
66-593 .
66-594 . A = B-C;
66-595 . A = B+C;
66-596 . A = B*C;
66-597 . A = B*C;
66-598 . // max LOC 86
66-599 .
66-600 . }
66-601 .
66-602 .
66-603 . /*
66-604 . -----------------------------------------------------------------------------
66-605 . --| NAME: wxp.8.4
66-606 . --|
66-607 . --| ABSTRACT:
66-608 . --| This function does wxp stuff.
66-609 . --|
66-610 . --| RETURNS:
66-611 . --| NONE.
66-612 . --|
66-613 . ----------------------------------------------------------------------------
66-614 . */
66-615 . static void wxp.8.4(void)
66-616 . {
66-617 . A = B+C;
66-618 . A = B*C;
66-619 . A = B/C;
66-620 . A = B+C;
66-621 . A = B/C;
66-622 . A = B*C;
66-623 . A = B-C;
66-624 . A = B-C;
66-625 . A = B-C;
66-626 . A = B/C;
66-627 .
66-628 . if (A < = B)
66-629 . {
66-630 . A = B + C;
66-631 . D = E + F;
66-632 . }
66-633 .
66-634 . A = B+C;
66-635 . /* LE SV TOC-3124 this is a wxp-08.4.13 req to process*/
66-636 .
66-637 . if (A le B)
66-638 . {
66-639 . A = B + C;
66-640 . D = E + F;
66-641 . }
66-642 .
66-643 . A = B+C;
66-644 . A = B*C;
66-645 . /* LE SV TOC-3125 this is a wxp-08.4.16 req to verify*/
66-646 .
66-647 . if (A == B)
66-648 . {
66-649 . A = B + C;
66-650 . D = E + F;
66-651 . }
66-652 .
66-653 . A = B*C;
66-654 .
66-655 . if (A > = B)
66-656 . {
66-657 . A = B + C;
66-658 . D = E + F;
66-659 . }
66-660 .
66-661 . A = B/C;
66-662 . A = B-C;
66-663 . A = B+C;
66-664 . A = B-C;
66-665 .
66-666 . if (A ge B)
66-667 . {
66-668 . A = B + C;
66-669 . D = E + F;
66-670 . }
66-671 .
66-672 .
66-673 . switch (wxp stuff)
66-674 . {
66-675 . case one:
66-676 . {
66-677 . run_this;
66-678 . break;
66-679 . }
66-680 . case two:
66-681 . {
66-682 . run_this;
66-683 . break;
66-684 . }
66-685 . default:
66-686 . {
66-687 . SwError;
66-688 . }
66-689 . }
66-690 .
66-691 .
66-692 . if (A > B)
66-693 . {
66-694 . A = B + C;
66-695 . D = E + F;
66-696 . }
66-697 .
66-698 . A = B+C;
66-699 .
66-700 . if (A le B)
66-701 . {
66-702 . A = B + C;
66-703 . D = E + F;
66-704 . }
66-705 .
66-706 .
66-707 . if (A ne B)
66-708 . {
66-709 . A = B + C;
66-710 . D = E + F;
66-711 . }
66-712 .
66-713 .
66-714 . /* dead_block = C * D;
66-715 . dead_block = E * F; */
66-716 .
66-717 .
66-718 . if (A != B)
66-719 . {
66-720 . A = B + C;
66-721 . D = E + F;
66-722 . }
66-723 .
66-724 . A = B+C;
66-725 .
66-726 . if (A le B)
66-727 . {
66-728 . A = B + C;
66-729 . D = E + F;
66-730 . }
66-731 .
66-732 . A = B*C;
66-733 .
66-734 . if (A gt B)
66-735 . {
66-736 . A = B + C;
66-737 . D = E + F;
66-738 . }
66-739 .
66-740 . A = B/C;
66-741 . A = B-C;
66-742 . A = B-C;
66-743 .
66-744 . if (A > = B)
66-745 . {
66-746 . A = B + C;
66-747 . D = E + F;
66-748 . }
66-749 .
66-750 . A = B/C;
66-751 . A = 0x0003;
66-752 .
66-753 . if (A > = B)
66-754 . {
66-755 . A = B + C;
66-756 . D = E + F;
66-757 . }
66-758 .
66-759 . /* LE SV TOC-3126 this is a wxp-08.4.40 req to assign*/
66-760 . A = B-C;
66-761 . A = B-C;
66-762 .
66-763 . if (A gt B)
66-764 . {
66-765 . A = B + C;
66-766 . D = E + F;
66-767 . }
66-768 .
66-769 . A = B+C;
66-770 . A = B-C;
66-771 . A = B/C;
66-772 .
66-773 . switch (wxp stuff)
66-774 . {
66-775 . case one:
66-776 . {
66-777 . run_this;
66-778 . break;
66-779 . }
66-780 . case two:
66-781 . {
66-782 . run_this;
66-783 . break;
66-784 . }
66-785 . default:
66-786 . {
66-787 . SwError;
66-788 . }
66-789 . }
66-790 .
66-791 . A = B-C;
66-792 . A = B*C;
66-793 . A = B-C;
66-794 .
66-795 . #ifdef LAZY
66-796 . // this is not nice
66-797 . A = B + C;
66-798 . A = B + C;
66-799 . #endif
66-800 .
66-801 . A = B*C;
66-802 .
66-803 . if (A ge B)
66-804 . {
66-805 . A = B + C;
66-806 . D = E + F;
66-807 . }
66-808 .
66-809 . A = B+C;
66-810 .
66-811 . if (A < B)
66-812 . {
66-813 . A = B + C;
66-814 . D = E + F;
66-815 . }
66-816 .
66-817 . A = B*C;
66-818 .
66-819 . if (A != B)
66-820 . {
66-821 . A = B + C;
66-822 . D = E + F;
66-823 . }
66-824 .
66-825 . A = B*C;
66-826 . A = 0x0004;
66-827 .
66-828 . if (A ge B)
66-829 . {
66-830 . A = B + C;
66-831 . D = E + F;
66-832 . }
66-833 .
66-834 .
66-835 . if (A < B)
66-836 . {
66-837 . A = B + C;
66-838 . D = E + F;
66-839 . }
66-840 .
66-841 .
66-842 . /* dead_code = B + C;
66-843 . dead_code = D + E;
66-844 . dead_code = F + G; */
66-845 .
66-846 . A = B/C;
66-847 . A = B*C;
66-848 . A = B-C;
66-849 . A = B-C;
66-850 . A = B+C;
66-851 . A = B*C;
66-852 . A = B+C;
66-853 . A = B+C;
66-854 . A = B-C;
66-855 . A = B+C;
66-856 . A = B/C;
66-857 . A = B*C;
66-858 . A = B*C;
66-859 .
66-860 . if (A < B)
66-861 . {
66-862 . A = B + C;
66-863 . D = E + F;
66-864 . }
66-865 .
66-866 . A = B/C;
66-867 .
66-868 . if (A eq B)
66-869 . {
66-870 . A = B + C;
66-871 . D = E + F;
66-872 . }
66-873 .
66-874 . A = B+C;
66-875 . A = B*C;
66-876 . A = B/C;
66-877 . A = B*C;
66-878 .
66-879 . if (A < = B)
66-880 . {
66-881 . A = B + C;
66-882 . D = E + F;
66-883 . }
66-884 .
66-885 . /* LE SV TOC-3127 this is a wxp-08.4.80 req to record*/
66-886 . A = B*C;
66-887 . A = B+C;
66-888 . A = B-C;
66-889 . A = B+C;
66-890 .
66-891 . if (A < B)
66-892 . {
66-893 . A = B + C;
66-894 . D = E + F;
66-895 . }
66-896 .
66-897 . A = B+C;
66-898 .
66-899 . if (A ge B)
66-900 . {
66-901 . A = B + C;
66-902 . D = E + F;
66-903 . }
66-904 .
66-905 . // max LOC 86
66-906 .
66-907 . }
66-908 .
66-909 .
66-910 . /*
66-911 . -----------------------------------------------------------------------------
66-912 . --| NAME: wxp.8.5
66-913 . --|
66-914 . --| ABSTRACT:
66-915 . --| This function does wxp stuff.
66-916 . --|
66-917 . --| RETURNS:
66-918 . --| NONE.
66-919 . --|
66-920 . ----------------------------------------------------------------------------
66-921 . */
66-922 . static void wxp.8.5(void)
66-923 . {
66-924 . A = B+C;
66-925 .
66-926 . if (A ge B)
66-927 . {
66-928 . A = B + C;
66-929 . D = E + F;
66-930 . }
66-931 .
66-932 . A = 0x0007;
66-933 .
66-934 . if (A eq B)
66-935 . {
66-936 . A = B + C;
66-937 . D = E + F;
66-938 . }
66-939 .
66-940 .
66-941 . switch (wxp stuff)
66-942 . {
66-943 . case one:
66-944 . {
66-945 . run_this;
66-946 . break;
66-947 . }
66-948 . case two:
66-949 . {
66-950 . run_this;
66-951 . break;
66-952 . }
66-953 . default:
66-954 . {
66-955 . SwError;
66-956 . }
66-957 . }
66-958 .
66-959 .
66-960 . if (A lt B)
66-961 . {
66-962 . A = B + C;
66-963 . D = E + F;
66-964 . }
66-965 .
66-966 .
66-967 . if (A != B)
66-968 . {
66-969 . A = B + C;
66-970 . D = E + F;
66-971 . }
66-972 .
66-973 .
66-974 . if (A ne B)
66-975 . {
66-976 . A = B + C;
66-977 . D = E + F;
66-978 . }
66-979 .
66-980 .
66-981 . if (A > B)
66-982 . {
66-983 . A = B + C;
66-984 . D = E + F;
66-985 . }
66-986 .
66-987 . A = B+C;
66-988 . /* LE SV TOC-3128 this is a wxp-08.5.10 req to enable*/
66-989 .
66-990 . if (A ge B)
66-991 . {
66-992 . A = B + C;
66-993 . D = E + F;
66-994 . }
66-995 .
66-996 .
66-997 . if (A > = B)
66-998 . {
66-999 . A = B + C;
66-1000 . D = E + F;
66-1001 . }
66-1002 .
66-1003 . /* LE SV TOC-3129 this is a wxp-08.5.12 req to set RTC*/
66-1004 . A = B+C;
66-1005 .
66-1006 . if (A < = B)
66-1007 . {
66-1008 . A = B + C;
66-1009 . D = E + F;
66-1010 . }
66-1011 .
66-1012 . A = (long)B + C;
66-1013 . A = B-C;
66-1014 . // max LOC 14
66-1015 .
66-1016 . }
66-1017 .
66-1018 .
66-1019 . /*
66-1020 . -----------------------------------------------------------------------------
66-1021 . --| NAME: wxp.8.6
66-1022 . --|
66-1023 . --| ABSTRACT:
66-1024 . --| This function does wxp stuff.
66-1025 . --|
66-1026 . --| RETURNS:
66-1027 . --| NONE.
66-1028 . --|
66-1029 . ----------------------------------------------------------------------------
66-1030 . */
66-1031 . static void wxp.8.6(void)
66-1032 . {
66-1033 .
66-1034 . if (A > B)
66-1035 . {
66-1036 . A = B + C;
66-1037 . D = E + F;
66-1038 . }
66-1039 .
66-1040 . A = B+C;
66-1041 . A = B-C;
66-1042 . A = B/C;
66-1043 . A = B/C;
66-1044 . A = B/C;
66-1045 . A = B*C;
66-1046 . A = B+C;
66-1047 . A = B*C;
66-1048 . A = B+C;
66-1049 . A = B+C;
66-1050 .
66-1051 . if (A ge B)
66-1052 . {
66-1053 . A = B + C;
66-1054 . D = E + F;
66-1055 . }
66-1056 .
66-1057 .
66-1058 . if (A > B)
66-1059 . {
66-1060 . A = B + C;
66-1061 . D = E + F;
66-1062 . }
66-1063 .
66-1064 . A = B-C;
66-1065 . A = B-C;
66-1066 . A = B/C;
66-1067 .
66-1068 . switch (wxp stuff)
66-1069 . {
66-1070 . case one:
66-1071 . {
66-1072 . run_this;
66-1073 . break;
66-1074 . }
66-1075 . case two:
66-1076 . {
66-1077 . run_this;
66-1078 . break;
66-1079 . }
66-1080 . default:
66-1081 . {
66-1082 . SwError;
66-1083 . }
66-1084 . }
66-1085 .
66-1086 . A = B/C;
66-1087 .
66-1088 . if (A > = B)
66-1089 . {
66-1090 . A = B + C;
66-1091 . D = E + F;
66-1092 . }
66-1093 .
66-1094 . A = B+C;
66-1095 .
66-1096 . switch (wxp stuff)
66-1097 . {
66-1098 . case one:
66-1099 . {
66-1100 . run_this;
66-1101 . break;
66-1102 . }
66-1103 . case two:
66-1104 . {
66-1105 . run_this;
66-1106 . break;
66-1107 . }
66-1108 . default:
66-1109 . {
66-1110 . SwError;
66-1111 . }
66-1112 . }
66-1113 .
66-1114 .
66-1115 . if (A > B)
66-1116 . {
66-1117 . A = B + C;
66-1118 . D = E + F;
66-1119 . }
66-1120 .
66-1121 . A = B*C;
66-1122 .
66-1123 . if (A != B)
66-1124 . {
66-1125 . A = B + C;
66-1126 . D = E + F;
66-1127 . }
66-1128 .
66-1129 . A = B+C;
66-1130 . A = B+C;
66-1131 . A = B+C;
66-1132 .
66-1133 . if (A ge B)
66-1134 . {
66-1135 . A = B + C;
66-1136 . D = E + F;
66-1137 . }
66-1138 .
66-1139 .
66-1140 . if (A < B)
66-1141 . {
66-1142 . A = B + C;
66-1143 . D = E + F;
66-1144 . }
66-1145 .
66-1146 . A = B*C;
66-1147 .
66-1148 . if (A != B)
66-1149 . {
66-1150 . A = B + C;
66-1151 . D = E + F;
66-1152 . }
66-1153 .
66-1154 . A = B-C;
66-1155 . A = B+C;
66-1156 . A = B/C;
66-1157 . A = B*C;
66-1158 .
66-1159 . if (A < B)
66-1160 . {
66-1161 . A = B + C;
66-1162 . D = E + F;
66-1163 . }
66-1164 .
66-1165 . A = B*C;
66-1166 .
66-1167 . if (A ge B)
66-1168 . {
66-1169 . A = B + C;
66-1170 . D = E + F;
66-1171 . }
66-1172 .
66-1173 . A = B-C;
66-1174 . A = B-C;
66-1175 . A = B-C;
66-1176 . A = B+C;
66-1177 . A = B/C;
66-1178 .
66-1179 . if (A > B)
66-1180 . {
66-1181 . A = B + C;
66-1182 . D = E + F;
66-1183 . }
66-1184 .
66-1185 . A = B+C;
66-1186 . A = B*C;
66-1187 .
66-1188 . if (A eq B)
66-1189 . {
66-1190 . A = B + C;
66-1191 . D = E + F;
66-1192 . }
66-1193 .
66-1194 . A = B-C;
66-1195 . A = B*C;
66-1196 . A = B+C;
66-1197 . A = B/C;
66-1198 . A = B-C;
66-1199 .
66-1200 . if (A < = B)
66-1201 . {
66-1202 . A = B + C;
66-1203 . D = E + F;
66-1204 . }
66-1205 .
66-1206 . A = B*C;
66-1207 .
66-1208 . if (A lt B)
66-1209 . {
66-1210 . A = B + C;
66-1211 . D = E + F;
66-1212 . }
66-1213 .
66-1214 . A = B-C;
66-1215 . A = B/C;
66-1216 . A = B+C;
66-1217 . A = B/C;
66-1218 . A = B*C;
66-1219 .
66-1220 . if (A < B)
66-1221 . {
66-1222 . A = B + C;
66-1223 . D = E + F;
66-1224 . }
66-1225 .
66-1226 . /* LE SV TOC-3130 this is a wxp-08.6.62 req to set RTC*/
66-1227 . A = B/C;
66-1228 . A = B*C;
66-1229 . /* LE SV TOC-3131 this is a wxp-08.6.64 req to enable*/
66-1230 .
66-1231 . if (A > = B)
66-1232 . {
66-1233 . A = B + C;
66-1234 . D = E + F;
66-1235 . }
66-1236 .
66-1237 . A = B+C;
66-1238 .
66-1239 . if (A < = B)
66-1240 . {
66-1241 . A = B + C;
66-1242 . D = E + F;
66-1243 . }
66-1244 .
66-1245 . A = B/C;
66-1246 . A = B*C;
66-1247 . A = B+C;
66-1248 . A = B-C;
66-1249 . A = B-C;
66-1250 . // max LOC 71
66-1251 .
66-1252 . }
66-1253 .
66-1254 .
66-1255 . /*
66-1256 . -----------------------------------------------------------------------------
66-1257 . --| NAME: wxp.8.7
66-1258 . --|
66-1259 . --| ABSTRACT:
66-1260 . --| This function does wxp stuff.
66-1261 . --|
66-1262 . --| RETURNS:
66-1263 . --| NONE.
66-1264 . --|
66-1265 . ----------------------------------------------------------------------------
66-1266 . */
66-1267 . static void wxp.8.7(void)
66-1268 . {
66-1269 .
66-1270 . if (A ne B)
66-1271 . {
66-1272 . A = B + C;
66-1273 . D = E + F;
66-1274 . }
66-1275 .
66-1276 . A = B*C;
66-1277 .
66-1278 . if (A ge B)
66-1279 . {
66-1280 . A = B + C;
66-1281 . D = E + F;
66-1282 . }
66-1283 .
66-1284 . A = B*C;
66-1285 . A = B*C;
66-1286 . A = B-C;
66-1287 . A = B/C;
66-1288 .
66-1289 . if (A ge B)
66-1290 . {
66-1291 . A = B + C;
66-1292 . D = E + F;
66-1293 . }
66-1294 .
66-1295 . A = B+C;
66-1296 . A = B-C;
66-1297 . A = B+C;
66-1298 . A = 0x0009;
66-1299 .
66-1300 . if ($wxp stuff > $otherwxp stuff)
66-1301 . /* LE SV TOC-008 we really should log all error calls */
66-1302 . {
66-1303 . A = B + C;
66-1304 . }
66-1305 .
66-1306 .
66-1307 . if (A eq B)
66-1308 . {
66-1309 . A = B + C;
66-1310 . D = E + F;
66-1311 . }
66-1312 .
66-1313 . A = B/C;
66-1314 . A = B+C;
66-1315 . A = B-C;
66-1316 . A = B/C;
66-1317 . A = B-C;
66-1318 . A = B*C;
66-1319 .
66-1320 . switch (wxp stuff)
66-1321 . {
66-1322 . case one:
66-1323 . {
66-1324 . run_this;
66-1325 . break;
66-1326 . }
66-1327 . case two:
66-1328 . {
66-1329 . run_this;
66-1330 . break;
66-1331 . }
66-1332 . default:
66-1333 . {
66-1334 . SwError;
66-1335 . }
66-1336 . }
66-1337 .
66-1338 . A = B+C;
66-1339 . A = B*C;
66-1340 . A = B-C;
66-1341 . A = B/C;
66-1342 . A = B-C;
66-1343 . A = B*C;
66-1344 . A = B/C;
66-1345 . A = B/C;
66-1346 . A = B-C;
66-1347 .
66-1348 . switch (wxp stuff)
66-1349 . {
66-1350 . case one:
66-1351 . {
66-1352 . run_this;
66-1353 . break;
66-1354 . }
66-1355 . case two:
66-1356 . {
66-1357 . run_this;
66-1358 . break;
66-1359 . }
66-1360 . // missing default
66-1361 . }
66-1362 .
66-1363 . A = B-C;
66-1364 . A = B/C;
66-1365 . A = B/C;
66-1366 . A = 0x0002;
66-1367 .
66-1368 . if (A le B)
66-1369 . {
66-1370 . A = B + C;
66-1371 . D = E + F;
66-1372 . }
66-1373 .
66-1374 . A = B/C;
66-1375 . A = B+C;
66-1376 .
66-1377 . /* dead_code = B + C;
66-1378 . dead_code = D + E;
66-1379 . dead_code = F + G; */
66-1380 .
66-1381 . A = B+C;
66-1382 .
66-1383 . if (A gt B)
66-1384 . {
66-1385 . A = B + C;
66-1386 . D = E + F;
66-1387 . }
66-1388 .
66-1389 .
66-1390 . if (A > = B)
66-1391 . {
66-1392 . A = B + C;
66-1393 . D = E + F;
66-1394 . }
66-1395 .
66-1396 . A = B+C;
66-1397 .
66-1398 . if (A gt B)
66-1399 . {
66-1400 . A = B + C;
66-1401 . D = E + F;
66-1402 . }
66-1403 .
66-1404 . A = B-C;
66-1405 .
66-1406 . if (A gt B)
66-1407 . {
66-1408 . A = B + C;
66-1409 . D = E + F;
66-1410 . }
66-1411 .
66-1412 .
66-1413 . if (A ne B)
66-1414 . {
66-1415 . A = B + C;
66-1416 . D = E + F;
66-1417 . }
66-1418 .
66-1419 . A = B*C;
66-1420 . A = B*C;
66-1421 .
66-1422 . if (A < B)
66-1423 . {
66-1424 . A = B + C;
66-1425 . D = E + F;
66-1426 . }
66-1427 .
66-1428 .
66-1429 . if (A eq B)
66-1430 . {
66-1431 . A = B + C;
66-1432 . D = E + F;
66-1433 . }
66-1434 .
66-1435 .
66-1436 . if (A ge B)
66-1437 . {
66-1438 . A = B + C;
66-1439 . D = E + F;
66-1440 . }
66-1441 .
66-1442 .
66-1443 . if (A > B)
66-1444 . {
66-1445 . A = B + C;
66-1446 . D = E + F;
66-1447 . }
66-1448 .
66-1449 . A = B+C;
66-1450 . // TBD - what do I do now
66-1451 . A = B-C;
66-1452 . A = B-C;
66-1453 . A = B*C;
66-1454 . A = B*C;
66-1455 . A = B-C;
66-1456 . A = B*C;
66-1457 .
66-1458 . if (A ne B)
66-1459 . {
66-1460 . A = B + C;
66-1461 . D = E + F;
66-1462 . }
66-1463 .
66-1464 .
66-1465 . if (A < = B)
66-1466 . {
66-1467 . A = B + C;
66-1468 . D = E + F;
66-1469 . }
66-1470 .
66-1471 .
66-1472 . if (A eq B)
66-1473 . {
66-1474 . A = B + C;
66-1475 . D = E + F;
66-1476 . }
66-1477 .
66-1478 .
66-1479 . if (A == B)
66-1480 . {
66-1481 . A = B + C;
66-1482 . D = E + F;
66-1483 . }
66-1484 .
66-1485 . A = B+C;
66-1486 . A = B+C;
66-1487 . A = B*C;
66-1488 .
66-1489 . if (A < = B)
66-1490 . {
66-1491 . A = B + C;
66-1492 . D = E + F;
66-1493 . }
66-1494 .
66-1495 . A = B/C;
66-1496 .
66-1497 . if (A eq B)
66-1498 . {
66-1499 . A = B + C;
66-1500 . D = E + F;
66-1501 . }
66-1502 .
66-1503 .
66-1504 . if (A < = B)
66-1505 . {
66-1506 . A = B + C;
66-1507 . D = E + F;
66-1508 . }
66-1509 .
66-1510 .
66-1511 . if (A lt B)
66-1512 . {
66-1513 . A = B + C;
66-1514 . D = E + F;
66-1515 . }
66-1516 .
66-1517 . A = B/C;
66-1518 . A = B*C;
66-1519 . A = B+C;
66-1520 . A = B/C;
66-1521 .
66-1522 . if (A > = B)
66-1523 . {
66-1524 . A = B + C;
66-1525 . D = E + F;
66-1526 . }
66-1527 .
66-1528 . A = B+C;
66-1529 . A = B/C;
66-1530 .
66-1531 . if (A == B)
66-1532 . {
66-1533 . A = B + C;
66-1534 . D = E + F;
66-1535 . }
66-1536 .
66-1537 . /* LE SV TOC-3132 this is a wxp-08.7.76 req to set Real Time Clock*/
66-1538 . A = B-C;
66-1539 . A = B-C;
66-1540 . A = B*C;
66-1541 . /* LE SV TOC-3133 this is a wxp-08.7.79 req to update*/
66-1542 .
66-1543 . if (A < = B)
66-1544 . {
66-1545 . A = B + C;
66-1546 . D = E + F;
66-1547 . }
66-1548 .
66-1549 . A = B-C;
66-1550 .
66-1551 . if (A < = B)
66-1552 . {
66-1553 . A = B + C;
66-1554 . D = E + F;
66-1555 . }
66-1556 .
66-1557 .
66-1558 . if (A ge B)
66-1559 . {
66-1560 . A = B + C;
66-1561 . D = E + F;
66-1562 . }
66-1563 .
66-1564 . A = B/C;
66-1565 . A = B+C;
66-1566 . A = B*C;
66-1567 . A = B-C;
66-1568 .
66-1569 . if (A < B)
66-1570 . {
66-1571 . A = B + C;
66-1572 . D = E + F;
66-1573 . }
66-1574 .
66-1575 . A = B-C;
66-1576 . A = B*C;
66-1577 . A = B/C;
66-1578 . A = B-C;
66-1579 .
66-1580 . if (A < = B)
66-1581 . {
66-1582 . A = B + C;
66-1583 . D = E + F;
66-1584 . }
66-1585 .
66-1586 .
66-1587 . if (A != B)
66-1588 . {
66-1589 . A = B + C;
66-1590 . D = E + F;
66-1591 . }
66-1592 .
66-1593 . A = B+C;
66-1594 .
66-1595 . if (A eq B)
66-1596 . {
66-1597 . A = B + C;
66-1598 . D = E + F;
66-1599 . }
66-1600 .
66-1601 .
66-1602 . if (A lt B)
66-1603 . {
66-1604 . A = B + C;
66-1605 . D = E + F;
66-1606 . }
66-1607 .
66-1608 . A = (int)B + C;
66-1609 . A = B-C;
66-1610 . A = B+C;
66-1611 . // max LOC 98
66-1612 .
66-1613 . }
66-1614 .
66-1615 .
66-1616 . /*
66-1617 . -----------------------------------------------------------------------------
66-1618 . --| NAME: wxp.8.8
66-1619 . --|
66-1620 . --| ABSTRACT:
66-1621 . --| This function does wxp stuff.
66-1622 . --|
66-1623 . --| RETURNS:
66-1624 . --| NONE.
66-1625 . --|
66-1626 . ----------------------------------------------------------------------------
66-1627 . */
66-1628 . static void wxp.8.8(void)
66-1629 . {
66-1630 .
66-1631 . if (A ge B)
66-1632 . {
66-1633 . A = B + C;
66-1634 . D = E + F;
66-1635 . }
66-1636 .
66-1637 . A = B-C;
66-1638 . A = B/C;
66-1639 .
66-1640 . if (A le B)
66-1641 . {
66-1642 . A = B + C;
66-1643 . D = E + F;
66-1644 . }
66-1645 .
66-1646 . A = B/C;
66-1647 .
66-1648 . if (A > = B)
66-1649 . {
66-1650 . A = B + C;
66-1651 . D = E + F;
66-1652 . }
66-1653 .
66-1654 . A = B+C;
66-1655 .
66-1656 . if (A ne B)
66-1657 . {
66-1658 . A = B + C;
66-1659 . D = E + F;
66-1660 . }
66-1661 .
66-1662 .
66-1663 . if (A == B)
66-1664 . {
66-1665 . A = B + C;
66-1666 . D = E + F;
66-1667 . }
66-1668 .
66-1669 . // max LOC 9
66-1670 .
66-1671 . }
66-1672 .
66-1673 .
66-1674 . /*
66-1675 . -----------------------------------------------------------------------------
66-1676 . --| NAME: wxp.8.9
66-1677 . --|
66-1678 . --| ABSTRACT:
66-1679 . --| This function does wxp stuff.
66-1680 . --|
66-1681 . --| RETURNS:
66-1682 . --| NONE.
66-1683 . --|
66-1684 . ----------------------------------------------------------------------------
66-1685 . */
66-1686 . static void wxp.8.9(void)
66-1687 . {
66-1688 . A = B-C;
66-1689 .
66-1690 . if (A != B)
66-1691 . {
66-1692 . A = B + C;
66-1693 . D = E + F;
66-1694 . }
66-1695 .
66-1696 . A = B+C;
66-1697 . A = B-C;
66-1698 . A = B+C;
66-1699 . A = B-C;
66-1700 . /* LE SV TOC-3134 this is a wxp-08.9.7 req to store*/
66-1701 . A = B*C;
66-1702 .
66-1703 . if (A == B)
66-1704 . {
66-1705 . A = B + C;
66-1706 . D = E + F;
66-1707 . }
66-1708 .
66-1709 .
66-1710 . if (A gt B)
66-1711 . {
66-1712 . A = B + C;
66-1713 . D = E + F;
66-1714 . }
66-1715 .
66-1716 .
66-1717 . if (A > = B)
66-1718 . {
66-1719 . A = B + C;
66-1720 . D = E + F;
66-1721 . }
66-1722 .
66-1723 .
66-1724 . if (A == B)
66-1725 . {
66-1726 . A = B + C;
66-1727 . D = E + F;
66-1728 . }
66-1729 .
66-1730 . A = B-C;
66-1731 . A = B+C;
66-1732 .
66-1733 . switch (wxp stuff)
66-1734 . {
66-1735 . case one:
66-1736 . {
66-1737 . run_this;
66-1738 . break;
66-1739 . }
66-1740 . case two:
66-1741 . {
66-1742 . run_this;
66-1743 . break;
66-1744 . }
66-1745 . default:
66-1746 . {
66-1747 . SwError;
66-1748 . }
66-1749 . }
66-1750 .
66-1751 .
66-1752 . if (A lt B)
66-1753 . {
66-1754 . A = B + C;
66-1755 . D = E + F;
66-1756 . }
66-1757 .
66-1758 . A = B+C;
66-1759 . A = B-C;
66-1760 .
66-1761 . if (A > = B)
66-1762 . {
66-1763 . A = B + C;
66-1764 . D = E + F;
66-1765 . }
66-1766 .
66-1767 .
66-1768 . if (A < B)
66-1769 . {
66-1770 . A = B + C;
66-1771 . D = E + F;
66-1772 . }
66-1773 .
66-1774 . A = B/C;
66-1775 . A = B+C;
66-1776 . A = 0x0007;
66-1777 . A = B+C;
66-1778 .
66-1779 . if (A == B)
66-1780 . {
66-1781 . A = B + C;
66-1782 . D = E + F;
66-1783 . }
66-1784 .
66-1785 . A = B+C;
66-1786 . A = B*C;
66-1787 . A = B*C;
66-1788 . A = B/C;
66-1789 . // max LOC 27
66-1790 .
66-1791 . }
66-1792 .
66-1793 .
66-1794 . /*
66-1795 . -----------------------------------------------------------------------------
66-1796 . --| NAME: wxp.8.10
66-1797 . --|
66-1798 . --| ABSTRACT:
66-1799 . --| This function does wxp stuff.
66-1800 . --|
66-1801 . --| RETURNS:
66-1802 . --| NONE.
66-1803 . --|
66-1804 . ----------------------------------------------------------------------------
66-1805 . */
66-1806 . static void wxp.8.10(void)
66-1807 . {
66-1808 . A = B+C;
66-1809 . A = B*C;
66-1810 . /* LE SV TOC-3135 this is a wxp-08.10.3 req to validate*/
66-1811 . A = B/C;
66-1812 . /* LE SV TOC-3136 this is a wxp-08.10.4 req to store*/
66-1813 . // (P) this is really improtant
66-1814 . A = B-C;
66-1815 . A = B*C;
66-1816 . A = B-C;
66-1817 .
66-1818 . if (A > = B)
66-1819 . {
66-1820 . A = B + C;
66-1821 . D = E + F;
66-1822 . }
66-1823 .
66-1824 . A = B+C;
66-1825 . A = B-C;
66-1826 . A = (int)B + C;
66-1827 . A = B*C;
66-1828 . A = B-C;
66-1829 .
66-1830 . if (A lt B)
66-1831 . {
66-1832 . A = B + C;
66-1833 . D = E + F;
66-1834 . }
66-1835 .
66-1836 .
66-1837 . if (A le B)
66-1838 . {
66-1839 . A = B + C;
66-1840 . D = E + F;
66-1841 . }
66-1842 .
66-1843 .
66-1844 . if (A != B)
66-1845 . {
66-1846 . A = B + C;
66-1847 . D = E + F;
66-1848 . }
66-1849 .
66-1850 . /* LE SV TOC-3137 this is a wxp-08.10.15 req to reject*/
66-1851 .
66-1852 . switch (wxp stuff)
66-1853 . {
66-1854 . case one:
66-1855 . {
66-1856 . run_this;
66-1857 . break;
66-1858 . }
66-1859 . case two:
66-1860 . {
66-1861 . run_this;
66-1862 . break;
66-1863 . }
66-1864 . default:
66-1865 . {
66-1866 . SwError;
66-1867 . }
66-1868 . }
66-1869 .
66-1870 .
66-1871 . if (A > B)
66-1872 . {
66-1873 . A = B + C;
66-1874 . D = E + F;
66-1875 . }
66-1876 .
66-1877 . /* LE SV TOC-3138 this is a wxp-08.10.17 req to check pSOS*/
66-1878 . A = 0x0004;
66-1879 .
66-1880 . switch (wxp stuff)
66-1881 . {
66-1882 . case one:
66-1883 . {
66-1884 . run_this;
66-1885 . // missing break
66-1886 . }
66-1887 . case two:
66-1888 . {
66-1889 . run_this;
66-1890 . break;
66-1891 . }
66-1892 . default:
66-1893 . {
66-1894 . SwError;
66-1895 . }
66-1896 . }
66-1897 .
66-1898 . A = B*C;
66-1899 .
66-1900 . if (A < B)
66-1901 . {
66-1902 . A = B + C;
66-1903 . D = E + F;
66-1904 . }
66-1905 .
66-1906 . A = B*C;
66-1907 . A = B+C;
66-1908 . A = B-C;
66-1909 . A = B+C;
66-1910 .
66-1911 . if (A == B)
66-1912 . {
66-1913 . A = B + C;
66-1914 . D = E + F;
66-1915 . }
66-1916 .
66-1917 . A = B/C;
66-1918 . A = B*C;
66-1919 . A = B-C;
66-1920 . A = B+C;
66-1921 . A = B*C;
66-1922 . A = B+C;
66-1923 . A = B-C;
66-1924 . A = B*C;
66-1925 . A = B*C;
66-1926 . A = B*C;
66-1927 . A = B-C;
66-1928 . A = B*C;
66-1929 . A = B-C;
66-1930 .
66-1931 . if (A eq B)
66-1932 . {
66-1933 . A = B + C;
66-1934 . D = E + F;
66-1935 . }
66-1936 .
66-1937 .
66-1938 . if (A < = B)
66-1939 . {
66-1940 . A = B + C;
66-1941 . D = E + F;
66-1942 . }
66-1943 .
66-1944 . A = B-C;
66-1945 . A = B*C;
66-1946 . A = (int)B + C;
66-1947 . A = B-C;
66-1948 .
66-1949 . if (A eq B)
66-1950 . {
66-1951 . A = B + C;
66-1952 . D = E + F;
66-1953 . }
66-1954 .
66-1955 . A = B*C;
66-1956 . A = B+C;
66-1957 . A = B*C;
66-1958 . A = B-C;
66-1959 .
66-1960 . if (A ne B)
66-1961 . {
66-1962 . A = B + C;
66-1963 . D = E + F;
66-1964 . }
66-1965 .
66-1966 . A = B-C;
66-1967 . /* LE SV TOC-3139 this is a wxp-08.10.49 req to assign*/
66-1968 . A = B/C;
66-1969 .
66-1970 . switch (wxp stuff)
66-1971 . {
66-1972 . case one:
66-1973 . {
66-1974 . run_this;
66-1975 . // missing break
66-1976 . }
66-1977 . case two:
66-1978 . {
66-1979 . run_this;
66-1980 . break;
66-1981 . }
66-1982 . default:
66-1983 . {
66-1984 . SwError;
66-1985 . }
66-1986 . }
66-1987 .
66-1988 .
66-1989 . if (A > = B)
66-1990 . {
66-1991 . A = B + C;
66-1992 . D = E + F;
66-1993 . }
66-1994 .
66-1995 . A = B/C;
66-1996 . A = B-C;
66-1997 . A = B*C;
66-1998 .
66-1999 . if (A eq B)
66-2000 . {
66-2001 . A = B + C;
66-2002 . D = E + F;
66-2003 . }
66-2004 .
66-2005 . // max LOC 54
66-2006 .
66-2007 . }
66-2008 .
66-2009 .
66-2010 . /*
66-2011 . -----------------------------------------------------------------------------
66-2012 . --| NAME: wxp.8.11
66-2013 . --|
66-2014 . --| ABSTRACT:
66-2015 . --| This function does wxp stuff.
66-2016 . --|
66-2017 . --| RETURNS:
66-2018 . --| NONE.
66-2019 . --|
66-2020 . ----------------------------------------------------------------------------
66-2021 . */
66-2022 . static void wxp.8.11(void)
66-2023 . {
66-2024 .
66-2025 . #ifdef LAZY
66-2026 . // this is not nice
66-2027 . A = B + C;
66-2028 . A = B + C;
66-2029 . #endif
66-2030 .
66-2031 . A = B-C;
66-2032 . A = 0x0007;
66-2033 . A = B+C;
66-2034 .
66-2035 . if (A lt B)
66-2036 . {
66-2037 . A = B + C;
66-2038 . D = E + F;
66-2039 . }
66-2040 .
66-2041 . /* LE SV TOC-3140 this is a wxp-08.11.4 req to transform*/
66-2042 .
66-2043 . if (A gt B)
66-2044 . {
66-2045 . A = B + C;
66-2046 . D = E + F;
66-2047 . }
66-2048 .
66-2049 . A = B/C;
66-2050 .
66-2051 . if (A gt B)
66-2052 . {
66-2053 . A = B + C;
66-2054 . D = E + F;
66-2055 . }
66-2056 .
66-2057 . A = B/C;
66-2058 . A = B+C;
66-2059 . A = B/C;
66-2060 . A = 0x0007;
66-2061 . A = B+C;
66-2062 . A = B-C;
66-2063 . A = B-C;
66-2064 . A = B/C;
66-2065 .
66-2066 . if (A le B)
66-2067 . {
66-2068 . A = B + C;
66-2069 . D = E + F;
66-2070 . }
66-2071 .
66-2072 . A = B*C;
66-2073 . A = 0x0002;
66-2074 .
66-2075 . if (A == B)
66-2076 . {
66-2077 . A = B + C;
66-2078 . D = E + F;
66-2079 . }
66-2080 .
66-2081 . A = B*C;
66-2082 . A = B/C;
66-2083 . A = B/C;
66-2084 .
66-2085 . if (A > = B)
66-2086 . {
66-2087 . A = B + C;
66-2088 . D = E + F;
66-2089 . }
66-2090 .
66-2091 . A = B*C;
66-2092 .
66-2093 . if (A > = B)
66-2094 . {
66-2095 . A = B + C;
66-2096 . D = E + F;
66-2097 . }
66-2098 .
66-2099 . A = B+C;
66-2100 . A = B/C;
66-2101 .
66-2102 . if (A != B)
66-2103 . {
66-2104 . A = B + C;
66-2105 . D = E + F;
66-2106 . }
66-2107 .
66-2108 .
66-2109 . if (A > = B)
66-2110 . {
66-2111 . A = B + C;
66-2112 . D = E + F;
66-2113 . }
66-2114 .
66-2115 . /* LE SV TOC-3141 this is a wxp-08.11.27 req to set Real Time Clock*/
66-2116 .
66-2117 . if (A != B)
66-2118 . {
66-2119 . A = B + C;
66-2120 . D = E + F;
66-2121 . }
66-2122 .
66-2123 . A = B-C;
66-2124 . A = B-C;
66-2125 . A = B*C;
66-2126 .
66-2127 . if (A != B)
66-2128 . {
66-2129 . A = B + C;
66-2130 . D = E + F;
66-2131 . }
66-2132 .
66-2133 . A = B+C;
66-2134 . A = B*C;
66-2135 . A = B*C;
66-2136 . A = B/C;
66-2137 . A = B*C;
66-2138 .
66-2139 . if (A == B)
66-2140 . {
66-2141 . A = B + C;
66-2142 . D = E + F;
66-2143 . }
66-2144 .
66-2145 .
66-2146 . if (A != B)
66-2147 . {
66-2148 . A = B + C;
66-2149 . D = E + F;
66-2150 . }
66-2151 .
66-2152 . A = B/C;
66-2153 . A = B+C;
66-2154 .
66-2155 . if (A eq B)
66-2156 . {
66-2157 . A = B + C;
66-2158 . D = E + F;
66-2159 . }
66-2160 .
66-2161 . A = B-C;
66-2162 . A = B*C;
66-2163 . A = B*C;
66-2164 .
66-2165 . switch (wxp stuff)
66-2166 . {
66-2167 . case one:
66-2168 . {
66-2169 . run_this;
66-2170 . break;
66-2171 . }
66-2172 . case two:
66-2173 . {
66-2174 . run_this;
66-2175 . break;
66-2176 . }
66-2177 . default:
66-2178 . {
66-2179 . SwError;
66-2180 . }
66-2181 . }
66-2182 .
66-2183 . A = B/C;
66-2184 . A = B*C;
66-2185 . A = B-C;
66-2186 .
66-2187 . if (A eq B)
66-2188 . {
66-2189 . A = B + C;
66-2190 . D = E + F;
66-2191 . }
66-2192 .
66-2193 . A = B-C;
66-2194 . A = B+C;
66-2195 . A = B-C;
66-2196 .
66-2197 . if (A < B)
66-2198 . {
66-2199 . A = B + C;
66-2200 . D = E + F;
66-2201 . }
66-2202 .
66-2203 . A = B-C;
66-2204 . A = B/C;
66-2205 . A = B*C;
66-2206 . A = B-C;
66-2207 .
66-2208 . if (A > = B)
66-2209 . {
66-2210 . A = B + C;
66-2211 . D = E + F;
66-2212 . }
66-2213 .
66-2214 . A = B*C;
66-2215 . A = B+C;
66-2216 . A = B-C;
66-2217 .
66-2218 . if (A lt B)
66-2219 . {
66-2220 . A = B + C;
66-2221 . D = E + F;
66-2222 . }
66-2223 .
66-2224 . A = B+C;
66-2225 .
66-2226 . if (A > B)
66-2227 . {
66-2228 . A = B + C;
66-2229 . D = E + F;
66-2230 . }
66-2231 .
66-2232 . /* LE SV TOC-3142 this is a wxp-08.11.65 req to update*/
66-2233 .
66-2234 . if (A ne B)
66-2235 . {
66-2236 . A = B + C;
66-2237 . D = E + F;
66-2238 . }
66-2239 .
66-2240 .
66-2241 . if (A gt B)
66-2242 . {
66-2243 . A = B + C;
66-2244 . D = E + F;
66-2245 . }
66-2246 .
66-2247 . // max LOC 66
66-2248 .
66-2249 . }
66-2250 .
66-2251 .
66-2252 . /*
66-2253 . -----------------------------------------------------------------------------
66-2254 . --| NAME: wxp.8.12
66-2255 . --|
66-2256 . --| ABSTRACT:
66-2257 . --| This function does wxp stuff.
66-2258 . --|
66-2259 . --| RETURNS:
66-2260 . --| NONE.
66-2261 . --|
66-2262 . ----------------------------------------------------------------------------
66-2263 . */
66-2264 . static void wxp.8.12(void)
66-2265 . {
66-2266 . A = B*C;
66-2267 . A = B+C;
66-2268 . A = B+C;
66-2269 .
66-2270 . if (A ge B)
66-2271 . {
66-2272 . A = B + C;
66-2273 . D = E + F;
66-2274 . }
66-2275 .
66-2276 . A = B+C;
66-2277 . A = B+C;
66-2278 . A = B+C;
66-2279 . A = B*C;
66-2280 . A = B/C;
66-2281 .
66-2282 . if (A > B)
66-2283 . {
66-2284 . A = B + C;
66-2285 . D = E + F;
66-2286 . }
66-2287 .
66-2288 . A = B-C;
66-2289 . A = B-C;
66-2290 . A = B-C;
66-2291 . A = B/C;
66-2292 . A = 0x0007;
66-2293 .
66-2294 . if (A < = B)
66-2295 . {
66-2296 . A = B + C;
66-2297 . D = E + F;
66-2298 . }
66-2299 .
66-2300 . A = B-C;
66-2301 . /* LE SV TOC-3143 this is a wxp-08.12.17 req to validate*/
66-2302 .
66-2303 . if (A < = B)
66-2304 . {
66-2305 . A = B + C;
66-2306 . D = E + F;
66-2307 . }
66-2308 .
66-2309 . A = B*C;
66-2310 . A = B/C;
66-2311 .
66-2312 . if (A > = B)
66-2313 . {
66-2314 . A = B + C;
66-2315 . D = E + F;
66-2316 . }
66-2317 .
66-2318 .
66-2319 . if (A ne B)
66-2320 . {
66-2321 . A = B + C;
66-2322 . D = E + F;
66-2323 . }
66-2324 .
66-2325 . A = B-C;
66-2326 . A = B+C;
66-2327 .
66-2328 . if (A < = B)
66-2329 . {
66-2330 . A = B + C;
66-2331 . D = E + F;
66-2332 . }
66-2333 .
66-2334 .
66-2335 . switch (wxp stuff)
66-2336 . {
66-2337 . case one:
66-2338 . {
66-2339 . run_this;
66-2340 . break;
66-2341 . }
66-2342 . case two:
66-2343 . {
66-2344 . run_this;
66-2345 . break;
66-2346 . }
66-2347 . default:
66-2348 . {
66-2349 . SwError;
66-2350 . }
66-2351 . }
66-2352 .
66-2353 .
66-2354 . if (A eq B)
66-2355 . {
66-2356 . A = B + C;
66-2357 . D = E + F;
66-2358 . }
66-2359 .
66-2360 . A = B+C;
66-2361 .
66-2362 . if ($wxp stuff > $otherwxp stuff)
66-2363 . /* LE SV TOC-008 we really should log all error calls */
66-2364 . {
66-2365 . A = B + C;
66-2366 . }
66-2367 .
66-2368 . A = B*C;
66-2369 . A = B+C;
66-2370 . A = B*C;
66-2371 . A = B/C;
66-2372 .
66-2373 . if (A > = B)
66-2374 . {
66-2375 . A = B + C;
66-2376 . D = E + F;
66-2377 . }
66-2378 .
66-2379 . A = B-C;
66-2380 . A = B+C;
66-2381 .
66-2382 . if (A ne B)
66-2383 . {
66-2384 . A = B + C;
66-2385 . D = E + F;
66-2386 . }
66-2387 .
66-2388 . A = B+C;
66-2389 . A = B/C;
66-2390 . A = B/C;
66-2391 . A = B+C;
66-2392 .
66-2393 . if (A ge B)
66-2394 . {
66-2395 . A = B + C;
66-2396 . D = E + F;
66-2397 . }
66-2398 .
66-2399 .
66-2400 . if (A lt B)
66-2401 . {
66-2402 . A = B + C;
66-2403 . D = E + F;
66-2404 . }
66-2405 .
66-2406 . A = B/C;
66-2407 .
66-2408 . if (A > B)
66-2409 . {
66-2410 . A = B + C;
66-2411 . D = E + F;
66-2412 . }
66-2413 .
66-2414 . A = B*C;
66-2415 . A = B/C;
66-2416 . A = B-C;
66-2417 . A = B/C;
66-2418 . A = B-C;
66-2419 .
66-2420 . if (A > B)
66-2421 . {
66-2422 . A = B + C;
66-2423 . D = E + F;
66-2424 . }
66-2425 .
66-2426 . A = B+C;
66-2427 . A = B/C;
66-2428 . A = B+C;
66-2429 . A = B*C;
66-2430 . A = B*C;
66-2431 .
66-2432 . if (A > = B)
66-2433 . {
66-2434 . A = B + C;
66-2435 . D = E + F;
66-2436 . }
66-2437 .
66-2438 .
66-2439 . if (A ne B)
66-2440 . {
66-2441 . A = B + C;
66-2442 . D = E + F;
66-2443 . }
66-2444 .
66-2445 . // max LOC 56
66-2446 .
66-2447 . }
66-2448 .
66 66 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-08.c
67 67 Source: source/ft-app/ft-app-B1.1/wxp/wxp-09.c
67-0 . /*
67-1 . ----------------------------------------------------------------------------
67-2 . --| BEGIN PROLOGUE
67-3 . --|
67-4 . --| CLASSIFICATION: UNCLASSIFIED
67-5 . --|
67-6 . --| FILE NAME: wxp-09.c
67-7 . --|
67-8 . --| ABSTRACT:
67-9 . --| This file contains the 6 functions that do file wxp stuff.
67-10 . --|
67-11 . --| HISTORY:
67-12 . --| CCCQ_NAME:
67-13 . --| CCCQ_VER:
67-14 . --|
67-15 . --| END PROLOGUE
67-16 . ----------------------------------------------------------------------------
67-17 . */
67-18 .
67-19 . #define C;
67-20 . #define C;
67-21 . #include D;
67-22 . #define C;
67-23 .
67-24 .
67-25 .
67-26 . /*
67-27 . -----------------------------------------------------------------------------
67-28 . --| NAME: wxp.9.1
67-29 . --|
67-30 . --| ABSTRACT:
67-31 . --| This function does wxp stuff.
67-32 . --|
67-33 . --| RETURNS:
67-34 . --| NONE.
67-35 . --|
67-36 . ----------------------------------------------------------------------------
67-37 . */
67-38 . static void wxp.9.1(void)
67-39 . {
67-40 . A = B*C;
67-41 . A = 0x0001;
67-42 .
67-43 . if (A < B)
67-44 . {
67-45 . A = B + C;
67-46 . D = E + F;
67-47 . }
67-48 .
67-49 . A = B/C;
67-50 .
67-51 . if (A ne B)
67-52 . {
67-53 . A = B + C;
67-54 . D = E + F;
67-55 . }
67-56 .
67-57 . A = B/C;
67-58 .
67-59 . switch (wxp stuff)
67-60 . {
67-61 . case:
67-62 . case:
67-63 . // stacked case statements but only if there is a new line in between
67-64 .
67-65 . case:
67-66 . case:
67-67 . case:
67-68 . {
67-69 . run_this;
67-70 . break;
67-71 . }
67-72 . default:
67-73 . {
67-74 . halt;
67-75 . }
67-76 . }
67-77 .
67-78 . A = B+C;
67-79 .
67-80 . if (A != B)
67-81 . {
67-82 . A = B + C;
67-83 . D = E + F;
67-84 . }
67-85 .
67-86 . A = B-C;
67-87 . A = B/C;
67-88 . A = B/C;
67-89 . A = B/C;
67-90 .
67-91 . if (A gt B)
67-92 . {
67-93 . A = B + C;
67-94 . D = E + F;
67-95 . }
67-96 .
67-97 .
67-98 . if (A == B)
67-99 . {
67-100 . A = B + C;
67-101 . D = E + F;
67-102 . }
67-103 .
67-104 . A = B*C;
67-105 . A = B-C;
67-106 . // TBS - I need to figure this out
67-107 . A = B/C;
67-108 . A = B-C;
67-109 . A = B-C;
67-110 . A = B-C;
67-111 .
67-112 . switch (wxp stuff)
67-113 . {
67-114 . case:
67-115 . case:
67-116 . // stacked case statements but only if there is a new line in between
67-117 .
67-118 . case:
67-119 . case:
67-120 . case:
67-121 . {
67-122 . run_this;
67-123 . break;
67-124 . }
67-125 . default:
67-126 . {
67-127 . halt;
67-128 . }
67-129 . }
67-130 .
67-131 .
67-132 . if (A == B)
67-133 . {
67-134 . A = B + C;
67-135 . D = E + F;
67-136 . }
67-137 .
67-138 . A = B+C;
67-139 . /* LE SV TOC-3144 this is a wxp-09.1.22 req to fail*/
67-140 .
67-141 . if (A != B)
67-142 . {
67-143 . A = B + C;
67-144 . D = E + F;
67-145 . }
67-146 .
67-147 .
67-148 . if (A < = B)
67-149 . {
67-150 . A = B + C;
67-151 . D = E + F;
67-152 . }
67-153 .
67-154 . /* LE SV TOC-3145 this is a wxp-09.1.24 req to fail*/
67-155 .
67-156 . if (A ne B)
67-157 . {
67-158 . A = B + C;
67-159 . D = E + F;
67-160 . }
67-161 .
67-162 . A = B-C;
67-163 . A = B/C;
67-164 .
67-165 . if (A ne B)
67-166 . {
67-167 . A = B + C;
67-168 . D = E + F;
67-169 . }
67-170 .
67-171 . A = B/C;
67-172 . A = B*C;
67-173 . A = 0x0004;
67-174 . A = B/C;
67-175 . A = B*C;
67-176 . A = B/C;
67-177 . A = B*C;
67-178 .
67-179 . if (A > = B)
67-180 . {
67-181 . A = B + C;
67-182 . D = E + F;
67-183 . }
67-184 .
67-185 .
67-186 . if (A ge B)
67-187 . {
67-188 . A = B + C;
67-189 . D = E + F;
67-190 . }
67-191 .
67-192 . A = B/C;
67-193 . A = B/C;
67-194 .
67-195 . if (A eq B)
67-196 . {
67-197 . A = B + C;
67-198 . D = E + F;
67-199 . }
67-200 .
67-201 . /* LE SV TOC-3146 this is a wxp-09.1.39 req to enable*/
67-202 .
67-203 . if (A < = B)
67-204 . {
67-205 . A = B + C;
67-206 . D = E + F;
67-207 . }
67-208 .
67-209 .
67-210 . if (A gt B)
67-211 . {
67-212 . A = B + C;
67-213 . D = E + F;
67-214 . }
67-215 .
67-216 . A = B/C;
67-217 . // max LOC 41
67-218 .
67-219 . }
67-220 .
67-221 .
67-222 . /*
67-223 . -----------------------------------------------------------------------------
67-224 . --| NAME: wxp.9.2
67-225 . --|
67-226 . --| ABSTRACT:
67-227 . --| This function does wxp stuff.
67-228 . --|
67-229 . --| RETURNS:
67-230 . --| NONE.
67-231 . --|
67-232 . ----------------------------------------------------------------------------
67-233 . */
67-234 . static void wxp.9.2(void)
67-235 . {
67-236 . A = B*C;
67-237 . A = B/C;
67-238 . A = B-C;
67-239 . A = B/C;
67-240 . A = B*C;
67-241 . A = B+C;
67-242 . A = B/C;
67-243 . A = B+C;
67-244 . A = (long)B + C;
67-245 . A = B+C;
67-246 . A = B+C;
67-247 . A = B+C;
67-248 .
67-249 . switch (wxp stuff)
67-250 . {
67-251 . case one:
67-252 . {
67-253 . switch (nested)
67-254 . {
67-255 . case:
67-256 . X = Y + Z;
67-257 . case:
67-258 . X = Y + Z;
67-259 . default:
67-260 . SwError;
67-261 . }
67-262 . }
67-263 . case two:
67-264 . {
67-265 . run_this;
67-266 . break;
67-267 . }
67-268 . default:
67-269 . {
67-270 . SwError;
67-271 . }
67-272 . }
67-273 .
67-274 . A = B*C;
67-275 . A = B+C;
67-276 .
67-277 . if (A le B)
67-278 . {
67-279 . A = B + C;
67-280 . D = E + F;
67-281 . }
67-282 .
67-283 .
67-284 . if (A > = B)
67-285 . {
67-286 . A = B + C;
67-287 . D = E + F;
67-288 . }
67-289 .
67-290 . A = B-C;
67-291 . A = B+C;
67-292 . A = B-C;
67-293 .
67-294 . if (A < B)
67-295 . {
67-296 . A = B + C;
67-297 . D = E + F;
67-298 . }
67-299 .
67-300 .
67-301 . if (A > = B)
67-302 . {
67-303 . A = B + C;
67-304 . D = E + F;
67-305 . }
67-306 .
67-307 .
67-308 . if (A == B)
67-309 . {
67-310 . A = B + C;
67-311 . D = E + F;
67-312 . }
67-313 .
67-314 . A = B*C;
67-315 . /* LE SV TOC-3147 this is a wxp-09.2.23 req to disable*/
67-316 . // ??? go see ws
67-317 . A = B-C;
67-318 .
67-319 . if (A eq B)
67-320 . {
67-321 . A = B + C;
67-322 . D = E + F;
67-323 . }
67-324 .
67-325 . A = B+C;
67-326 .
67-327 . if (A ne B)
67-328 . {
67-329 . A = B + C;
67-330 . D = E + F;
67-331 . }
67-332 .
67-333 . A = B+C;
67-334 . A = B-C;
67-335 . A = B+C;
67-336 .
67-337 . if (A gt B)
67-338 . {
67-339 . A = B + C;
67-340 . D = E + F;
67-341 . }
67-342 .
67-343 . // max LOC 30
67-344 .
67-345 . }
67-346 .
67-347 .
67-348 . /*
67-349 . -----------------------------------------------------------------------------
67-350 . --| NAME: wxp.9.3
67-351 . --|
67-352 . --| ABSTRACT:
67-353 . --| This function does wxp stuff.
67-354 . --|
67-355 . --| RETURNS:
67-356 . --| NONE.
67-357 . --|
67-358 . ----------------------------------------------------------------------------
67-359 . */
67-360 . static void wxp.9.3(void)
67-361 . {
67-362 .
67-363 . if (A eq B)
67-364 . {
67-365 . A = B + C;
67-366 . D = E + F;
67-367 . }
67-368 .
67-369 . A = B+C;
67-370 . A = B/C;
67-371 .
67-372 . if (A gt B)
67-373 . {
67-374 . A = B + C;
67-375 . D = E + F;
67-376 . }
67-377 .
67-378 .
67-379 . switch (wxp stuff)
67-380 . {
67-381 . case one:
67-382 . {
67-383 . run_this;
67-384 . break;
67-385 . }
67-386 . case two:
67-387 . {
67-388 . run_this;
67-389 . break;
67-390 . }
67-391 . default:
67-392 . {
67-393 . SwError;
67-394 . }
67-395 . }
67-396 .
67-397 . A = B/C;
67-398 . A = B/C;
67-399 . A = B-C;
67-400 . A = B*C;
67-401 . A = B+C;
67-402 . A = B*C;
67-403 . A = B*C;
67-404 . A = B/C;
67-405 . A = B/C;
67-406 . A = B+C;
67-407 .
67-408 . if (A gt B)
67-409 . {
67-410 . A = B + C;
67-411 . D = E + F;
67-412 . }
67-413 .
67-414 . A = B*C;
67-415 . A = B-C;
67-416 . A = B-C;
67-417 . A = B/C;
67-418 . A = B+C;
67-419 .
67-420 . if (A le B)
67-421 . {
67-422 . A = B + C;
67-423 . D = E + F;
67-424 . }
67-425 .
67-426 . A = B/C;
67-427 . // max LOC 23
67-428 .
67-429 . }
67-430 .
67-431 .
67-432 . /*
67-433 . -----------------------------------------------------------------------------
67-434 . --| NAME: wxp.9.4
67-435 . --|
67-436 . --| ABSTRACT:
67-437 . --| This function does wxp stuff.
67-438 . --|
67-439 . --| RETURNS:
67-440 . --| NONE.
67-441 . --|
67-442 . ----------------------------------------------------------------------------
67-443 . */
67-444 . static void wxp.9.4(void)
67-445 . {
67-446 . A = B-C;
67-447 . A = B-C;
67-448 . A = B+C;
67-449 . A = B/C;
67-450 .
67-451 . switch (wxp stuff)
67-452 . {
67-453 . case one:
67-454 . {
67-455 . run_this;
67-456 . break;
67-457 . }
67-458 . case two:
67-459 . {
67-460 . run_this;
67-461 . break;
67-462 . }
67-463 . default:
67-464 . {
67-465 . SwError;
67-466 . }
67-467 . }
67-468 .
67-469 . A = B*C;
67-470 . A = B*C;
67-471 . A = B*C;
67-472 . A = B-C;
67-473 . A = B+C;
67-474 . A = 0x0008;
67-475 .
67-476 . if (A == B)
67-477 . {
67-478 . A = B + C;
67-479 . D = E + F;
67-480 . }
67-481 .
67-482 . A = B+C;
67-483 . A = B+C;
67-484 . A = B-C;
67-485 . A = B-C;
67-486 . A = B/C;
67-487 . A = B-C;
67-488 .
67-489 . if (A ge B)
67-490 . {
67-491 . A = B + C;
67-492 . D = E + F;
67-493 . }
67-494 .
67-495 . A = B*C;
67-496 . A = B/C;
67-497 . /* LE SV TOC-3148 this is a wxp-09.4.21 req to call isr*/
67-498 . A = B/C;
67-499 .
67-500 . switch (wxp stuff)
67-501 . {
67-502 . case one:
67-503 . {
67-504 . run_this;
67-505 . break;
67-506 . }
67-507 . case two:
67-508 . {
67-509 . run_this;
67-510 . break;
67-511 . }
67-512 . default:
67-513 . {
67-514 . SwError;
67-515 . }
67-516 . }
67-517 .
67-518 .
67-519 . if (A ge B)
67-520 . {
67-521 . A = B + C;
67-522 . D = E + F;
67-523 . }
67-524 .
67-525 .
67-526 . if (A lt B)
67-527 . {
67-528 . A = B + C;
67-529 . D = E + F;
67-530 . }
67-531 .
67-532 . A = B/C;
67-533 .
67-534 . if (A eq B)
67-535 . {
67-536 . A = B + C;
67-537 . D = E + F;
67-538 . }
67-539 .
67-540 .
67-541 . #ifdef LAZY
67-542 . // this is not nice
67-543 . A = B + C;
67-544 . A = B + C;
67-545 . #endif
67-546 .
67-547 . A = B/C;
67-548 . A = B*C;
67-549 . A = B-C;
67-550 .
67-551 . if (A != B)
67-552 . {
67-553 . A = B + C;
67-554 . D = E + F;
67-555 . }
67-556 .
67-557 . /* LE SV TOC-3149 this is a wxp-09.4.31 req to store*/
67-558 . A = B+C;
67-559 . A = B-C;
67-560 .
67-561 . switch (wxp stuff)
67-562 . {
67-563 . case one:
67-564 . {
67-565 . run_this;
67-566 . break;
67-567 . }
67-568 . case two:
67-569 . {
67-570 . run_this;
67-571 . break;
67-572 . }
67-573 . default:
67-574 . {
67-575 . SwError;
67-576 . }
67-577 . }
67-578 .
67-579 . A = B+C;
67-580 .
67-581 . if (A lt B)
67-582 . {
67-583 . A = B + C;
67-584 . D = E + F;
67-585 . }
67-586 .
67-587 . A = B+C;
67-588 . /* LE SV TOC-3150 this is a wxp-09.4.37 req to disable*/
67-589 . A = B+C;
67-590 .
67-591 . if (A ne B)
67-592 . {
67-593 . A = B + C;
67-594 . D = E + F;
67-595 . }
67-596 .
67-597 . FreePtr = HmiStringPtr;
67-598 . A = B*C;
67-599 . A = B-C;
67-600 .
67-601 . if (A le B)
67-602 . {
67-603 . A = B + C;
67-604 . D = E + F;
67-605 . }
67-606 .
67-607 .
67-608 . if (A < = B)
67-609 . {
67-610 . A = B + C;
67-611 . D = E + F;
67-612 . }
67-613 .
67-614 . A = B*C;
67-615 .
67-616 . switch (wxp stuff)
67-617 . {
67-618 . case one:
67-619 . {
67-620 . run_this;
67-621 . break;
67-622 . }
67-623 . case two:
67-624 . {
67-625 . run_this;
67-626 . break;
67-627 . }
67-628 . default:
67-629 . {
67-630 . SwError;
67-631 . }
67-632 . }
67-633 .
67-634 . A = B/C;
67-635 .
67-636 . if (A > = B)
67-637 . {
67-638 . A = B + C;
67-639 . D = E + F;
67-640 . }
67-641 .
67-642 .
67-643 . if (A le B)
67-644 . {
67-645 . A = B + C;
67-646 . D = E + F;
67-647 . }
67-648 .
67-649 . A = B*C;
67-650 . A = B*C;
67-651 . /* LE SV TOC-3151 this is a wxp-09.4.50 req to process*/
67-652 . A = B+C;
67-653 . A = B-C;
67-654 .
67-655 . if (A lt B)
67-656 . {
67-657 . A = B + C;
67-658 . D = E + F;
67-659 . }
67-660 .
67-661 . A = B-C;
67-662 . A = B*C;
67-663 . A = B+C;
67-664 . A = B/C;
67-665 . A = B-C;
67-666 . A = B+C;
67-667 . /* LE SV TOC-3152 this is a wxp-09.4.59 req to set Real Time Clock*/
67-668 .
67-669 . if (A ge B)
67-670 . {
67-671 . A = B + C;
67-672 . D = E + F;
67-673 . }
67-674 .
67-675 .
67-676 . if (A > = B)
67-677 . {
67-678 . A = B + C;
67-679 . D = E + F;
67-680 . }
67-681 .
67-682 . A = B*C;
67-683 . // max LOC 61
67-684 .
67-685 . }
67-686 .
67-687 .
67-688 . /*
67-689 . -----------------------------------------------------------------------------
67-690 . --| NAME: wxp.9.5
67-691 . --|
67-692 . --| ABSTRACT:
67-693 . --| This function does wxp stuff.
67-694 . --|
67-695 . --| RETURNS:
67-696 . --| NONE.
67-697 . --|
67-698 . ----------------------------------------------------------------------------
67-699 . */
67-700 . static void wxp.9.5(void)
67-701 . {
67-702 .
67-703 . if (A > B)
67-704 . {
67-705 . A = B + C;
67-706 . D = E + F;
67-707 . }
67-708 .
67-709 .
67-710 . if (A gt B)
67-711 . {
67-712 . A = B + C;
67-713 . D = E + F;
67-714 . }
67-715 .
67-716 . A = B+C;
67-717 .
67-718 . switch (wxp stuff)
67-719 . {
67-720 . case one:
67-721 . {
67-722 . run_this;
67-723 . break;
67-724 . }
67-725 . case two:
67-726 . {
67-727 . run_this;
67-728 . break;
67-729 . }
67-730 . default:
67-731 . {
67-732 . SwError;
67-733 . }
67-734 . }
67-735 .
67-736 . A = B-C;
67-737 . A = B-C;
67-738 . A = B*C;
67-739 . A = B-C;
67-740 . A = B+C;
67-741 . A = B*C;
67-742 . A = B*C;
67-743 . /* LE SV TOC-3153 this is a wxp-09.5.12 req to call isr*/
67-744 .
67-745 . if (A ne B)
67-746 . {
67-747 . A = B + C;
67-748 . D = E + F;
67-749 . }
67-750 .
67-751 . /* LE SV TOC-3154 this is a wxp-09.5.13 req to inhibit*/
67-752 . A = B+C;
67-753 . A = B-C;
67-754 .
67-755 . if (A < B)
67-756 . {
67-757 . A = B + C;
67-758 . D = E + F;
67-759 . }
67-760 .
67-761 . A = B*C;
67-762 . A = B*C;
67-763 .
67-764 . if (A > B)
67-765 . {
67-766 . A = B + C;
67-767 . D = E + F;
67-768 . }
67-769 .
67-770 . A = B*C;
67-771 . A = B-C;
67-772 .
67-773 . switch (wxp stuff)
67-774 . {
67-775 . case one:
67-776 . {
67-777 . run_this;
67-778 . // missing break
67-779 . }
67-780 . case two:
67-781 . {
67-782 . run_this;
67-783 . break;
67-784 . }
67-785 . default:
67-786 . {
67-787 . SwError;
67-788 . }
67-789 . }
67-790 .
67-791 . A = B-C;
67-792 . A = B*C;
67-793 .
67-794 . if (A eq B)
67-795 . {
67-796 . A = B + C;
67-797 . D = E + F;
67-798 . }
67-799 .
67-800 . A = B*C;
67-801 . A = B-C;
67-802 . A = B*C;
67-803 . A = B*C;
67-804 . A = B+C;
67-805 . A = 0x0009;
67-806 . A = B/C;
67-807 .
67-808 . if (A == B)
67-809 . {
67-810 . A = B + C;
67-811 . D = E + F;
67-812 . }
67-813 .
67-814 . A = B+C;
67-815 . A = B/C;
67-816 . A = B+C;
67-817 .
67-818 . if (A > B)
67-819 . {
67-820 . A = B + C;
67-821 . D = E + F;
67-822 . }
67-823 .
67-824 . A = B/C;
67-825 .
67-826 . if (A le B)
67-827 . {
67-828 . A = B + C;
67-829 . D = E + F;
67-830 . }
67-831 .
67-832 . A = B-C;
67-833 .
67-834 . if (A > = B)
67-835 . {
67-836 . A = B + C;
67-837 . D = E + F;
67-838 . }
67-839 .
67-840 .
67-841 . if (A > = B)
67-842 . {
67-843 . A = B + C;
67-844 . D = E + F;
67-845 . }
67-846 .
67-847 . A = B*C;
67-848 . A = B-C;
67-849 .
67-850 . if (A ne B)
67-851 . {
67-852 . A = B + C;
67-853 . D = E + F;
67-854 . }
67-855 .
67-856 . A = B+C;
67-857 . A = B*C;
67-858 . A = B+C;
67-859 . A = B-C;
67-860 .
67-861 . if (A < B)
67-862 . {
67-863 . A = B + C;
67-864 . D = E + F;
67-865 . }
67-866 .
67-867 . A = B/C;
67-868 . /* LE SV TOC-3155 this is a wxp-09.5.49 req to assign*/
67-869 . A = B/C;
67-870 . A = B*C;
67-871 .
67-872 . if (A > B)
67-873 . {
67-874 . A = B + C;
67-875 . D = E + F;
67-876 . }
67-877 .
67-878 .
67-879 . if (A le B)
67-880 . {
67-881 . A = B + C;
67-882 . D = E + F;
67-883 . }
67-884 .
67-885 . A = B+C;
67-886 . A = B*C;
67-887 . A = B-C;
67-888 . A = 0x0002;
67-889 . A = B+C;
67-890 .
67-891 . if (A ne B)
67-892 . {
67-893 . A = B + C;
67-894 . D = E + F;
67-895 . }
67-896 .
67-897 . // max LOC 57
67-898 .
67-899 . }
67-900 .
67-901 .
67-902 . /*
67-903 . -----------------------------------------------------------------------------
67-904 . --| NAME: wxp.9.6
67-905 . --|
67-906 . --| ABSTRACT:
67-907 . --| This function does wxp stuff.
67-908 . --|
67-909 . --| RETURNS:
67-910 . --| NONE.
67-911 . --|
67-912 . ----------------------------------------------------------------------------
67-913 . */
67-914 . static void wxp.9.6(void)
67-915 . {
67-916 .
67-917 . if (A == B)
67-918 . {
67-919 . A = B + C;
67-920 . D = E + F;
67-921 . }
67-922 .
67-923 .
67-924 . if (A == B)
67-925 . {
67-926 . A = B + C;
67-927 . D = E + F;
67-928 . }
67-929 .
67-930 . A = B+C;
67-931 .
67-932 . if (A > B)
67-933 . {
67-934 . A = B + C;
67-935 . D = E + F;
67-936 . }
67-937 .
67-938 .
67-939 . if (A le B)
67-940 . {
67-941 . A = B + C;
67-942 . D = E + F;
67-943 . }
67-944 .
67-945 . A = B*C;
67-946 .
67-947 . if (A lt B)
67-948 . {
67-949 . A = B + C;
67-950 . D = E + F;
67-951 . }
67-952 .
67-953 . A = B+C;
67-954 . A = B/C;
67-955 . A = B/C;
67-956 .
67-957 . if (A > B)
67-958 . {
67-959 . A = B + C;
67-960 . D = E + F;
67-961 . }
67-962 .
67-963 . A = B/C;
67-964 .
67-965 . switch (wxp stuff)
67-966 . {
67-967 . case one:
67-968 . {
67-969 . run_this;
67-970 . // missing break
67-971 . }
67-972 . case two:
67-973 . {
67-974 . run_this;
67-975 . break;
67-976 . }
67-977 . default:
67-978 . {
67-979 . SwError;
67-980 . }
67-981 . }
67-982 .
67-983 .
67-984 . if (A eq B)
67-985 . {
67-986 . A = B + C;
67-987 . D = E + F;
67-988 . }
67-989 .
67-990 . A = B*C;
67-991 . A = B+C;
67-992 .
67-993 . switch (wxp stuff)
67-994 . {
67-995 . case one:
67-996 . {
67-997 . run_this;
67-998 . break;
67-999 . }
67-1000 . case two:
67-1001 . {
67-1002 . run_this;
67-1003 . break;
67-1004 . }
67-1005 . default:
67-1006 . {
67-1007 . SwError;
67-1008 . }
67-1009 . }
67-1010 .
67-1011 .
67-1012 . if (A ne B)
67-1013 . {
67-1014 . A = B + C;
67-1015 . D = E + F;
67-1016 . }
67-1017 .
67-1018 .
67-1019 . switch (wxp stuff)
67-1020 . {
67-1021 . case one:
67-1022 . {
67-1023 . run_this;
67-1024 . break;
67-1025 . }
67-1026 . case two:
67-1027 . {
67-1028 . run_this;
67-1029 . break;
67-1030 . }
67-1031 . default:
67-1032 . {
67-1033 . SwError;
67-1034 . }
67-1035 . }
67-1036 .
67-1037 . A = B*C;
67-1038 . A = B/C;
67-1039 . A = B-C;
67-1040 . A = B+C;
67-1041 . A = B*C;
67-1042 . A = B/C;
67-1043 . // max LOC 24
67-1044 .
67-1045 . }
67-1046 .
67 67 Result: result/source/ft-app/ft-app-B1.1/wxp/wxp-09.c
done
12/01/2003 16:31:49 start
12/01/2003 16:32:45 end