75 75 Source: source/ft-app/ft-app-B1.0/log/log-16.c
75-0 . /*
75-1 . ----------------------------------------------------------------------------
75-2 . --| BEGIN PROLOGUE
75-3 . --|
75-4 . --| CLASSIFICATION: UNCLASSIFIED
75-5 . --|
75-6 . --| FILE NAME: log-16.c
75-7 . --|
75-8 . --| ABSTRACT:
75-9 . --| This file contains the 2 functions that do file log stuff.
75-10 . --|
75-11 . --| HISTORY:
75-12 . --| CCCQ_NAME:
75-13 . --| CCCQ_VER:
75-14 . --|
75-15 . --| END PROLOGUE
75-16 . ----------------------------------------------------------------------------
75-17 . */
75-18 .
75-19 . #define B;
75-20 . char D;
75-21 . #include B;
75-22 . #define A;
75-23 . #include C;
75-24 . #include D;
75-25 . #include B;
75-26 . #include B;
75-27 .
75-28 .
75-29 .
75-30 . /*
75-31 . -----------------------------------------------------------------------------
75-32 . --| NAME: log.16.1
75-33 . --|
75-34 . --| ABSTRACT:
75-35 . --| This function does log stuff.
75-36 . --|
75-37 . --| RETURNS:
75-38 . --| NONE.
75-39 . --|
75-40 . ----------------------------------------------------------------------------
75-41 . */
75-42 . static void log.16.1(void)
75-43 . {
75-44 .
75-45 . if (A != B)
75-46 . {
75-47 . A = B + C;
75-48 . D = E + F;
75-49 . }
75-50 .
75-51 .
75-52 . if (A < = B)
75-53 . {
75-54 . A = B + C;
75-55 . D = E + F;
75-56 . }
75-57 .
75-58 . A = B-C;
75-59 . A = B-C;
75-60 .
75-61 . if (A eq B)
75-62 . {
75-63 . A = B + C;
75-64 . D = E + F;
75-65 . }
75-66 .
75-67 . A = B*C;
75-68 .
75-69 . if (A le B)
75-70 . {
75-71 . A = B + C;
75-72 . D = E + F;
75-73 . }
75-74 .
75-75 . A = B+C;
75-76 .
75-77 . switch (log stuff)
75-78 . {
75-79 . case one:
75-80 . {
75-81 . run_this;
75-82 . break;
75-83 . }
75-84 . case two:
75-85 . {
75-86 . run_this;
75-87 . break;
75-88 . }
75-89 . default:
75-90 . {
75-91 . SwError;
75-92 . }
75-93 . }
75-94 .
75-95 . A = B-C;
75-96 . A = B*C;
75-97 . A = B+C;
75-98 . A = B/C;
75-99 .
75-100 . switch (log stuff)
75-101 . {
75-102 . case one:
75-103 . {
75-104 . run_this;
75-105 . break;
75-106 . }
75-107 . case two:
75-108 . {
75-109 . run_this;
75-110 . break;
75-111 . }
75-112 . default:
75-113 . {
75-114 . SwError;
75-115 . }
75-116 . }
75-117 .
75-118 .
75-119 . if (A > B)
75-120 . {
75-121 . A = B + C;
75-122 . D = E + F;
75-123 . }
75-124 .
75-125 . A = B*C;
75-126 . A = B*C;
75-127 . A = B+C;
75-128 . A = B/C;
75-129 . A = B-C;
75-130 .
75-131 . if (A eq B)
75-132 . {
75-133 . A = B + C;
75-134 . D = E + F;
75-135 . }
75-136 .
75-137 . A = B*C;
75-138 . A = B-C;
75-139 . A = B*C;
75-140 . A = B-C;
75-141 .
75-142 . if (A ne B)
75-143 . {
75-144 . A = B + C;
75-145 . D = E + F;
75-146 . }
75-147 .
75-148 . A = B/C;
75-149 . A = B/C;
75-150 . /* LE SV TOC-2122 this is a log-16.1.29 req to validate*/
75-151 . A = B-C;
75-152 . A = B-C;
75-153 . // max LOC 30
75-154 .
75-155 . }
75-156 .
75-157 .
75-158 . /*
75-159 . -----------------------------------------------------------------------------
75-160 . --| NAME: log.16.2
75-161 . --|
75-162 . --| ABSTRACT:
75-163 . --| This function does log stuff.
75-164 . --|
75-165 . --| RETURNS:
75-166 . --| NONE.
75-167 . --|
75-168 . ----------------------------------------------------------------------------
75-169 . */
75-170 . static void log.16.2(void)
75-171 . {
75-172 . /* LE SV TOC-2123 this is a log-16.2.1 req to halt*/
75-173 . A = B+C;
75-174 . A = B-C;
75-175 .
75-176 . if (A eq B)
75-177 . {
75-178 . A = B + C;
75-179 . D = E + F;
75-180 . }
75-181 .
75-182 .
75-183 . if (A != B)
75-184 . {
75-185 . A = B + C;
75-186 . D = E + F;
75-187 . }
75-188 .
75-189 . A = B*C;
75-190 .
75-191 . if (A gt B)
75-192 . {
75-193 . A = B + C;
75-194 . D = E + F;
75-195 . }
75-196 .
75-197 . /* LE SV TOC-2124 this is a log-16.2.7 req to validate*/
75-198 .
75-199 . if (A == B)
75-200 . {
75-201 . A = B + C;
75-202 . D = E + F;
75-203 . }
75-204 .
75-205 .
75-206 . if (A < B)
75-207 . {
75-208 . A = B + C;
75-209 . D = E + F;
75-210 . }
75-211 .
75-212 .
75-213 . if (A < = B)
75-214 . {
75-215 . A = B + C;
75-216 . D = E + F;
75-217 . }
75-218 .
75-219 . A = B*C;
75-220 . A = B-C;
75-221 .
75-222 . if (A lt B)
75-223 . {
75-224 . A = B + C;
75-225 . D = E + F;
75-226 . }
75-227 .
75-228 .
75-229 . switch (log stuff)
75-230 . {
75-231 . case one:
75-232 . {
75-233 . run_this;
75-234 . break;
75-235 . }
75-236 . case two:
75-237 . {
75-238 . run_this;
75-239 . break;
75-240 . }
75-241 . default:
75-242 . {
75-243 . SwError;
75-244 . }
75-245 . }
75-246 .
75-247 . A = B+C;
75-248 . A = B+C;
75-249 . A = B-C;
75-250 .
75-251 . if (A > = B)
75-252 . {
75-253 . A = B + C;
75-254 . D = E + F;
75-255 . }
75-256 .
75-257 . A = B-C;
75-258 . A = B*C;
75-259 . A = B/C;
75-260 .
75-261 . if (A lt B)
75-262 . {
75-263 . A = B + C;
75-264 . D = E + F;
75-265 . }
75-266 .
75-267 . A = B+C;
75-268 . A = B/C;
75-269 . A = B-C;
75-270 .
75-271 . if (A le B)
75-272 . {
75-273 . A = B + C;
75-274 . D = E + F;
75-275 . }
75-276 .
75-277 . A = B*C;
75-278 . A = B+C;
75-279 .
75-280 . if (A != B)
75-281 . {
75-282 . A = B + C;
75-283 . D = E + F;
75-284 . }
75-285 .
75-286 . A = B-C;
75-287 . A = B-C;
75-288 . A = 0x0002;
75-289 . A = B*C;
75-290 .
75-291 . if (A != B)
75-292 . {
75-293 . A = B + C;
75-294 . D = E + F;
75-295 . }
75-296 .
75-297 . A = B-C;
75-298 . A = B/C;
75-299 .
75-300 . switch (log stuff)
75-301 . {
75-302 . case one:
75-303 . {
75-304 . run_this;
75-305 . break;
75-306 . }
75-307 . case two:
75-308 . {
75-309 . run_this;
75-310 . break;
75-311 . }
75-312 . default:
75-313 . {
75-314 . SwError;
75-315 . }
75-316 . }
75-317 .
75-318 .
75-319 . if (A le B)
75-320 . {
75-321 . A = B + C;
75-322 . D = E + F;
75-323 . }
75-324 .
75-325 .
75-326 . if (A le B)
75-327 . {
75-328 . A = B + C;
75-329 . D = E + F;
75-330 . }
75-331 .
75-332 . A = B/C;
75-333 . A = B*C;
75-334 . A = B+C;
75-335 . A = B+C;
75-336 .
75-337 . if (A eq B)
75-338 . {
75-339 . A = B + C;
75-340 . D = E + F;
75-341 . }
75-342 .
75-343 . A = B/C;
75-344 . // max LOC 43
75-345 .
75-346 . }
75-347 .
75 75 Result: result/source/ft-app/ft-app-B1.0/log/log-16.c
76 76 Source: source/ft-app/ft-app-B1.0/log/log-17.c
76-0 . /*
76-1 . ----------------------------------------------------------------------------
76-2 . --| BEGIN PROLOGUE
76-3 . --|
76-4 . --| CLASSIFICATION: UNCLASSIFIED
76-5 . --|
76-6 . --| FILE NAME: log-17.c
76-7 . --|
76-8 . --| ABSTRACT:
76-9 . --| This file contains the 6 functions that do file log stuff.
76-10 . --|
76-11 . --| HISTORY:
76-12 . --| CCCQ_NAME:
76-13 . --| CCCQ_VER:
76-14 . --|
76-15 . --| END PROLOGUE
76-16 . ----------------------------------------------------------------------------
76-17 . */
76-18 .
76-19 . #include C;
76-20 . #define A;
76-21 . int A;
76-22 . #define C;
76-23 . #include A;
76-24 . #define A;
76-25 . int A;
76-26 . #define B;
76-27 . #define C;
76-28 .
76-29 .
76-30 .
76-31 . /*
76-32 . -----------------------------------------------------------------------------
76-33 . --| NAME: log.17.1
76-34 . --|
76-35 . --| ABSTRACT:
76-36 . --| This function does log stuff.
76-37 . --|
76-38 . --| RETURNS:
76-39 . --| NONE.
76-40 . --|
76-41 . ----------------------------------------------------------------------------
76-42 . */
76-43 . static void log.17.1(void)
76-44 . {
76-45 .
76-46 . if (A != B)
76-47 . {
76-48 . A = B + C;
76-49 . D = E + F;
76-50 . }
76-51 .
76-52 . A = B/C;
76-53 . A = B/C;
76-54 .
76-55 . if (A gt B)
76-56 . {
76-57 . A = B + C;
76-58 . D = E + F;
76-59 . }
76-60 .
76-61 . /* LE SV TOC-2125 this is a log-17.1.5 req to reject*/
76-62 . A = B-C;
76-63 .
76-64 . if (A > = B)
76-65 . {
76-66 . A = B + C;
76-67 . D = E + F;
76-68 . }
76-69 .
76-70 .
76-71 . if (A == B)
76-72 . {
76-73 . A = B + C;
76-74 . D = E + F;
76-75 . }
76-76 .
76-77 . A = 0x0004;
76-78 .
76-79 . switch (log stuff)
76-80 . {
76-81 . case one:
76-82 . {
76-83 . run_this;
76-84 . break;
76-85 . }
76-86 . case two:
76-87 . {
76-88 . run_this;
76-89 . break;
76-90 . }
76-91 . default:
76-92 . {
76-93 . SwError;
76-94 . }
76-95 . }
76-96 .
76-97 . A = B+C;
76-98 . A = B/C;
76-99 . A = B/C;
76-100 . A = B/C;
76-101 .
76-102 . if (A ge B)
76-103 . {
76-104 . A = B + C;
76-105 . D = E + F;
76-106 . }
76-107 .
76-108 . A = B/C;
76-109 . A = B-C;
76-110 . A = B+C;
76-111 . A = B-C;
76-112 .
76-113 . if (A > B)
76-114 . {
76-115 . A = B + C;
76-116 . D = E + F;
76-117 . }
76-118 .
76-119 . A = B-C;
76-120 . A = B/C;
76-121 .
76-122 . switch (log stuff)
76-123 . {
76-124 . case one:
76-125 . {
76-126 . run_this;
76-127 . break;
76-128 . }
76-129 . case two:
76-130 . {
76-131 . run_this;
76-132 . break;
76-133 . }
76-134 . // missing default
76-135 . }
76-136 .
76-137 . A = B-C;
76-138 . A = B-C;
76-139 . A = 0x0006;
76-140 .
76-141 . if (A le B)
76-142 . {
76-143 . A = B + C;
76-144 . D = E + F;
76-145 . }
76-146 .
76-147 . /* LE SV TOC-2126 this is a log-17.1.24 req to recover*/
76-148 . A = B+C;
76-149 . A = B/C;
76-150 . /* LE SV TOC-2127 this is a log-17.1.26 req to increment*/
76-151 . A = B*C;
76-152 . A = B+C;
76-153 .
76-154 . if (A > = B)
76-155 . {
76-156 . A = B + C;
76-157 . D = E + F;
76-158 . }
76-159 .
76-160 . A = B/C;
76-161 .
76-162 . if (A > = B)
76-163 . {
76-164 . A = B + C;
76-165 . D = E + F;
76-166 . }
76-167 .
76-168 .
76-169 . if (A lt B)
76-170 . {
76-171 . A = B + C;
76-172 . D = E + F;
76-173 . }
76-174 .
76-175 .
76-176 . if (A == B)
76-177 . {
76-178 . A = B + C;
76-179 . D = E + F;
76-180 . }
76-181 .
76-182 . /* LE SV TOC-2128 this is a log-17.1.33 req to transform*/
76-183 .
76-184 . if (A gt B)
76-185 . {
76-186 . A = B + C;
76-187 . D = E + F;
76-188 . }
76-189 .
76-190 .
76-191 . if (A > B)
76-192 . {
76-193 . A = B + C;
76-194 . D = E + F;
76-195 . }
76-196 .
76-197 . A = B/C;
76-198 . A = B+C;
76-199 . A = B*C;
76-200 . A = B/C;
76-201 .
76-202 . if (A > = B)
76-203 . {
76-204 . A = B + C;
76-205 . D = E + F;
76-206 . }
76-207 .
76-208 .
76-209 . if (A ne B)
76-210 . {
76-211 . A = B + C;
76-212 . D = E + F;
76-213 . }
76-214 .
76-215 . A = B/C;
76-216 . A = B*C;
76-217 . A = B/C;
76-218 .
76-219 . if (A ge B)
76-220 . {
76-221 . A = B + C;
76-222 . D = E + F;
76-223 . }
76-224 .
76-225 .
76-226 . if (A > B)
76-227 . {
76-228 . A = B + C;
76-229 . D = E + F;
76-230 . }
76-231 .
76-232 .
76-233 . if (A gt B)
76-234 . {
76-235 . A = B + C;
76-236 . D = E + F;
76-237 . }
76-238 .
76-239 . A = B*C;
76-240 .
76-241 . if (A ne B)
76-242 . {
76-243 . A = B + C;
76-244 . D = E + F;
76-245 . }
76-246 .
76-247 .
76-248 . if (A > B)
76-249 . {
76-250 . A = B + C;
76-251 . D = E + F;
76-252 . }
76-253 .
76-254 . A = B-C;
76-255 . A = B*C;
76-256 . A = B-C;
76-257 . A = B+C;
76-258 . /* LE SV TOC-2129 this is a log-17.1.54 req to set Real Time Clock*/
76-259 . A = B-C;
76-260 . A = B-C;
76-261 . A = B-C;
76-262 . A = B+C;
76-263 .
76-264 . if (A gt B)
76-265 . {
76-266 . A = B + C;
76-267 . D = E + F;
76-268 . }
76-269 .
76-270 . A = (long)B + C;
76-271 . A = B-C;
76-272 .
76-273 . switch (log stuff)
76-274 . {
76-275 . case one:
76-276 . {
76-277 . run_this;
76-278 . break;
76-279 . }
76-280 . case two:
76-281 . {
76-282 . run_this;
76-283 . break;
76-284 . }
76-285 . default:
76-286 . {
76-287 . SwError;
76-288 . }
76-289 . }
76-290 .
76-291 .
76-292 . if (A < B)
76-293 . {
76-294 . A = B + C;
76-295 . D = E + F;
76-296 . }
76-297 .
76-298 . free(FreePtr);
76-299 . A = B-C;
76-300 .
76-301 . if (A > B)
76-302 . {
76-303 . A = B + C;
76-304 . D = E + F;
76-305 . }
76-306 .
76-307 . A = B-C;
76-308 .
76-309 . if (A eq B)
76-310 . {
76-311 . A = B + C;
76-312 . D = E + F;
76-313 . }
76-314 .
76-315 . A = B/C;
76-316 . A = B+C;
76-317 .
76-318 . if (A le B)
76-319 . {
76-320 . A = B + C;
76-321 . D = E + F;
76-322 . }
76-323 .
76-324 .
76-325 . if (A > B)
76-326 . {
76-327 . A = B + C;
76-328 . D = E + F;
76-329 . }
76-330 .
76-331 .
76-332 . if (A == B)
76-333 . {
76-334 . A = B + C;
76-335 . D = E + F;
76-336 . }
76-337 .
76-338 .
76-339 . if (A le B)
76-340 . {
76-341 . A = B + C;
76-342 . D = E + F;
76-343 . }
76-344 .
76-345 .
76-346 . if (A eq B)
76-347 . {
76-348 . A = B + C;
76-349 . D = E + F;
76-350 . }
76-351 .
76-352 . // max LOC 72
76-353 .
76-354 . }
76-355 .
76-356 .
76-357 . /*
76-358 . -----------------------------------------------------------------------------
76-359 . --| NAME: log.17.2
76-360 . --|
76-361 . --| ABSTRACT:
76-362 . --| This function does log stuff.
76-363 . --|
76-364 . --| RETURNS:
76-365 . --| NONE.
76-366 . --|
76-367 . ----------------------------------------------------------------------------
76-368 . */
76-369 . static void log.17.2(void)
76-370 . {
76-371 . /* LE SV TOC-2130 this is a log-17.2.1 req to compare*/
76-372 .
76-373 . if (A gt B)
76-374 . {
76-375 . A = B + C;
76-376 . D = E + F;
76-377 . }
76-378 .
76-379 .
76-380 . if (A lt B)
76-381 . {
76-382 . A = B + C;
76-383 . D = E + F;
76-384 . }
76-385 .
76-386 .
76-387 . if (A < B)
76-388 . {
76-389 . A = B + C;
76-390 . D = E + F;
76-391 . }
76-392 .
76-393 . A = B/C;
76-394 . A = B*C;
76-395 . A = B-C;
76-396 .
76-397 . if (A ne B)
76-398 . {
76-399 . A = B + C;
76-400 . D = E + F;
76-401 . }
76-402 .
76-403 . A = B+C;
76-404 . A = B-C;
76-405 . A = B+C;
76-406 .
76-407 . /* dead_code = B + C;
76-408 . dead_code = D + E;
76-409 . dead_code = F + G; */
76-410 .
76-411 . A = B-C;
76-412 . // max LOC 11
76-413 .
76-414 . }
76-415 .
76-416 .
76-417 . /*
76-418 . -----------------------------------------------------------------------------
76-419 . --| NAME: log.17.3
76-420 . --|
76-421 . --| ABSTRACT:
76-422 . --| This function does log stuff.
76-423 . --|
76-424 . --| RETURNS:
76-425 . --| NONE.
76-426 . --|
76-427 . ----------------------------------------------------------------------------
76-428 . */
76-429 . static void log.17.3(void)
76-430 . {
76-431 . A = 0x0004;
76-432 . A = B/C;
76-433 . /* LE SV TOC-2131 this is a log-17.3.2 req to translate*/
76-434 . A = B+C;
76-435 . A = B/C;
76-436 . A = B+C;
76-437 . A = B*C;
76-438 . A = B/C;
76-439 . /* LE SV TOC-2132 this is a log-17.3.7 req to reject*/
76-440 . A = B*C;
76-441 . A = B+C;
76-442 .
76-443 . switch (log stuff)
76-444 . {
76-445 . case one:
76-446 . {
76-447 . run_this;
76-448 . // missing break
76-449 . }
76-450 . case two:
76-451 . {
76-452 . run_this;
76-453 . break;
76-454 . }
76-455 . default:
76-456 . {
76-457 . SwError;
76-458 . }
76-459 . }
76-460 .
76-461 . A = B-C;
76-462 . A = B+C;
76-463 . A = B-C;
76-464 .
76-465 . if (A ne B)
76-466 . {
76-467 . A = B + C;
76-468 . D = E + F;
76-469 . }
76-470 .
76-471 .
76-472 . if (A == B)
76-473 . {
76-474 . A = B + C;
76-475 . D = E + F;
76-476 . }
76-477 .
76-478 . A = B+C;
76-479 . A = B-C;
76-480 . A = B-C;
76-481 .
76-482 . if (A le B)
76-483 . {
76-484 . A = B + C;
76-485 . D = E + F;
76-486 . }
76-487 .
76-488 . /* LE SV TOC-2133 this is a log-17.3.18 req to recover*/
76-489 . A = B/C;
76-490 . A = B+C;
76-491 .
76-492 . if (A lt B)
76-493 . {
76-494 . A = B + C;
76-495 . D = E + F;
76-496 . }
76-497 .
76-498 . A = B*C;
76-499 . A = B/C;
76-500 . A = B*C;
76-501 .
76-502 . if (A < B)
76-503 . {
76-504 . A = B + C;
76-505 . D = E + F;
76-506 . }
76-507 .
76-508 . A = B*C;
76-509 . do forever;
76-510 . A = B/C;
76-511 . A = B+C;
76-512 . A = 0x0006;
76-513 . A = B-C;
76-514 . A = B/C;
76-515 . /* LE SV TOC-2134 this is a log-17.3.30 req to record*/
76-516 .
76-517 . switch (log stuff)
76-518 . {
76-519 . case one:
76-520 . {
76-521 . run_this;
76-522 . break;
76-523 . }
76-524 . case two:
76-525 . {
76-526 . run_this;
76-527 . break;
76-528 . }
76-529 . default:
76-530 . {
76-531 . SwError;
76-532 . }
76-533 . }
76-534 .
76-535 . A = B-C;
76-536 . A = B*C;
76-537 .
76-538 . #ifdef LAZY
76-539 . // this is not nice
76-540 . A = B + C;
76-541 . A = B + C;
76-542 . #endif
76-543 .
76-544 .
76-545 . if (A ne B)
76-546 . {
76-547 . A = B + C;
76-548 . D = E + F;
76-549 . }
76-550 .
76-551 . A = B/C;
76-552 . A = B+C;
76-553 .
76-554 . if (A ne B)
76-555 . {
76-556 . A = B + C;
76-557 . D = E + F;
76-558 . }
76-559 .
76-560 . // max LOC 36
76-561 .
76-562 . }
76-563 .
76-564 .
76-565 . /*
76-566 . -----------------------------------------------------------------------------
76-567 . --| NAME: log.17.4
76-568 . --|
76-569 . --| ABSTRACT:
76-570 . --| This function does log stuff.
76-571 . --|
76-572 . --| RETURNS:
76-573 . --| NONE.
76-574 . --|
76-575 . ----------------------------------------------------------------------------
76-576 . */
76-577 . static void log.17.4(void)
76-578 . {
76-579 .
76-580 . if (A le B)
76-581 . {
76-582 . A = B + C;
76-583 . D = E + F;
76-584 . }
76-585 .
76-586 . A = B*C;
76-587 . A = B/C;
76-588 . A = B/C;
76-589 . A = B*C;
76-590 . A = B*C;
76-591 . A = B*C;
76-592 .
76-593 . if (A lt B)
76-594 . {
76-595 . A = B + C;
76-596 . D = E + F;
76-597 . }
76-598 .
76-599 .
76-600 . switch (log stuff)
76-601 . {
76-602 . case one:
76-603 . {
76-604 . run_this;
76-605 . break;
76-606 . }
76-607 . case two:
76-608 . {
76-609 . run_this;
76-610 . break;
76-611 . }
76-612 . default:
76-613 . {
76-614 . SwError;
76-615 . }
76-616 . }
76-617 .
76-618 .
76-619 . if (A != B)
76-620 . {
76-621 . A = B + C;
76-622 . D = E + F;
76-623 . }
76-624 .
76-625 . A = B*C;
76-626 . A = B-C;
76-627 . /* LE SV TOC-2135 this is a log-17.4.13 req to validate*/
76-628 . A = B*C;
76-629 . A = B/C;
76-630 .
76-631 . if (A == B)
76-632 . {
76-633 . A = B + C;
76-634 . D = E + F;
76-635 . }
76-636 .
76-637 . // max LOC 15
76-638 .
76-639 . }
76-640 .
76-641 .
76-642 . /*
76-643 . -----------------------------------------------------------------------------
76-644 . --| NAME: log.17.5
76-645 . --|
76-646 . --| ABSTRACT:
76-647 . --| This function does log stuff.
76-648 . --|
76-649 . --| RETURNS:
76-650 . --| NONE.
76-651 . --|
76-652 . ----------------------------------------------------------------------------
76-653 . */
76-654 . static void log.17.5(void)
76-655 . {
76-656 . A = B-C;
76-657 . A = B/C;
76-658 .
76-659 . if (A > = B)
76-660 . {
76-661 . A = B + C;
76-662 . D = E + F;
76-663 . }
76-664 .
76-665 . A = B-C;
76-666 . A = B-C;
76-667 . A = B-C;
76-668 . A = B*C;
76-669 .
76-670 . switch (log stuff)
76-671 . {
76-672 . case one:
76-673 . {
76-674 . run_this;
76-675 . break;
76-676 . }
76-677 . case two:
76-678 . {
76-679 . run_this;
76-680 . break;
76-681 . }
76-682 . default:
76-683 . {
76-684 . SwError;
76-685 . }
76-686 . }
76-687 .
76-688 . A = (int)B + C;
76-689 . A = B+C;
76-690 . /* LE SV TOC-2136 this is a log-17.5.10 req to update*/
76-691 . A = B/C;
76-692 . A = B+C;
76-693 . A = B/C;
76-694 . A = B-C;
76-695 . A = B-C;
76-696 . A = B-C;
76-697 . A = B-C;
76-698 . A = B+C;
76-699 . A = B/C;
76-700 . A = B-C;
76-701 . A = B-C;
76-702 . A = (long)B + C;
76-703 . A = B+C;
76-704 . A = B-C;
76-705 . A = B-C;
76-706 . A = B+C;
76-707 . A = B/C;
76-708 . A = B/C;
76-709 . // ??? go see ws
76-710 .
76-711 . if (A != B)
76-712 . {
76-713 . A = B + C;
76-714 . D = E + F;
76-715 . }
76-716 .
76-717 . A = B/C;
76-718 .
76-719 . if (A < B)
76-720 . {
76-721 . A = B + C;
76-722 . D = E + F;
76-723 . }
76-724 .
76-725 .
76-726 . if (A eq B)
76-727 . {
76-728 . A = B + C;
76-729 . D = E + F;
76-730 . }
76-731 .
76-732 .
76-733 . if (A < B)
76-734 . {
76-735 . A = B + C;
76-736 . D = E + F;
76-737 . }
76-738 .
76-739 .
76-740 . if (A == B)
76-741 . {
76-742 . A = B + C;
76-743 . D = E + F;
76-744 . }
76-745 .
76-746 . A = B+C;
76-747 . A = B*C;
76-748 . A = B-C;
76-749 . A = B*C;
76-750 . A = B*C;
76-751 . A = B+C;
76-752 . A = B+C;
76-753 . A = B/C;
76-754 . A = B-C;
76-755 . A = B/C;
76-756 .
76-757 . if (A gt B)
76-758 . {
76-759 . A = B + C;
76-760 . D = E + F;
76-761 . }
76-762 .
76-763 .
76-764 . if (A < = B)
76-765 . {
76-766 . A = B + C;
76-767 . D = E + F;
76-768 . }
76-769 .
76-770 . A = B-C;
76-771 . A = B+C;
76-772 . do forever;
76-773 .
76-774 . if (A < = B)
76-775 . {
76-776 . A = B + C;
76-777 . D = E + F;
76-778 . }
76-779 .
76-780 . A = B-C;
76-781 . A = B/C;
76-782 .
76-783 . switch (log stuff)
76-784 . {
76-785 . case one:
76-786 . {
76-787 . run_this;
76-788 . break;
76-789 . }
76-790 . case two:
76-791 . {
76-792 . run_this;
76-793 . break;
76-794 . }
76-795 . default:
76-796 . {
76-797 . SwError;
76-798 . }
76-799 . }
76-800 .
76-801 . A = B+C;
76-802 . A = B/C;
76-803 . /* LE SV TOC-2137 this is a log-17.5.53 req to reject*/
76-804 . A = B+C;
76-805 . A = B*C;
76-806 . A = B*C;
76-807 . A = B-C;
76-808 . /* LE SV TOC-2138 this is a log-17.5.57 req to enable*/
76-809 . A = B-C;
76-810 . A = B-C;
76-811 .
76-812 . if (A > = B)
76-813 . {
76-814 . A = B + C;
76-815 . D = E + F;
76-816 . }
76-817 .
76-818 . A = B-C;
76-819 . /* LE SV TOC-2139 this is a log-17.5.61 req to check unix*/
76-820 . A = B/C;
76-821 . // max LOC 61
76-822 .
76-823 . }
76-824 .
76-825 .
76-826 . /*
76-827 . -----------------------------------------------------------------------------
76-828 . --| NAME: log.17.6
76-829 . --|
76-830 . --| ABSTRACT:
76-831 . --| This function does log stuff.
76-832 . --|
76-833 . --| RETURNS:
76-834 . --| NONE.
76-835 . --|
76-836 . ----------------------------------------------------------------------------
76-837 . */
76-838 . static void log.17.6(void)
76-839 . {
76-840 . A = 0x0004;
76-841 .
76-842 . if (A < = B)
76-843 . {
76-844 . A = B + C;
76-845 . D = E + F;
76-846 . }
76-847 .
76-848 . A = B-C;
76-849 . A = B*C;
76-850 . A = B/C;
76-851 .
76-852 . if (A < B)
76-853 . {
76-854 . A = B + C;
76-855 . D = E + F;
76-856 . }
76-857 .
76-858 . A = B-C;
76-859 .
76-860 . if (A eq B)
76-861 . {
76-862 . A = B + C;
76-863 . D = E + F;
76-864 . }
76-865 .
76-866 .
76-867 . if (A == B)
76-868 . {
76-869 . A = B + C;
76-870 . D = E + F;
76-871 . }
76-872 .
76-873 . A = B/C;
76-874 .
76-875 . if (A ge B)
76-876 . {
76-877 . A = B + C;
76-878 . D = E + F;
76-879 . }
76-880 .
76-881 . A = B/C;
76-882 . rcv_buffer = (U16 *) alloc(size+1);
76-883 . A = B+C;
76-884 .
76-885 . if (A < = B)
76-886 . {
76-887 . A = B + C;
76-888 . D = E + F;
76-889 . }
76-890 .
76-891 .
76-892 . if (A != B)
76-893 . {
76-894 . A = B + C;
76-895 . D = E + F;
76-896 . }
76-897 .
76-898 . A = B*C;
76-899 . A = B-C;
76-900 . A = B*C;
76-901 . A = B-C;
76-902 . /* LE SV TOC-2140 this is a log-17.6.19 req to increment*/
76-903 . A = B-C;
76-904 .
76-905 . if (A > = B)
76-906 . {
76-907 . A = B + C;
76-908 . D = E + F;
76-909 . }
76-910 .
76-911 . A = B-C;
76-912 . A = B-C;
76-913 . A = B*C;
76-914 .
76-915 . if (A le B)
76-916 . {
76-917 . A = B + C;
76-918 . D = E + F;
76-919 . }
76-920 .
76-921 . A = B*C;
76-922 . A = B+C;
76-923 . A = B*C;
76-924 . A = B/C;
76-925 .
76-926 . if (A != B)
76-927 . {
76-928 . A = B + C;
76-929 . D = E + F;
76-930 . }
76-931 .
76-932 .
76-933 . switch (log stuff)
76-934 . {
76-935 . case one:
76-936 . {
76-937 . run_this;
76-938 . break;
76-939 . }
76-940 . case two:
76-941 . {
76-942 . run_this;
76-943 . break;
76-944 . }
76-945 . default:
76-946 . {
76-947 . SwError;
76-948 . }
76-949 . }
76-950 .
76-951 . A = B/C;
76-952 . A = 0x0007;
76-953 .
76-954 . if (A < B)
76-955 . {
76-956 . A = B + C;
76-957 . D = E + F;
76-958 . }
76-959 .
76-960 .
76-961 . if (A == B)
76-962 . {
76-963 . A = B + C;
76-964 . D = E + F;
76-965 . }
76-966 .
76-967 .
76-968 . if (A < B)
76-969 . {
76-970 . A = B + C;
76-971 . D = E + F;
76-972 . }
76-973 .
76-974 . /* LE SV TOC-2141 this is a log-17.6.35 req to recover*/
76-975 . A = B-C;
76-976 . // TBD - what do I do now
76-977 . A = B*C;
76-978 . A = B+C;
76-979 .
76-980 . switch (log stuff)
76-981 . {
76-982 . case one:
76-983 . {
76-984 . run_this;
76-985 . break;
76-986 . }
76-987 . case two:
76-988 . {
76-989 . run_this;
76-990 . break;
76-991 . }
76-992 . default:
76-993 . {
76-994 . SwError;
76-995 . }
76-996 . }
76-997 .
76-998 . A = B+C;
76-999 . A = B-C;
76-1000 . A = 0x0004;
76-1001 . // (P) this is really improtant
76-1002 .
76-1003 . if (A == B)
76-1004 . {
76-1005 . A = B + C;
76-1006 . D = E + F;
76-1007 . }
76-1008 .
76-1009 .
76-1010 . if (A > B)
76-1011 . {
76-1012 . A = B + C;
76-1013 . D = E + F;
76-1014 . }
76-1015 .
76-1016 . A = B*C;
76-1017 . // TBD - what do I do now
76-1018 . A = B+C;
76-1019 . A = B/C;
76-1020 .
76-1021 . if (A ne B)
76-1022 . {
76-1023 . A = B + C;
76-1024 . D = E + F;
76-1025 . }
76-1026 .
76-1027 .
76-1028 . if (A ne B)
76-1029 . {
76-1030 . A = B + C;
76-1031 . D = E + F;
76-1032 . }
76-1033 .
76-1034 . A = B+C;
76-1035 .
76-1036 . if (A != B)
76-1037 . {
76-1038 . A = B + C;
76-1039 . D = E + F;
76-1040 . }
76-1041 .
76-1042 .
76-1043 . if (A > = B)
76-1044 . {
76-1045 . A = B + C;
76-1046 . D = E + F;
76-1047 . }
76-1048 .
76-1049 . A = B*C;
76-1050 . /* LE SV TOC-2142 this is a log-17.6.52 req to translate*/
76-1051 . A = B-C;
76-1052 . send_buffer = (U16 *) malloc(size+1);
76-1053 . A = B-C;
76-1054 . A = B-C;
76-1055 .
76-1056 . if (A ne B)
76-1057 . {
76-1058 . A = B + C;
76-1059 . D = E + F;
76-1060 . }
76-1061 .
76-1062 . // max LOC 55
76-1063 .
76-1064 . }
76-1065 .
76 76 Result: result/source/ft-app/ft-app-B1.0/log/log-17.c
77 77 Source: source/ft-app/ft-app-B1.0/log/log-18.c
77-0 . /*
77-1 . ----------------------------------------------------------------------------
77-2 . --| BEGIN PROLOGUE
77-3 . --|
77-4 . --| CLASSIFICATION: UNCLASSIFIED
77-5 . --|
77-6 . --| FILE NAME: log-18.c
77-7 . --|
77-8 . --| ABSTRACT:
77-9 . --| This file contains the 2 functions that do file log stuff.
77-10 . --|
77-11 . --| HISTORY:
77-12 . --| CCCQ_NAME:
77-13 . --| CCCQ_VER:
77-14 . --|
77-15 . --| END PROLOGUE
77-16 . ----------------------------------------------------------------------------
77-17 . */
77-18 .
77-19 . double C;
77-20 . #include D;
77-21 . #define B;
77-22 . char D;
77-23 . #include D;
77-24 .
77-25 .
77-26 .
77-27 . /*
77-28 . -----------------------------------------------------------------------------
77-29 . --| NAME: log.18.1
77-30 . --|
77-31 . --| ABSTRACT:
77-32 . --| This function does log stuff.
77-33 . --|
77-34 . --| RETURNS:
77-35 . --| NONE.
77-36 . --|
77-37 . ----------------------------------------------------------------------------
77-38 . */
77-39 . static void log.18.1(void)
77-40 . {
77-41 .
77-42 . if (A != B)
77-43 . {
77-44 . A = B + C;
77-45 . D = E + F;
77-46 . }
77-47 .
77-48 . A = B-C;
77-49 . A = B+C;
77-50 . A = B*C;
77-51 . A = B/C;
77-52 .
77-53 . if (veg)
77-54 . // missing curly brace
77-55 . variable = orange;
77-56 .
77-57 . A = B*C;
77-58 .
77-59 . if (A < B)
77-60 . {
77-61 . A = B + C;
77-62 . D = E + F;
77-63 . }
77-64 .
77-65 . // max LOC 7
77-66 .
77-67 . }
77-68 .
77-69 .
77-70 . /*
77-71 . -----------------------------------------------------------------------------
77-72 . --| NAME: log.18.2
77-73 . --|
77-74 . --| ABSTRACT:
77-75 . --| This function does log stuff.
77-76 . --|
77-77 . --| RETURNS:
77-78 . --| NONE.
77-79 . --|
77-80 . ----------------------------------------------------------------------------
77-81 . */
77-82 . static void log.18.2(void)
77-83 . {
77-84 . A = B*C;
77-85 . send_buffer = (U16 *) malloc(size+1);
77-86 . A = B*C;
77-87 . /* LE SV TOC-2143 this is a log-18.2.3 req to enable*/
77-88 . A = B*C;
77-89 . A = B/C;
77-90 .
77-91 . if (A eq B)
77-92 . {
77-93 . A = B + C;
77-94 . D = E + F;
77-95 . }
77-96 .
77-97 . A = B*C;
77-98 .
77-99 . if (A eq B)
77-100 . {
77-101 . A = B + C;
77-102 . D = E + F;
77-103 . }
77-104 .
77-105 . A = B-C;
77-106 . // max LOC 8
77-107 .
77-108 . }
77-109 .
77 77 Result: result/source/ft-app/ft-app-B1.0/log/log-18.c
78 78 Source: source/ft-app/ft-app-B1.0/log/log-19.c
78-0 . /*
78-1 . ----------------------------------------------------------------------------
78-2 . --| BEGIN PROLOGUE
78-3 . --|
78-4 . --| CLASSIFICATION: UNCLASSIFIED
78-5 . --|
78-6 . --| FILE NAME: log-19.c
78-7 . --|
78-8 . --| ABSTRACT:
78-9 . --| This file contains the 3 functions that do file log stuff.
78-10 . --|
78-11 . --| HISTORY:
78-12 . --| CCCQ_NAME:
78-13 . --| CCCQ_VER:
78-14 . --|
78-15 . --| END PROLOGUE
78-16 . ----------------------------------------------------------------------------
78-17 . */
78-18 .
78-19 . int A;
78-20 . #include D;
78-21 . int A;
78-22 . float B;
78-23 . #define C;
78-24 . int A;
78-25 .
78-26 .
78-27 .
78-28 . /*
78-29 . -----------------------------------------------------------------------------
78-30 . --| NAME: log.19.1
78-31 . --|
78-32 . --| ABSTRACT:
78-33 . --| This function does log stuff.
78-34 . --|
78-35 . --| RETURNS:
78-36 . --| NONE.
78-37 . --|
78-38 . ----------------------------------------------------------------------------
78-39 . */
78-40 . static void log.19.1(void)
78-41 . {
78-42 .
78-43 . if (A lt B)
78-44 . {
78-45 . A = B + C;
78-46 . D = E + F;
78-47 . }
78-48 .
78-49 . A = B*C;
78-50 . A = B/C;
78-51 . A = B*C;
78-52 . A = B-C;
78-53 . /* LE SV TOC-2144 this is a log-19.1.6 req to translate*/
78-54 .
78-55 . if (A le B)
78-56 . {
78-57 . A = B + C;
78-58 . D = E + F;
78-59 . }
78-60 .
78-61 . A = B+C;
78-62 . A = B/C;
78-63 . A = B/C;
78-64 . A = B/C;
78-65 . A = B*C;
78-66 . A = B+C;
78-67 . A = B-C;
78-68 . A = B*C;
78-69 . A = B*C;
78-70 . A = B+C;
78-71 .
78-72 . if (A < = B)
78-73 . {
78-74 . A = B + C;
78-75 . D = E + F;
78-76 . }
78-77 .
78-78 . A = B-C;
78-79 .
78-80 . if (A ge B)
78-81 . {
78-82 . A = B + C;
78-83 . D = E + F;
78-84 . }
78-85 .
78-86 . A = B+C;
78-87 . A = B-C;
78-88 .
78-89 . if (A == B)
78-90 . {
78-91 . A = B + C;
78-92 . D = E + F;
78-93 . }
78-94 .
78-95 . A = 0x0004;
78-96 .
78-97 . if (A > = B)
78-98 . {
78-99 . A = B + C;
78-100 . D = E + F;
78-101 . }
78-102 .
78-103 .
78-104 . if (A < = B)
78-105 . {
78-106 . A = B + C;
78-107 . D = E + F;
78-108 . }
78-109 .
78-110 . A = B-C;
78-111 . A = B+C;
78-112 . A = B-C;
78-113 . A = B/C;
78-114 . A = B+C;
78-115 .
78-116 . switch (log stuff)
78-117 . {
78-118 . case one:
78-119 . {
78-120 . run_this;
78-121 . // missing break
78-122 . }
78-123 . case two:
78-124 . {
78-125 . run_this;
78-126 . break;
78-127 . }
78-128 . default:
78-129 . {
78-130 . SwError;
78-131 . }
78-132 . }
78-133 .
78-134 .
78-135 . if (A ne B)
78-136 . {
78-137 . A = B + C;
78-138 . D = E + F;
78-139 . }
78-140 .
78-141 . A = B-C;
78-142 . A = B+C;
78-143 . /* dead_code = A * B; */
78-144 .
78-145 . if (A != B)
78-146 . {
78-147 . A = B + C;
78-148 . D = E + F;
78-149 . }
78-150 .
78-151 . A = B-C;
78-152 .
78-153 . if (A < B)
78-154 . {
78-155 . A = B + C;
78-156 . D = E + F;
78-157 . }
78-158 .
78-159 . A = B*C;
78-160 . A = B/C;
78-161 . /* LE SV TOC-2145 this is a log-19.1.38 req to fail*/
78-162 . A = B*C;
78-163 . A = B+C;
78-164 .
78-165 . if (A < B)
78-166 . {
78-167 . A = B + C;
78-168 . D = E + F;
78-169 . }
78-170 .
78-171 .
78-172 . if (A ge B)
78-173 . {
78-174 . A = B + C;
78-175 . D = E + F;
78-176 . }
78-177 .
78-178 .
78-179 . if (A > = B)
78-180 . {
78-181 . A = B + C;
78-182 . D = E + F;
78-183 . }
78-184 .
78-185 . A = B*C;
78-186 .
78-187 . switch (log stuff)
78-188 . {
78-189 . case:
78-190 . case:
78-191 . // stacked case statements but only if there is a new line in between
78-192 .
78-193 . case:
78-194 . case:
78-195 . case:
78-196 . {
78-197 . run_this;
78-198 . break;
78-199 . }
78-200 . default:
78-201 . {
78-202 . halt;
78-203 . }
78-204 . }
78-205 .
78-206 .
78-207 . if (A < B)
78-208 . {
78-209 . A = B + C;
78-210 . D = E + F;
78-211 . }
78-212 .
78-213 . A = B*C;
78-214 . A = B+C;
78-215 . A = B*C;
78-216 . A = B-C;
78-217 .
78-218 . if (A lt B)
78-219 . {
78-220 . A = B + C;
78-221 . D = E + F;
78-222 . }
78-223 .
78-224 .
78-225 . if (A le B)
78-226 . {
78-227 . A = B + C;
78-228 . D = E + F;
78-229 . }
78-230 .
78-231 .
78-232 . if (A > B)
78-233 . {
78-234 . A = B + C;
78-235 . D = E + F;
78-236 . }
78-237 .
78-238 .
78-239 . if (A le B)
78-240 . {
78-241 . A = B + C;
78-242 . D = E + F;
78-243 . }
78-244 .
78-245 . A = B-C;
78-246 . A = B/C;
78-247 .
78-248 . if (A != B)
78-249 . {
78-250 . A = B + C;
78-251 . D = E + F;
78-252 . }
78-253 .
78-254 .
78-255 . if (A > = B)
78-256 . {
78-257 . A = B + C;
78-258 . D = E + F;
78-259 . }
78-260 .
78-261 . A = B/C;
78-262 . // max LOC 57
78-263 .
78-264 . }
78-265 .
78-266 .
78-267 . /*
78-268 . -----------------------------------------------------------------------------
78-269 . --| NAME: log.19.2
78-270 . --|
78-271 . --| ABSTRACT:
78-272 . --| This function does log stuff.
78-273 . --|
78-274 . --| RETURNS:
78-275 . --| NONE.
78-276 . --|
78-277 . ----------------------------------------------------------------------------
78-278 . */
78-279 . static void log.19.2(void)
78-280 . {
78-281 . A = B/C;
78-282 . // ??? go see ws
78-283 . A = B*C;
78-284 .
78-285 . if (A le B)
78-286 . {
78-287 . A = B + C;
78-288 . D = E + F;
78-289 . }
78-290 .
78-291 .
78-292 . switch (log stuff)
78-293 . {
78-294 . case one:
78-295 . {
78-296 . run_this;
78-297 . break;
78-298 . }
78-299 . case two:
78-300 . {
78-301 . run_this;
78-302 . break;
78-303 . }
78-304 . // missing default
78-305 . }
78-306 .
78-307 . A = B-C;
78-308 .
78-309 . if (A ge B)
78-310 . {
78-311 . A = B + C;
78-312 . D = E + F;
78-313 . }
78-314 .
78-315 . A = B*C;
78-316 . A = B+C;
78-317 .
78-318 . if (A gt B)
78-319 . {
78-320 . A = B + C;
78-321 . D = E + F;
78-322 . }
78-323 .
78-324 . A = B/C;
78-325 .
78-326 . if (A > B)
78-327 . {
78-328 . A = B + C;
78-329 . D = E + F;
78-330 . }
78-331 .
78-332 . A = (int)B + C;
78-333 .
78-334 . if (A ge B)
78-335 . {
78-336 . A = B + C;
78-337 . D = E + F;
78-338 . }
78-339 .
78-340 . // max LOC 11
78-341 .
78-342 . }
78-343 .
78-344 .
78-345 . /*
78-346 . -----------------------------------------------------------------------------
78-347 . --| NAME: log.19.3
78-348 . --|
78-349 . --| ABSTRACT:
78-350 . --| This function does log stuff.
78-351 . --|
78-352 . --| RETURNS:
78-353 . --| NONE.
78-354 . --|
78-355 . ----------------------------------------------------------------------------
78-356 . */
78-357 . static void log.19.3(void)
78-358 . {
78-359 . A = B/C;
78-360 .
78-361 . if (A le B)
78-362 . {
78-363 . A = B + C;
78-364 . D = E + F;
78-365 . }
78-366 .
78-367 . A = B*C;
78-368 .
78-369 . if (A < = B)
78-370 . {
78-371 . A = B + C;
78-372 . D = E + F;
78-373 . }
78-374 .
78-375 . A = B/C;
78-376 . A = B-C;
78-377 . A = B-C;
78-378 . A = B/C;
78-379 . A = B-C;
78-380 .
78-381 . if (A < B)
78-382 . {
78-383 . A = B + C;
78-384 . D = E + F;
78-385 . }
78-386 .
78-387 . A = B/C;
78-388 .
78-389 . if (A ne B)
78-390 . {
78-391 . A = B + C;
78-392 . D = E + F;
78-393 . }
78-394 .
78-395 . A = B*C;
78-396 . A = B+C;
78-397 .
78-398 . if (A eq B)
78-399 . {
78-400 . A = B + C;
78-401 . D = E + F;
78-402 . }
78-403 .
78-404 .
78-405 . if (A < = B)
78-406 . {
78-407 . A = B + C;
78-408 . D = E + F;
78-409 . }
78-410 .
78-411 .
78-412 . if (A eq B)
78-413 . {
78-414 . A = B + C;
78-415 . D = E + F;
78-416 . }
78-417 .
78-418 . A = B-C;
78-419 .
78-420 . if (A < = B)
78-421 . {
78-422 . A = B + C;
78-423 . D = E + F;
78-424 . }
78-425 .
78-426 . A = B/C;
78-427 . // TBD - what do I do now
78-428 .
78-429 . if (A == B)
78-430 . {
78-431 . A = B + C;
78-432 . D = E + F;
78-433 . }
78-434 .
78-435 . A = B/C;
78-436 . A = B/C;
78-437 . A = B-C;
78-438 . A = B-C;
78-439 . A = B-C;
78-440 . A = B*C;
78-441 . A = B+C;
78-442 . A = B/C;
78-443 . /* LE SV TOC-2146 this is a log-19.3.30 req to detect error*/
78-444 . // TBS - I need to figure this out
78-445 . A = B-C;
78-446 . A = B/C;
78-447 . A = B/C;
78-448 . A = B*C;
78-449 .
78-450 . if (A > B)
78-451 . {
78-452 . A = B + C;
78-453 . D = E + F;
78-454 . }
78-455 .
78-456 . // max LOC 34
78-457 .
78-458 . }
78-459 .
78 78 Result: result/source/ft-app/ft-app-B1.0/log/log-19.c
79 79 Source: source/ft-app/ft-app-B1.0/msaw/msaw-01.c
79-0 . /*
79-1 . ----------------------------------------------------------------------------
79-2 . --| BEGIN PROLOGUE
79-3 . --|
79-4 . --| CLASSIFICATION: UNCLASSIFIED
79-5 . --|
79-6 . --| FILE NAME: msaw-01.c
79-7 . --|
79-8 . --| ABSTRACT:
79-9 . --| This file contains the 1 functions that do file msaw stuff.
79-10 . --|
79-11 . --| HISTORY:
79-12 . --| CCCQ_NAME:
79-13 . --| CCCQ_VER:
79-14 . --|
79-15 . --| END PROLOGUE
79-16 . ----------------------------------------------------------------------------
79-17 . */
79-18 .
79-19 . #include D;
79-20 . #define D;
79-21 . #define B;
79-22 . #define C;
79-23 . #include A;
79-24 . #define C;
79-25 .
79-26 .
79-27 .
79-28 . /*
79-29 . -----------------------------------------------------------------------------
79-30 . --| NAME: msaw.1.1
79-31 . --|
79-32 . --| ABSTRACT:
79-33 . --| This function does msaw stuff.
79-34 . --|
79-35 . --| RETURNS:
79-36 . --| NONE.
79-37 . --|
79-38 . ----------------------------------------------------------------------------
79-39 . */
79-40 . static void msaw.1.1(void)
79-41 . {
79-42 . A = B*C;
79-43 .
79-44 . switch (msaw stuff)
79-45 . {
79-46 . case one:
79-47 . {
79-48 . run_this;
79-49 . break;
79-50 . }
79-51 . case two:
79-52 . {
79-53 . run_this;
79-54 . break;
79-55 . }
79-56 . default:
79-57 . {
79-58 . SwError;
79-59 . }
79-60 . }
79-61 .
79-62 .
79-63 . if (A != B)
79-64 . {
79-65 . A = B + C;
79-66 . D = E + F;
79-67 . }
79-68 .
79-69 .
79-70 . if (A gt B)
79-71 . {
79-72 . A = B + C;
79-73 . D = E + F;
79-74 . }
79-75 .
79-76 . A = B*C;
79-77 .
79-78 . if (A gt B)
79-79 . {
79-80 . A = B + C;
79-81 . D = E + F;
79-82 . }
79-83 .
79-84 . A = B-C;
79-85 . A = B/C;
79-86 . A = B*C;
79-87 .
79-88 . if (A gt B)
79-89 . {
79-90 . A = B + C;
79-91 . D = E + F;
79-92 . }
79-93 .
79-94 . A = B-C;
79-95 .
79-96 . if (A le B)
79-97 . {
79-98 . A = B + C;
79-99 . D = E + F;
79-100 . }
79-101 .
79-102 . A = B*C;
79-103 .
79-104 . if (A < B)
79-105 . {
79-106 . A = B + C;
79-107 . D = E + F;
79-108 . }
79-109 .
79-110 .
79-111 . if (A != B)
79-112 . {
79-113 . A = B + C;
79-114 . D = E + F;
79-115 . }
79-116 .
79-117 . A = B+C;
79-118 . A = B/C;
79-119 .
79-120 . if (A le B)
79-121 . {
79-122 . A = B + C;
79-123 . D = E + F;
79-124 . }
79-125 .
79-126 . A = B+C;
79-127 .
79-128 . if (A > = B)
79-129 . {
79-130 . A = B + C;
79-131 . D = E + F;
79-132 . }
79-133 .
79-134 . A = B-C;
79-135 . A = B+C;
79-136 . A = B+C;
79-137 . A = B/C;
79-138 . A = B-C;
79-139 .
79-140 . switch (msaw stuff)
79-141 . {
79-142 . case one:
79-143 . {
79-144 . run_this;
79-145 . break;
79-146 . }
79-147 . case two:
79-148 . {
79-149 . run_this;
79-150 . break;
79-151 . }
79-152 . default:
79-153 . {
79-154 . SwError;
79-155 . }
79-156 . }
79-157 .
79-158 . A = B-C;
79-159 . A = B/C;
79-160 . /* LE SV TOC-2201 this is a msaw-01.1.29 req to increment*/
79-161 .
79-162 . switch (msaw stuff)
79-163 . {
79-164 . case one:
79-165 . {
79-166 . run_this;
79-167 . break;
79-168 . }
79-169 . case two:
79-170 . {
79-171 . run_this;
79-172 . break;
79-173 . }
79-174 . default:
79-175 . {
79-176 . SwError;
79-177 . }
79-178 . }
79-179 .
79-180 . A = B/C;
79-181 .
79-182 . if (A ge B)
79-183 . {
79-184 . A = B + C;
79-185 . D = E + F;
79-186 . }
79-187 .
79-188 . A = B+C;
79-189 . A = 0x0009;
79-190 . A = B+C;
79-191 . A = B*C;
79-192 . A = B*C;
79-193 .
79-194 . if (A ne B)
79-195 . {
79-196 . A = B + C;
79-197 . D = E + F;
79-198 . }
79-199 .
79-200 .
79-201 . if (A ge B)
79-202 . {
79-203 . A = B + C;
79-204 . D = E + F;
79-205 . }
79-206 .
79-207 . A = B/C;
79-208 .
79-209 . if (A ne B)
79-210 . {
79-211 . A = B + C;
79-212 . D = E + F;
79-213 . }
79-214 .
79-215 . A = B*C;
79-216 . A = (long)B + C;
79-217 . A = B+C;
79-218 . A = B-C;
79-219 . A = B/C;
79-220 . A = B+C;
79-221 . A = B-C;
79-222 . A = B/C;
79-223 . A = B/C;
79-224 . // max LOC 47
79-225 .
79-226 . }
79-227 .
79 79 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-01.c
80 80 Source: source/ft-app/ft-app-B1.0/msaw/msaw-02.c
80-0 .
80-1 .
80-2 . #define A;
80-3 . #include C;
80-4 . float B;
80-5 . #define A;
80-6 . #define B;
80-7 . double C;
80-8 .
80-9 .
80-10 .
80-11 . /*
80-12 . -----------------------------------------------------------------------------
80-13 . --| NAME: msaw.2.1
80-14 . --|
80-15 . --| ABSTRACT:
80-16 . --| This function does msaw stuff.
80-17 . --|
80-18 . --| RETURNS:
80-19 . --| NONE.
80-20 . --|
80-21 . ----------------------------------------------------------------------------
80-22 . */
80-23 . static void msaw.2.1(void)
80-24 . {
80-25 . A = B*C;
80-26 . A = B+C;
80-27 .
80-28 . switch (msaw stuff)
80-29 . {
80-30 . case one:
80-31 . {
80-32 . run_this;
80-33 . break;
80-34 . }
80-35 . case two:
80-36 . {
80-37 . run_this;
80-38 . break;
80-39 . }
80-40 . default:
80-41 . {
80-42 . SwError;
80-43 . }
80-44 . }
80-45 .
80-46 .
80-47 . if (A le B)
80-48 . {
80-49 . A = B + C;
80-50 . D = E + F;
80-51 . }
80-52 .
80-53 . /* LE SV TOC-2202 this is a msaw-02.1.5 req to recover*/
80-54 . A = B-C;
80-55 . A = B*C;
80-56 . A = B+C;
80-57 . A = B*C;
80-58 . /* LE SV TOC-2203 this is a msaw-02.1.9 req to process*/
80-59 .
80-60 . switch (msaw stuff)
80-61 . {
80-62 . case one:
80-63 . {
80-64 . run_this;
80-65 . break;
80-66 . }
80-67 . case two:
80-68 . {
80-69 . run_this;
80-70 . break;
80-71 . }
80-72 . default:
80-73 . {
80-74 . SwError;
80-75 . }
80-76 . }
80-77 .
80-78 . A = B/C;
80-79 . A = B*C;
80-80 . /* LE SV TOC-2204 this is a msaw-02.1.12 req to compare*/
80-81 . A = B+C;
80-82 . A = B+C;
80-83 . A = 0x0001;
80-84 .
80-85 . if (A gt B)
80-86 . {
80-87 . A = B + C;
80-88 . D = E + F;
80-89 . }
80-90 .
80-91 .
80-92 . switch (msaw stuff)
80-93 . {
80-94 . case one:
80-95 . {
80-96 . run_this;
80-97 . break;
80-98 . }
80-99 . case two:
80-100 . {
80-101 . run_this;
80-102 . break;
80-103 . }
80-104 . default:
80-105 . {
80-106 . SwError;
80-107 . }
80-108 . }
80-109 .
80-110 . A = B/C;
80-111 . /* LE SV TOC-2205 this is a msaw-02.1.17 req to transform*/
80-112 .
80-113 . if (A > B)
80-114 . {
80-115 . A = B + C;
80-116 . D = E + F;
80-117 . }
80-118 .
80-119 .
80-120 . if (A < B)
80-121 . {
80-122 . A = B + C;
80-123 . D = E + F;
80-124 . }
80-125 .
80-126 . A = B-C;
80-127 .
80-128 . if (A ne B)
80-129 . {
80-130 . A = B + C;
80-131 . D = E + F;
80-132 . }
80-133 .
80-134 .
80-135 . if (A ge B)
80-136 . {
80-137 . A = B + C;
80-138 . D = E + F;
80-139 . }
80-140 .
80-141 . /* LE SV TOC-2206 this is a msaw-02.1.22 req to recover*/
80-142 . A = B+C;
80-143 . A = B/C;
80-144 . A = B*C;
80-145 . A = B-C;
80-146 . A = B/C;
80-147 . A = B-C;
80-148 .
80-149 . if (A gt B)
80-150 . {
80-151 . A = B + C;
80-152 . D = E + F;
80-153 . }
80-154 .
80-155 . A = B*C;
80-156 . A = B/C;
80-157 . A = B+C;
80-158 .
80-159 . if (A > = B)
80-160 . {
80-161 . A = B + C;
80-162 . D = E + F;
80-163 . }
80-164 .
80-165 . FreePtr = HmiStringPtr;
80-166 .
80-167 . if (A != B)
80-168 . {
80-169 . A = B + C;
80-170 . D = E + F;
80-171 . }
80-172 .
80-173 . A = B/C;
80-174 . A = B+C;
80-175 .
80-176 . if (A == B)
80-177 . {
80-178 . A = B + C;
80-179 . D = E + F;
80-180 . }
80-181 .
80-182 . /* LE SV TOC-2207 this is a msaw-02.1.37 req to check unix*/
80-183 .
80-184 . if (A ge B)
80-185 . {
80-186 . A = B + C;
80-187 . D = E + F;
80-188 . }
80-189 .
80-190 . A = B-C;
80-191 .
80-192 . if (A == B)
80-193 . {
80-194 . A = B + C;
80-195 . D = E + F;
80-196 . }
80-197 .
80-198 . A = B-C;
80-199 . A = B+C;
80-200 . A = B*C;
80-201 . A = B-C;
80-202 . A = B/C;
80-203 . A = B+C;
80-204 . A = B/C;
80-205 . A = B-C;
80-206 . A = B/C;
80-207 . A = 0x0002;
80-208 .
80-209 . if (A le B)
80-210 . {
80-211 . A = B + C;
80-212 . D = E + F;
80-213 . }
80-214 .
80-215 . A = B+C;
80-216 .
80-217 . switch (msaw stuff)
80-218 . {
80-219 . case one:
80-220 . {
80-221 . run_this;
80-222 . break;
80-223 . }
80-224 . case two:
80-225 . {
80-226 . run_this;
80-227 . break;
80-228 . }
80-229 . // missing default
80-230 . }
80-231 .
80-232 . A = B/C;
80-233 . A = B*C;
80-234 . A = B/C;
80-235 .
80-236 . if (A eq B)
80-237 . {
80-238 . A = B + C;
80-239 . D = E + F;
80-240 . }
80-241 .
80-242 .
80-243 . if (A != B)
80-244 . {
80-245 . A = B + C;
80-246 . D = E + F;
80-247 . }
80-248 .
80-249 .
80-250 . if (A lt B)
80-251 . {
80-252 . A = B + C;
80-253 . D = E + F;
80-254 . }
80-255 .
80-256 .
80-257 . if (A ge B)
80-258 . {
80-259 . A = B + C;
80-260 . D = E + F;
80-261 . }
80-262 .
80-263 .
80-264 . if (A != B)
80-265 . {
80-266 . A = B + C;
80-267 . D = E + F;
80-268 . }
80-269 .
80-270 .
80-271 . if (A < = B)
80-272 . {
80-273 . A = B + C;
80-274 . D = E + F;
80-275 . }
80-276 .
80-277 .
80-278 . switch (msaw stuff)
80-279 . {
80-280 . case one:
80-281 . {
80-282 . run_this;
80-283 . break;
80-284 . }
80-285 . case two:
80-286 . {
80-287 . run_this;
80-288 . break;
80-289 . }
80-290 . default:
80-291 . {
80-292 . SwError;
80-293 . }
80-294 . }
80-295 .
80-296 . A = B/C;
80-297 .
80-298 . if (A le B)
80-299 . {
80-300 . A = B + C;
80-301 . D = E + F;
80-302 . }
80-303 .
80-304 . A = B*C;
80-305 . A = B+C;
80-306 . A = B-C;
80-307 . A = B*C;
80-308 . A = B-C;
80-309 . A = B*C;
80-310 .
80-311 . if (A gt B)
80-312 . {
80-313 . A = B + C;
80-314 . D = E + F;
80-315 . }
80-316 .
80-317 .
80-318 . if (A lt B)
80-319 . {
80-320 . A = B + C;
80-321 . D = E + F;
80-322 . }
80-323 .
80-324 . A = B/C;
80-325 . A = B-C;
80-326 .
80-327 . if (A < B)
80-328 . {
80-329 . A = B + C;
80-330 . D = E + F;
80-331 . }
80-332 .
80-333 . A = B-C;
80-334 .
80-335 . if (A ge B)
80-336 . {
80-337 . A = B + C;
80-338 . D = E + F;
80-339 . }
80-340 .
80-341 . A = B-C;
80-342 . /* LE SV TOC-2208 this is a msaw-02.1.77 req to translate*/
80-343 .
80-344 . if (A < = B)
80-345 . {
80-346 . A = B + C;
80-347 . D = E + F;
80-348 . }
80-349 .
80-350 . free(FreePtr);
80-351 . A = B-C;
80-352 . A = B/C;
80-353 .
80-354 . if (A > = B)
80-355 . {
80-356 . A = B + C;
80-357 . D = E + F;
80-358 . }
80-359 .
80-360 . A = B*C;
80-361 . A = B+C;
80-362 . A = B*C;
80-363 .
80-364 . if (A ge B)
80-365 . {
80-366 . A = B + C;
80-367 . D = E + F;
80-368 . }
80-369 .
80-370 . A = B+C;
80-371 .
80-372 . if (A != B)
80-373 . {
80-374 . A = B + C;
80-375 . D = E + F;
80-376 . }
80-377 .
80-378 . A = B*C;
80-379 . A = B/C;
80-380 . A = B/C;
80-381 . A = B/C;
80-382 . A = B/C;
80-383 . // max LOC 91
80-384 .
80-385 . }
80-386 .
80 80 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-02.c
81 81 Source: source/ft-app/ft-app-B1.0/msaw/msaw-03.c
81-0 . /*
81-1 . ----------------------------------------------------------------------------
81-2 . --| BEGIN PROLOGUE
81-3 . --|
81-4 . --| CLASSIFICATION: UNCLASSIFIED
81-5 . --|
81-6 . --| FILE NAME: msaw-03.c
81-7 . --|
81-8 . --| ABSTRACT:
81-9 . --| This file contains the 2 functions that do file msaw stuff.
81-10 . --|
81-11 . --| HISTORY:
81-12 . --| CCCQ_NAME:
81-13 . --| CCCQ_VER:
81-14 . --|
81-15 . --| END PROLOGUE
81-16 . ----------------------------------------------------------------------------
81-17 . */
81-18 .
81-19 . #include B;
81-20 . float B;
81-21 . #include B;
81-22 .
81-23 .
81-24 .
81-25 . /*
81-26 . -----------------------------------------------------------------------------
81-27 . --| NAME: msaw.3.1
81-28 . --|
81-29 . --| ABSTRACT:
81-30 . --| This function does msaw stuff.
81-31 . --|
81-32 . --| RETURNS:
81-33 . --| NONE.
81-34 . --|
81-35 . ----------------------------------------------------------------------------
81-36 . */
81-37 . static void msaw.3.1(void)
81-38 . {
81-39 .
81-40 . if (A == B)
81-41 . {
81-42 . A = B + C;
81-43 . D = E + F;
81-44 . }
81-45 .
81-46 . A = B+C;
81-47 . A = B+C;
81-48 .
81-49 . if (A ne B)
81-50 . {
81-51 . A = B + C;
81-52 . D = E + F;
81-53 . }
81-54 .
81-55 .
81-56 . if (A < B)
81-57 . {
81-58 . A = B + C;
81-59 . D = E + F;
81-60 . }
81-61 .
81-62 .
81-63 . if (A == B)
81-64 . {
81-65 . A = B + C;
81-66 . D = E + F;
81-67 . }
81-68 .
81-69 .
81-70 . if (A > B)
81-71 . {
81-72 . A = B + C;
81-73 . D = E + F;
81-74 . }
81-75 .
81-76 .
81-77 . if (A < = B)
81-78 . {
81-79 . A = B + C;
81-80 . D = E + F;
81-81 . }
81-82 .
81-83 . A = B/C;
81-84 .
81-85 . if (veg)
81-86 . // missing curly brace
81-87 . variable = orange;
81-88 .
81-89 . A = B-C;
81-90 .
81-91 . if (A == B)
81-92 . {
81-93 . A = B + C;
81-94 . D = E + F;
81-95 . }
81-96 .
81-97 . A = B-C;
81-98 . /* LE SV TOC-2209 this is a msaw-03.1.13 req to verify*/
81-99 .
81-100 . if (A gt B)
81-101 . {
81-102 . A = B + C;
81-103 . D = E + F;
81-104 . }
81-105 .
81-106 . A = B+C;
81-107 . // max LOC 14
81-108 .
81-109 . }
81-110 .
81-111 .
81-112 . /*
81-113 . -----------------------------------------------------------------------------
81-114 . --| NAME: msaw.3.2
81-115 . --|
81-116 . --| ABSTRACT:
81-117 . --| This function does msaw stuff.
81-118 . --|
81-119 . --| RETURNS:
81-120 . --| NONE.
81-121 . --|
81-122 . ----------------------------------------------------------------------------
81-123 . */
81-124 . static void msaw.3.2(void)
81-125 . {
81-126 . A = B+C;
81-127 .
81-128 . if (A > B)
81-129 . {
81-130 . A = B + C;
81-131 . D = E + F;
81-132 . }
81-133 .
81-134 .
81-135 . if (A < = B)
81-136 . {
81-137 . A = B + C;
81-138 . D = E + F;
81-139 . }
81-140 .
81-141 .
81-142 . if (A le B)
81-143 . {
81-144 . A = B + C;
81-145 . D = E + F;
81-146 . }
81-147 .
81-148 . A = B+C;
81-149 . A = B*C;
81-150 . A = B*C;
81-151 . A = (long)B + C;
81-152 . A = B*C;
81-153 . A = B*C;
81-154 . A = B+C;
81-155 . A = B-C;
81-156 . /* LE SV TOC-2210 this is a msaw-03.2.12 req to halt*/
81-157 . A = B*C;
81-158 . A = B-C;
81-159 . A = B-C;
81-160 . A = B-C;
81-161 .
81-162 . if (A ne B)
81-163 . {
81-164 . A = B + C;
81-165 . D = E + F;
81-166 . }
81-167 .
81-168 . A = B+C;
81-169 .
81-170 . if (A != B)
81-171 . {
81-172 . A = B + C;
81-173 . D = E + F;
81-174 . }
81-175 .
81-176 .
81-177 . if (A lt B)
81-178 . {
81-179 . A = B + C;
81-180 . D = E + F;
81-181 . }
81-182 .
81-183 . A = B*C;
81-184 . A = B+C;
81-185 . A = B+C;
81-186 . A = B*C;
81-187 . A = B*C;
81-188 . A = B/C;
81-189 . A = B/C;
81-190 .
81-191 . if (A ne B)
81-192 . {
81-193 . A = B + C;
81-194 . D = E + F;
81-195 . }
81-196 .
81-197 . A = B-C;
81-198 . A = B-C;
81-199 .
81-200 . if (A > = B)
81-201 . {
81-202 . A = B + C;
81-203 . D = E + F;
81-204 . }
81-205 .
81-206 . A = B-C;
81-207 .
81-208 . switch (msaw stuff)
81-209 . {
81-210 . case one:
81-211 . {
81-212 . run_this;
81-213 . break;
81-214 . }
81-215 . case two:
81-216 . {
81-217 . run_this;
81-218 . break;
81-219 . }
81-220 . default:
81-221 . {
81-222 . SwError;
81-223 . }
81-224 . }
81-225 .
81-226 . A = B+C;
81-227 . A = B+C;
81-228 . A = B-C;
81-229 . A = 0x0004;
81-230 .
81-231 . if (A eq B)
81-232 . {
81-233 . A = B + C;
81-234 . D = E + F;
81-235 . }
81-236 .
81-237 . // max LOC 36
81-238 .
81-239 . }
81-240 .
81 81 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-03.c
82 82 Source: source/ft-app/ft-app-B1.0/msaw/msaw-04.c
82-0 . /*
82-1 . ----------------------------------------------------------------------------
82-2 . --| BEGIN PROLOGUE
82-3 . --|
82-4 . --| CLASSIFICATION: UNCLASSIFIED
82-5 . --|
82-6 . --| FILE NAME: msaw-04.c
82-7 . --|
82-8 . --| ABSTRACT:
82-9 . --| This file contains the 5 functions that do file msaw stuff.
82-10 . --|
82-11 . --| HISTORY:
82-12 . --| CCCQ_NAME:
82-13 . --| CCCQ_VER:
82-14 . --|
82-15 . --| END PROLOGUE
82-16 . ----------------------------------------------------------------------------
82-17 . */
82-18 .
82-19 . double C;
82-20 .
82-21 .
82-22 .
82-23 . /*
82-24 . -----------------------------------------------------------------------------
82-25 . --| NAME: msaw.4.1
82-26 . --|
82-27 . --| ABSTRACT:
82-28 . --| This function does msaw stuff.
82-29 . --|
82-30 . --| RETURNS:
82-31 . --| NONE.
82-32 . --|
82-33 . ----------------------------------------------------------------------------
82-34 . */
82-35 . static void msaw.4.1(void)
82-36 . {
82-37 . A = B-C;
82-38 .
82-39 . if (A ne B)
82-40 . {
82-41 . A = B + C;
82-42 . D = E + F;
82-43 . }
82-44 .
82-45 . A = B/C;
82-46 . A = B*C;
82-47 . A = B*C;
82-48 . A = B-C;
82-49 .
82-50 . if (A lt B)
82-51 . {
82-52 . A = B + C;
82-53 . D = E + F;
82-54 . }
82-55 .
82-56 . A = 0x0001;
82-57 . A = B-C;
82-58 . A = B*C;
82-59 . A = 0x0007;
82-60 . A = B-C;
82-61 . A = B*C;
82-62 .
82-63 . if (A gt B)
82-64 . {
82-65 . A = B + C;
82-66 . D = E + F;
82-67 . }
82-68 .
82-69 .
82-70 . if (A gt B)
82-71 . {
82-72 . A = B + C;
82-73 . D = E + F;
82-74 . }
82-75 .
82-76 . A = B+C;
82-77 . A = B*C;
82-78 .
82-79 . switch (msaw stuff)
82-80 . {
82-81 . case one:
82-82 . {
82-83 . switch (nested)
82-84 . {
82-85 . case:
82-86 . X = Y + Z;
82-87 . case:
82-88 . X = Y + Z;
82-89 . default:
82-90 . SwError;
82-91 . }
82-92 . }
82-93 . case two:
82-94 . {
82-95 . run_this;
82-96 . break;
82-97 . }
82-98 . default:
82-99 . {
82-100 . SwError;
82-101 . }
82-102 . }
82-103 .
82-104 .
82-105 . if (A > = B)
82-106 . {
82-107 . A = B + C;
82-108 . D = E + F;
82-109 . }
82-110 .
82-111 . A = B*C;
82-112 . A = B+C;
82-113 . A = B-C;
82-114 . A = B/C;
82-115 . A = B-C;
82-116 . A = B/C;
82-117 .
82-118 . if (A ne B)
82-119 . {
82-120 . A = B + C;
82-121 . D = E + F;
82-122 . }
82-123 .
82-124 . A = B-C;
82-125 .
82-126 . if (A ne B)
82-127 . {
82-128 . A = B + C;
82-129 . D = E + F;
82-130 . }
82-131 .
82-132 . A = B+C;
82-133 . A = B+C;
82-134 .
82-135 . if (A == B)
82-136 . {
82-137 . A = B + C;
82-138 . D = E + F;
82-139 . }
82-140 .
82-141 . /* LE SV TOC-2211 this is a msaw-04.1.29 req to translate*/
82-142 . A = B*C;
82-143 . A = B+C;
82-144 . A = B/C;
82-145 . /* LE SV TOC-2212 this is a msaw-04.1.32 req to detect error*/
82-146 .
82-147 . if (A lt B)
82-148 . {
82-149 . A = B + C;
82-150 . D = E + F;
82-151 . }
82-152 .
82-153 . A = B+C;
82-154 .
82-155 . if (A ne B)
82-156 . {
82-157 . A = B + C;
82-158 . D = E + F;
82-159 . }
82-160 .
82-161 . A = 0x0003;
82-162 . A = B-C;
82-163 . A = B+C;
82-164 . A = B+C;
82-165 . A = B/C;
82-166 .
82-167 . if (A ne B)
82-168 . {
82-169 . A = B + C;
82-170 . D = E + F;
82-171 . }
82-172 .
82-173 .
82-174 . if (A > = B)
82-175 . {
82-176 . A = B + C;
82-177 . D = E + F;
82-178 . }
82-179 .
82-180 . A = B/C;
82-181 . A = B*C;
82-182 . /* LE SV TOC-2213 this is a msaw-04.1.43 req to disable*/
82-183 . A = B+C;
82-184 . A = B*C;
82-185 . A = B-C;
82-186 . A = B/C;
82-187 . A = B/C;
82-188 . A = B+C;
82-189 .
82-190 . if (A == B)
82-191 . {
82-192 . A = B + C;
82-193 . D = E + F;
82-194 . }
82-195 .
82-196 . A = B-C;
82-197 . A = 0x0008;
82-198 . A = B*C;
82-199 . A = B/C;
82-200 . A = B*C;
82-201 .
82-202 . if (A ge B)
82-203 . {
82-204 . A = B + C;
82-205 . D = E + F;
82-206 . }
82-207 .
82-208 . A = B-C;
82-209 . A = B*C;
82-210 .
82-211 . switch (msaw stuff)
82-212 . {
82-213 . case one:
82-214 . {
82-215 . switch (nested)
82-216 . {
82-217 . case:
82-218 . X = Y + Z;
82-219 . case:
82-220 . X = Y + Z;
82-221 . default:
82-222 . SwError;
82-223 . }
82-224 . }
82-225 . case two:
82-226 . {
82-227 . run_this;
82-228 . break;
82-229 . }
82-230 . default:
82-231 . {
82-232 . SwError;
82-233 . }
82-234 . }
82-235 .
82-236 .
82-237 . if (A < = B)
82-238 . {
82-239 . A = B + C;
82-240 . D = E + F;
82-241 . }
82-242 .
82-243 . A = B+C;
82-244 . // max LOC 58
82-245 .
82-246 . }
82-247 .
82-248 .
82-249 . /*
82-250 . -----------------------------------------------------------------------------
82-251 . --| NAME: msaw.4.2
82-252 . --|
82-253 . --| ABSTRACT:
82-254 . --| This function does msaw stuff.
82-255 . --|
82-256 . --| RETURNS:
82-257 . --| NONE.
82-258 . --|
82-259 . ----------------------------------------------------------------------------
82-260 . */
82-261 . static void msaw.4.2(void)
82-262 . {
82-263 .
82-264 . switch (msaw stuff)
82-265 . {
82-266 . case one:
82-267 . {
82-268 . run_this;
82-269 . break;
82-270 . }
82-271 . case two:
82-272 . {
82-273 . run_this;
82-274 . break;
82-275 . }
82-276 . default:
82-277 . {
82-278 . SwError;
82-279 . }
82-280 . }
82-281 .
82-282 . A = (int)B + C;
82-283 . A = B*C;
82-284 .
82-285 . if (A == B)
82-286 . {
82-287 . A = B + C;
82-288 . D = E + F;
82-289 . }
82-290 .
82-291 . A = B-C;
82-292 . A = 0x0006;
82-293 . A = (float)B + C;
82-294 .
82-295 . if (A lt B)
82-296 . {
82-297 . A = B + C;
82-298 . D = E + F;
82-299 . }
82-300 .
82-301 .
82-302 . if (A > B)
82-303 . {
82-304 . A = B + C;
82-305 . D = E + F;
82-306 . }
82-307 .
82-308 . A = B*C;
82-309 .
82-310 . if (A lt B)
82-311 . {
82-312 . A = B + C;
82-313 . D = E + F;
82-314 . }
82-315 .
82-316 . A = B+C;
82-317 . A = B/C;
82-318 . A = B+C;
82-319 . // max LOC 11
82-320 .
82-321 . }
82-322 .
82-323 .
82-324 . /*
82-325 . -----------------------------------------------------------------------------
82-326 . --| NAME: msaw.4.3
82-327 . --|
82-328 . --| ABSTRACT:
82-329 . --| This function does msaw stuff.
82-330 . --|
82-331 . --| RETURNS:
82-332 . --| NONE.
82-333 . --|
82-334 . ----------------------------------------------------------------------------
82-335 . */
82-336 . static void msaw.4.3(void)
82-337 . {
82-338 .
82-339 . if (A == B)
82-340 . {
82-341 . A = B + C;
82-342 . D = E + F;
82-343 . }
82-344 .
82-345 . A = B-C;
82-346 . A = B+C;
82-347 . A = B+C;
82-348 . A = B*C;
82-349 . /* LE SV TOC-2214 this is a msaw-04.3.6 req to enable*/
82-350 .
82-351 . if (A ge B)
82-352 . {
82-353 . A = B + C;
82-354 . D = E + F;
82-355 . }
82-356 .
82-357 . rcv_buffer = (U16 *) alloc(size+1);
82-358 . A = B*C;
82-359 . A = B*C;
82-360 .
82-361 . if (A == B)
82-362 . {
82-363 . A = B + C;
82-364 . D = E + F;
82-365 . }
82-366 .
82-367 . A = B+C;
82-368 .
82-369 . if (A lt B)
82-370 . {
82-371 . A = B + C;
82-372 . D = E + F;
82-373 . }
82-374 .
82-375 . A = 0x0007;
82-376 . A = B-C;
82-377 .
82-378 . if (A != B)
82-379 . {
82-380 . A = B + C;
82-381 . D = E + F;
82-382 . }
82-383 .
82-384 . A = B+C;
82-385 .
82-386 . if (A != B)
82-387 . {
82-388 . A = B + C;
82-389 . D = E + F;
82-390 . }
82-391 .
82-392 . A = B+C;
82-393 . A = B*C;
82-394 . A = B+C;
82-395 . A = B*C;
82-396 . /* LE SV TOC-2215 this is a msaw-04.3.20 req to increment*/
82-397 . A = B/C;
82-398 . A = B+C;
82-399 . A = B/C;
82-400 . /* LE SV TOC-2216 this is a msaw-04.3.23 req to increment*/
82-401 . A = B/C;
82-402 .
82-403 . if (A > = B)
82-404 . {
82-405 . A = B + C;
82-406 . D = E + F;
82-407 . }
82-408 .
82-409 . A = B*C;
82-410 .
82-411 . if (A == B)
82-412 . {
82-413 . A = B + C;
82-414 . D = E + F;
82-415 . }
82-416 .
82-417 . A = B*C;
82-418 . A = B/C;
82-419 .
82-420 . if (A != B)
82-421 . {
82-422 . A = B + C;
82-423 . D = E + F;
82-424 . }
82-425 .
82-426 . A = B*C;
82-427 . A = B+C;
82-428 .
82-429 . switch (msaw stuff)
82-430 . {
82-431 . case:
82-432 . case:
82-433 . // stacked case statements but only if there is a new line in between
82-434 .
82-435 . case:
82-436 . case:
82-437 . case:
82-438 . {
82-439 . run_this;
82-440 . break;
82-441 . }
82-442 . default:
82-443 . {
82-444 . halt;
82-445 . }
82-446 . }
82-447 .
82-448 . A = B*C;
82-449 .
82-450 . if (A le B)
82-451 . {
82-452 . A = B + C;
82-453 . D = E + F;
82-454 . }
82-455 .
82-456 . A = 0x0006;
82-457 . A = B/C;
82-458 . A = B/C;
82-459 . A = B-C;
82-460 . A = B*C;
82-461 . A = B*C;
82-462 . // max LOC 38
82-463 .
82-464 . }
82-465 .
82-466 .
82-467 . /*
82-468 . -----------------------------------------------------------------------------
82-469 . --| NAME: msaw.4.4
82-470 . --|
82-471 . --| ABSTRACT:
82-472 . --| This function does msaw stuff.
82-473 . --|
82-474 . --| RETURNS:
82-475 . --| NONE.
82-476 . --|
82-477 . ----------------------------------------------------------------------------
82-478 . */
82-479 . static void msaw.4.4(void)
82-480 . {
82-481 .
82-482 . if (A != B)
82-483 . {
82-484 . A = B + C;
82-485 . D = E + F;
82-486 . }
82-487 .
82-488 .
82-489 . if (A lt B)
82-490 . {
82-491 . A = B + C;
82-492 . D = E + F;
82-493 . }
82-494 .
82-495 . A = B/C;
82-496 .
82-497 . if (A ne B)
82-498 . {
82-499 . A = B + C;
82-500 . D = E + F;
82-501 . }
82-502 .
82-503 .
82-504 . if (A != B)
82-505 . {
82-506 . A = B + C;
82-507 . D = E + F;
82-508 . }
82-509 .
82-510 . A = B+C;
82-511 . A = B/C;
82-512 .
82-513 . if (A le B)
82-514 . {
82-515 . A = B + C;
82-516 . D = E + F;
82-517 . }
82-518 .
82-519 . A = B+C;
82-520 .
82-521 . if (A > = B)
82-522 . {
82-523 . A = B + C;
82-524 . D = E + F;
82-525 . }
82-526 .
82-527 . A = B*C;
82-528 . A = (int)B + C;
82-529 . A = B*C;
82-530 . A = B-C;
82-531 . A = B/C;
82-532 .
82-533 . if (A eq B)
82-534 . {
82-535 . A = B + C;
82-536 . D = E + F;
82-537 . }
82-538 .
82-539 . A = B-C;
82-540 .
82-541 . if (A gt B)
82-542 . {
82-543 . A = B + C;
82-544 . D = E + F;
82-545 . }
82-546 .
82-547 . A = B+C;
82-548 . A = 0x0001;
82-549 . A = B*C;
82-550 . A = B*C;
82-551 . A = B/C;
82-552 .
82-553 . if (A != B)
82-554 . {
82-555 . A = B + C;
82-556 . D = E + F;
82-557 . }
82-558 .
82-559 . /* LE SV TOC-2217 this is a msaw-04.4.23 req to inhibit*/
82-560 . A = B*C;
82-561 . A = (float)B + C;
82-562 . A = B*C;
82-563 . A = B+C;
82-564 . A = B-C;
82-565 . A = B-C;
82-566 . A = B-C;
82-567 .
82-568 . if (A eq B)
82-569 . {
82-570 . A = B + C;
82-571 . D = E + F;
82-572 . }
82-573 .
82-574 . /* LE SV TOC-2218 this is a msaw-04.4.30 req to verify*/
82-575 . A = B-C;
82-576 . A = B+C;
82-577 .
82-578 . if (A le B)
82-579 . {
82-580 . A = B + C;
82-581 . D = E + F;
82-582 . }
82-583 .
82-584 . A = B*C;
82-585 . goto error;
82-586 . A = B+C;
82-587 . A = B*C;
82-588 . A = B/C;
82-589 . A = B/C;
82-590 . A = B*C;
82-591 . A = B-C;
82-592 . A = B*C;
82-593 .
82-594 . if (A eq B)
82-595 . {
82-596 . A = B + C;
82-597 . D = E + F;
82-598 . }
82-599 .
82-600 . A = B*C;
82-601 . A = B*C;
82-602 . A = B/C;
82-603 .
82-604 . if (A < = B)
82-605 . {
82-606 . A = B + C;
82-607 . D = E + F;
82-608 . }
82-609 .
82-610 .
82-611 . switch (msaw stuff)
82-612 . {
82-613 . case one:
82-614 . {
82-615 . run_this;
82-616 . break;
82-617 . }
82-618 . case two:
82-619 . {
82-620 . run_this;
82-621 . break;
82-622 . }
82-623 . // missing default
82-624 . }
82-625 .
82-626 .
82-627 . if (A eq B)
82-628 . {
82-629 . A = B + C;
82-630 . D = E + F;
82-631 . }
82-632 .
82-633 .
82-634 . if (A ge B)
82-635 . {
82-636 . A = B + C;
82-637 . D = E + F;
82-638 . }
82-639 .
82-640 .
82-641 . if (A ge B)
82-642 . {
82-643 . A = B + C;
82-644 . D = E + F;
82-645 . }
82-646 .
82-647 .
82-648 . switch (msaw stuff)
82-649 . {
82-650 . case one:
82-651 . {
82-652 . run_this;
82-653 . break;
82-654 . }
82-655 . case two:
82-656 . {
82-657 . run_this;
82-658 . break;
82-659 . }
82-660 . default:
82-661 . {
82-662 . SwError;
82-663 . }
82-664 . }
82-665 .
82-666 . A = B*C;
82-667 . A = B/C;
82-668 .
82-669 . if (A le B)
82-670 . {
82-671 . A = B + C;
82-672 . D = E + F;
82-673 . }
82-674 .
82-675 . A = B+C;
82-676 . A = B-C;
82-677 . goto error;
82-678 . A = B*C;
82-679 . A = B+C;
82-680 .
82-681 . if (A ne B)
82-682 . {
82-683 . A = B + C;
82-684 . D = E + F;
82-685 . }
82-686 .
82-687 . A = B/C;
82-688 . A = B+C;
82-689 .
82-690 . if (A eq B)
82-691 . {
82-692 . A = B + C;
82-693 . D = E + F;
82-694 . }
82-695 .
82-696 .
82-697 . if (A < = B)
82-698 . {
82-699 . A = B + C;
82-700 . D = E + F;
82-701 . }
82-702 .
82-703 . /* LE SV TOC-2219 this is a msaw-04.4.62 req to process*/
82-704 . A = B/C;
82-705 . A = B-C;
82-706 . A = B*C;
82-707 . A = B*C;
82-708 . A = B*C;
82-709 . A = B*C;
82-710 .
82-711 . if (A gt B)
82-712 . {
82-713 . A = B + C;
82-714 . D = E + F;
82-715 . }
82-716 .
82-717 . A = B-C;
82-718 .
82-719 . if (A lt B)
82-720 . {
82-721 . A = B + C;
82-722 . D = E + F;
82-723 . }
82-724 .
82-725 . A = B*C;
82-726 . // max LOC 71
82-727 .
82-728 . }
82-729 .
82-730 .
82-731 . /*
82-732 . -----------------------------------------------------------------------------
82-733 . --| NAME: msaw.4.5
82-734 . --|
82-735 . --| ABSTRACT:
82-736 . --| This function does msaw stuff.
82-737 . --|
82-738 . --| RETURNS:
82-739 . --| NONE.
82-740 . --|
82-741 . ----------------------------------------------------------------------------
82-742 . */
82-743 . static void msaw.4.5(void)
82-744 . {
82-745 .
82-746 . if (A ne B)
82-747 . {
82-748 . A = B + C;
82-749 . D = E + F;
82-750 . }
82-751 .
82-752 .
82-753 . if (A < B)
82-754 . {
82-755 . A = B + C;
82-756 . D = E + F;
82-757 . }
82-758 .
82-759 . A = B+C;
82-760 .
82-761 . if (A < = B)
82-762 . {
82-763 . A = B + C;
82-764 . D = E + F;
82-765 . }
82-766 .
82-767 . A = B/C;
82-768 . A = B*C;
82-769 .
82-770 . if (A > B)
82-771 . {
82-772 . A = B + C;
82-773 . D = E + F;
82-774 . }
82-775 .
82-776 .
82-777 . if (A != B)
82-778 . {
82-779 . A = B + C;
82-780 . D = E + F;
82-781 . }
82-782 .
82-783 . A = B*C;
82-784 .
82-785 . if (A > = B)
82-786 . {
82-787 . A = B + C;
82-788 . D = E + F;
82-789 . }
82-790 .
82-791 .
82-792 . /* dead_block = C * D;
82-793 . dead_block = E * F; */
82-794 .
82-795 . A = B-C;
82-796 .
82-797 . switch (msaw stuff)
82-798 . {
82-799 . case one:
82-800 . {
82-801 . run_this;
82-802 . break;
82-803 . }
82-804 . case two:
82-805 . {
82-806 . run_this;
82-807 . break;
82-808 . }
82-809 . default:
82-810 . {
82-811 . SwError;
82-812 . }
82-813 . }
82-814 .
82-815 . A = B+C;
82-816 .
82-817 . if (A le B)
82-818 . {
82-819 . A = B + C;
82-820 . D = E + F;
82-821 . }
82-822 .
82-823 . A = B-C;
82-824 . A = B*C;
82-825 . /* LE SV TOC-2220 this is a msaw-04.5.17 req to call isr*/
82-826 .
82-827 . if (A < B)
82-828 . {
82-829 . A = B + C;
82-830 . D = E + F;
82-831 . }
82-832 .
82-833 . A = B*C;
82-834 . A = B/C;
82-835 . A = B+C;
82-836 . // max LOC 20
82-837 .
82-838 . }
82-839 .
82 82 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-04.c
83 83 Source: source/ft-app/ft-app-B1.0/msaw/msaw-05.c
83-0 . /*
83-1 . ----------------------------------------------------------------------------
83-2 . --| BEGIN PROLOGUE
83-3 . --|
83-4 . --| CLASSIFICATION: UNCLASSIFIED
83-5 . --|
83-6 . --| FILE NAME: msaw-05.c
83-7 . --|
83-8 . --| ABSTRACT:
83-9 . --| This file contains the 4 functions that do file msaw stuff.
83-10 . --|
83-11 . --| HISTORY:
83-12 . --| CCCQ_NAME:
83-13 . --| CCCQ_VER:
83-14 . --|
83-15 . --| END PROLOGUE
83-16 . ----------------------------------------------------------------------------
83-17 . */
83-18 .
83-19 . char D;
83-20 . #include D;
83-21 . char D;
83-22 . #define B;
83-23 . #define C;
83-24 .
83-25 .
83-26 .
83-27 . /*
83-28 . -----------------------------------------------------------------------------
83-29 . --| NAME: msaw.5.1
83-30 . --|
83-31 . --| ABSTRACT:
83-32 . --| This function does msaw stuff.
83-33 . --|
83-34 . --| RETURNS:
83-35 . --| NONE.
83-36 . --|
83-37 . ----------------------------------------------------------------------------
83-38 . */
83-39 . static void msaw.5.1(void)
83-40 . {
83-41 .
83-42 . if (A le B)
83-43 . {
83-44 . A = B + C;
83-45 . D = E + F;
83-46 . }
83-47 .
83-48 . /* LE SV TOC-2221 this is a msaw-05.1.2 req to call isr*/
83-49 . A = B-C;
83-50 . A = B/C;
83-51 . A = B*C;
83-52 . A = B-C;
83-53 .
83-54 . if (A > B)
83-55 . {
83-56 . A = B + C;
83-57 . D = E + F;
83-58 . }
83-59 .
83-60 . A = (float)B + C;
83-61 . A = B-C;
83-62 . A = B-C;
83-63 .
83-64 . if (A < B)
83-65 . {
83-66 . A = B + C;
83-67 . D = E + F;
83-68 . }
83-69 .
83-70 .
83-71 . if (A < B)
83-72 . {
83-73 . A = B + C;
83-74 . D = E + F;
83-75 . }
83-76 .
83-77 . A = B-C;
83-78 .
83-79 . if (A == B)
83-80 . {
83-81 . A = B + C;
83-82 . D = E + F;
83-83 . }
83-84 .
83-85 . A = B/C;
83-86 . A = B-C;
83-87 . A = B*C;
83-88 . A = B-C;
83-89 . A = B-C;
83-90 . A = B-C;
83-91 . A = B/C;
83-92 .
83-93 . if (A le B)
83-94 . {
83-95 . A = B + C;
83-96 . D = E + F;
83-97 . }
83-98 .
83-99 . A = 0x0004;
83-100 . A = B/C;
83-101 .
83-102 . switch (msaw stuff)
83-103 . {
83-104 . case one:
83-105 . {
83-106 . run_this;
83-107 . break;
83-108 . }
83-109 . case two:
83-110 . {
83-111 . run_this;
83-112 . break;
83-113 . }
83-114 . default:
83-115 . {
83-116 . SwError;
83-117 . }
83-118 . }
83-119 .
83-120 . A = B/C;
83-121 .
83-122 . if (A eq B)
83-123 . {
83-124 . A = B + C;
83-125 . D = E + F;
83-126 . }
83-127 .
83-128 . A = B*C;
83-129 . A = B*C;
83-130 . A = B+C;
83-131 . A = B-C;
83-132 . A = B*C;
83-133 .
83-134 . if (A ge B)
83-135 . {
83-136 . A = B + C;
83-137 . D = E + F;
83-138 . }
83-139 .
83-140 . A = B/C;
83-141 .
83-142 . if (A < B)
83-143 . {
83-144 . A = B + C;
83-145 . D = E + F;
83-146 . }
83-147 .
83-148 . A = B-C;
83-149 .
83-150 . if (A lt B)
83-151 . {
83-152 . A = B + C;
83-153 . D = E + F;
83-154 . }
83-155 .
83-156 . A = B*C;
83-157 . A = B*C;
83-158 . A = B/C;
83-159 . A = B+C;
83-160 . A = B/C;
83-161 . A = B*C;
83-162 . A = B-C;
83-163 . A = B*C;
83-164 . /* LE SV TOC-2222 this is a msaw-05.1.43 req to check pSOS*/
83-165 .
83-166 . switch (msaw stuff)
83-167 . {
83-168 . case one:
83-169 . {
83-170 . run_this;
83-171 . break;
83-172 . }
83-173 . case two:
83-174 . {
83-175 . run_this;
83-176 . break;
83-177 . }
83-178 . default:
83-179 . {
83-180 . SwError;
83-181 . }
83-182 . }
83-183 .
83-184 .
83-185 . if (A ne B)
83-186 . {
83-187 . A = B + C;
83-188 . D = E + F;
83-189 . }
83-190 .
83-191 . A = B*C;
83-192 . A = B/C;
83-193 . A = B+C;
83-194 .
83-195 . if (A == B)
83-196 . {
83-197 . A = B + C;
83-198 . D = E + F;
83-199 . }
83-200 .
83-201 .
83-202 . if (A < B)
83-203 . {
83-204 . A = B + C;
83-205 . D = E + F;
83-206 . }
83-207 .
83-208 . A = B-C;
83-209 . A = B*C;
83-210 . A = B/C;
83-211 . A = B*C;
83-212 .
83-213 . switch (msaw stuff)
83-214 . {
83-215 . case one:
83-216 . {
83-217 . run_this;
83-218 . break;
83-219 . }
83-220 . case two:
83-221 . {
83-222 . run_this;
83-223 . break;
83-224 . }
83-225 . default:
83-226 . {
83-227 . SwError;
83-228 . }
83-229 . }
83-230 .
83-231 . A = B*C;
83-232 . A = B/C;
83-233 . A = B+C;
83-234 . /* LE SV TOC-2223 this is a msaw-05.1.58 req to audit*/
83-235 . A = B-C;
83-236 . A = B+C;
83-237 .
83-238 . if (A < B)
83-239 . {
83-240 . A = B + C;
83-241 . D = E + F;
83-242 . }
83-243 .
83-244 . A = B/C;
83-245 .
83-246 . if (A == B)
83-247 . {
83-248 . A = B + C;
83-249 . D = E + F;
83-250 . }
83-251 .
83-252 .
83-253 . if (A ne B)
83-254 . {
83-255 . A = B + C;
83-256 . D = E + F;
83-257 . }
83-258 .
83-259 .
83-260 . if (A ne B)
83-261 . {
83-262 . A = B + C;
83-263 . D = E + F;
83-264 . }
83-265 .
83-266 . A = B+C;
83-267 . // max LOC 65
83-268 .
83-269 . }
83-270 .
83-271 .
83-272 . /*
83-273 . -----------------------------------------------------------------------------
83-274 . --| NAME: msaw.5.2
83-275 . --|
83-276 . --| ABSTRACT:
83-277 . --| This function does msaw stuff.
83-278 . --|
83-279 . --| RETURNS:
83-280 . --| NONE.
83-281 . --|
83-282 . ----------------------------------------------------------------------------
83-283 . */
83-284 . static void msaw.5.2(void)
83-285 . {
83-286 . A = B*C;
83-287 . A = B/C;
83-288 . A = B+C;
83-289 .
83-290 . if (A ge B)
83-291 . {
83-292 . A = B + C;
83-293 . D = E + F;
83-294 . }
83-295 .
83-296 . A = B-C;
83-297 . A = B*C;
83-298 . /* LE SV TOC-2224 this is a msaw-05.2.7 req to process*/
83-299 .
83-300 . if (A > B)
83-301 . {
83-302 . A = B + C;
83-303 . D = E + F;
83-304 . }
83-305 .
83-306 . A = B+C;
83-307 .
83-308 . if (A < = B)
83-309 . {
83-310 . A = B + C;
83-311 . D = E + F;
83-312 . }
83-313 .
83-314 . A = B-C;
83-315 . A = B*C;
83-316 . A = B+C;
83-317 . A = B/C;
83-318 . A = B-C;
83-319 . A = 0x0006;
83-320 . A = B+C;
83-321 . A = B*C;
83-322 . A = B*C;
83-323 . A = B+C;
83-324 . // max LOC 18
83-325 .
83-326 . }
83-327 .
83-328 .
83-329 . /*
83-330 . -----------------------------------------------------------------------------
83-331 . --| NAME: msaw.5.3
83-332 . --|
83-333 . --| ABSTRACT:
83-334 . --| This function does msaw stuff.
83-335 . --|
83-336 . --| RETURNS:
83-337 . --| NONE.
83-338 . --|
83-339 . ----------------------------------------------------------------------------
83-340 . */
83-341 . static void msaw.5.3(void)
83-342 . {
83-343 . A = B/C;
83-344 . A = B*C;
83-345 .
83-346 . if (A ge B)
83-347 . {
83-348 . A = B + C;
83-349 . D = E + F;
83-350 . }
83-351 .
83-352 . /* LE SV TOC-2225 this is a msaw-05.3.4 req to update*/
83-353 . A = B*C;
83-354 . A = B*C;
83-355 . A = B/C;
83-356 . A = B/C;
83-357 .
83-358 . if (A le B)
83-359 . {
83-360 . A = B + C;
83-361 . D = E + F;
83-362 . }
83-363 .
83-364 . A = B*C;
83-365 . /* LE SV TOC-2226 this is a msaw-05.3.10 req to check unix*/
83-366 . A = 0x0003;
83-367 . A = B+C;
83-368 . A = B/C;
83-369 . A = B*C;
83-370 . A = B-C;
83-371 . A = B+C;
83-372 . A = B/C;
83-373 . /* LE SV TOC-2227 this is a msaw-05.3.16 req to transform*/
83-374 .
83-375 . if (A gt B)
83-376 . {
83-377 . A = B + C;
83-378 . D = E + F;
83-379 . }
83-380 .
83-381 . A = B-C;
83-382 . A = B*C;
83-383 . A = B-C;
83-384 . A = B/C;
83-385 . A = B/C;
83-386 . A = B-C;
83-387 . A = B-C;
83-388 . do forever;
83-389 . A = B-C;
83-390 .
83-391 . if (A ne B)
83-392 . {
83-393 . A = B + C;
83-394 . D = E + F;
83-395 . }
83-396 .
83-397 . A = B*C;
83-398 . A = B/C;
83-399 . A = B*C;
83-400 . A = B-C;
83-401 .
83-402 . if (A > = B)
83-403 . {
83-404 . A = B + C;
83-405 . D = E + F;
83-406 . }
83-407 .
83-408 . A = B-C;
83-409 .
83-410 . if (A < = B)
83-411 . {
83-412 . A = B + C;
83-413 . D = E + F;
83-414 . }
83-415 .
83-416 . FreePtr = HmiStringPtr;
83-417 . A = B-C;
83-418 .
83-419 . if (A lt B)
83-420 . {
83-421 . A = B + C;
83-422 . D = E + F;
83-423 . }
83-424 .
83-425 . A = B*C;
83-426 . A = B*C;
83-427 . A = B-C;
83-428 .
83-429 . if (A eq B)
83-430 . {
83-431 . A = B + C;
83-432 . D = E + F;
83-433 . }
83-434 .
83-435 .
83-436 . if (A > B)
83-437 . {
83-438 . A = B + C;
83-439 . D = E + F;
83-440 . }
83-441 .
83-442 . A = B*C;
83-443 . A = B*C;
83-444 . /* LE SV TOC-2228 this is a msaw-05.3.42 req to enable*/
83-445 . A = B+C;
83-446 . A = B+C;
83-447 . A = B-C;
83-448 . A = B*C;
83-449 .
83-450 . if (A == B)
83-451 . {
83-452 . A = B + C;
83-453 . D = E + F;
83-454 . }
83-455 .
83-456 .
83-457 . if (A gt B)
83-458 . {
83-459 . A = B + C;
83-460 . D = E + F;
83-461 . }
83-462 .
83-463 . A = B-C;
83-464 .
83-465 . if (A lt B)
83-466 . {
83-467 . A = B + C;
83-468 . D = E + F;
83-469 . }
83-470 .
83-471 . A = B/C;
83-472 . A = B-C;
83-473 . A = B*C;
83-474 . A = B/C;
83-475 . A = B*C;
83-476 . A = B/C;
83-477 .
83-478 . if (A > = B)
83-479 . {
83-480 . A = B + C;
83-481 . D = E + F;
83-482 . }
83-483 .
83-484 . A = B+C;
83-485 . A = B*C;
83-486 .
83-487 . /*
83-488 . dead_block = C * D;
83-489 . dead_block = E * F;
83-490 . */
83-491 .
83-492 .
83-493 . if (A > = B)
83-494 . {
83-495 . A = B + C;
83-496 . D = E + F;
83-497 . }
83-498 .
83-499 .
83-500 . if (A le B)
83-501 . {
83-502 . A = B + C;
83-503 . D = E + F;
83-504 . }
83-505 .
83-506 . A = B+C;
83-507 . A = B-C;
83-508 .
83-509 . if (A < B)
83-510 . {
83-511 . A = B + C;
83-512 . D = E + F;
83-513 . }
83-514 .
83-515 . A = B+C;
83-516 . free(FreePtr);
83-517 . A = B/C;
83-518 .
83-519 . if (A == B)
83-520 . {
83-521 . A = B + C;
83-522 . D = E + F;
83-523 . }
83-524 .
83-525 . A = B-C;
83-526 . A = B/C;
83-527 . A = 0x0006;
83-528 .
83-529 . switch (msaw stuff)
83-530 . {
83-531 . case one:
83-532 . {
83-533 . run_this;
83-534 . break;
83-535 . }
83-536 . case two:
83-537 . {
83-538 . run_this;
83-539 . break;
83-540 . }
83-541 . // missing default
83-542 . }
83-543 .
83-544 . A = B*C;
83-545 . // TBS - I need to figure this out
83-546 . A = B/C;
83-547 . A = B+C;
83-548 .
83-549 . if (A gt B)
83-550 . {
83-551 . A = B + C;
83-552 . D = E + F;
83-553 . }
83-554 .
83-555 . // max LOC 72
83-556 .
83-557 . }
83-558 .
83-559 .
83-560 . /*
83-561 . -----------------------------------------------------------------------------
83-562 . --| NAME: msaw.5.4
83-563 . --|
83-564 . --| ABSTRACT:
83-565 . --| This function does msaw stuff.
83-566 . --|
83-567 . --| RETURNS:
83-568 . --| NONE.
83-569 . --|
83-570 . ----------------------------------------------------------------------------
83-571 . */
83-572 . static void msaw.5.4(void)
83-573 . {
83-574 . A = B/C;
83-575 . A = 0x0006;
83-576 . A = B-C;
83-577 . A = 0x0006;
83-578 . A = B/C;
83-579 . A = B*C;
83-580 . A = B/C;
83-581 .
83-582 . if (A ge B)
83-583 . {
83-584 . A = B + C;
83-585 . D = E + F;
83-586 . }
83-587 .
83-588 . A = B+C;
83-589 . A = B*C;
83-590 . A = B*C;
83-591 . A = B-C;
83-592 .
83-593 . /*
83-594 . dead_code = B - C;
83-595 . dead_code = D - E;
83-596 . dead_code = F - G;
83-597 . */
83-598 .
83-599 .
83-600 . if (A le B)
83-601 . {
83-602 . A = B + C;
83-603 . D = E + F;
83-604 . }
83-605 .
83-606 . A = B*C;
83-607 .
83-608 . if (A != B)
83-609 . {
83-610 . A = B + C;
83-611 . D = E + F;
83-612 . }
83-613 .
83-614 . A = B+C;
83-615 . A = B-C;
83-616 . A = B/C;
83-617 .
83-618 . if (A lt B)
83-619 . {
83-620 . A = B + C;
83-621 . D = E + F;
83-622 . }
83-623 .
83-624 .
83-625 . if (A != B)
83-626 . {
83-627 . A = B + C;
83-628 . D = E + F;
83-629 . }
83-630 .
83-631 .
83-632 . if (A gt B)
83-633 . {
83-634 . A = B + C;
83-635 . D = E + F;
83-636 . }
83-637 .
83-638 .
83-639 . switch (msaw stuff)
83-640 . {
83-641 . case one:
83-642 . {
83-643 . run_this;
83-644 . break;
83-645 . }
83-646 . case two:
83-647 . {
83-648 . run_this;
83-649 . break;
83-650 . }
83-651 . default:
83-652 . {
83-653 . // missing error call
83-654 . }
83-655 . }
83-656 .
83-657 . A = B*C;
83-658 . A = 0x0006;
83-659 . A = B+C;
83-660 . A = B+C;
83-661 . A = B*C;
83-662 . A = B-C;
83-663 . A = B/C;
83-664 . A = B-C;
83-665 . A = B-C;
83-666 . /* LE SV TOC-2229 this is a msaw-05.4.28 req to enable*/
83-667 . A = B+C;
83-668 . A = B/C;
83-669 . A = B+C;
83-670 .
83-671 . if (A ge B)
83-672 . {
83-673 . A = B + C;
83-674 . D = E + F;
83-675 . }
83-676 .
83-677 . A = B/C;
83-678 .
83-679 . if (A != B)
83-680 . {
83-681 . A = B + C;
83-682 . D = E + F;
83-683 . }
83-684 .
83-685 . A = B+C;
83-686 .
83-687 . if (A eq B)
83-688 . {
83-689 . A = B + C;
83-690 . D = E + F;
83-691 . }
83-692 .
83-693 . A = B*C;
83-694 .
83-695 . switch (msaw stuff)
83-696 . {
83-697 . case one:
83-698 . {
83-699 . run_this;
83-700 . break;
83-701 . }
83-702 . case two:
83-703 . {
83-704 . run_this;
83-705 . break;
83-706 . }
83-707 . default:
83-708 . {
83-709 . SwError;
83-710 . }
83-711 . }
83-712 .
83-713 . A = B+C;
83-714 . A = B+C;
83-715 . /* LE SV TOC-2230 this is a msaw-05.4.40 req to check unix*/
83-716 . A = B/C;
83-717 . A = B+C;
83-718 . A = B/C;
83-719 .
83-720 . if (A > = B)
83-721 . {
83-722 . A = B + C;
83-723 . D = E + F;
83-724 . }
83-725 .
83-726 . A = B*C;
83-727 . A = B*C;
83-728 . A = B*C;
83-729 . A = B*C;
83-730 .
83-731 . if (A ne B)
83-732 . {
83-733 . A = B + C;
83-734 . D = E + F;
83-735 . }
83-736 .
83-737 . A = B+C;
83-738 . /* LE SV TOC-2231 this is a msaw-05.4.50 req to reject*/
83-739 . A = B/C;
83-740 .
83-741 . if (A == B)
83-742 . {
83-743 . A = B + C;
83-744 . D = E + F;
83-745 . }
83-746 .
83-747 .
83-748 . if (A != B)
83-749 . {
83-750 . A = B + C;
83-751 . D = E + F;
83-752 . }
83-753 .
83-754 .
83-755 . if (A ne B)
83-756 . {
83-757 . A = B + C;
83-758 . D = E + F;
83-759 . }
83-760 .
83-761 . A = B*C;
83-762 . A = B/C;
83-763 . A = B*C;
83-764 . A = B-C;
83-765 . A = B-C;
83-766 .
83-767 . if (A != B)
83-768 . {
83-769 . A = B + C;
83-770 . D = E + F;
83-771 . }
83-772 .
83-773 . A = B*C;
83-774 . A = B-C;
83-775 . A = 0x0001;
83-776 .
83-777 . if (A eq B)
83-778 . {
83-779 . A = B + C;
83-780 . D = E + F;
83-781 . }
83-782 .
83-783 . A = B/C;
83-784 . A = B+C;
83-785 . A = B-C;
83-786 . A = B+C;
83-787 . /* LE SV TOC-2232 this is a msaw-05.4.67 req to inhibit*/
83-788 . A = B-C;
83-789 .
83-790 . if (A < = B)
83-791 . {
83-792 . A = B + C;
83-793 . D = E + F;
83-794 . }
83-795 .
83-796 . A = B/C;
83-797 . A = B-C;
83-798 .
83-799 . if (A < = B)
83-800 . {
83-801 . A = B + C;
83-802 . D = E + F;
83-803 . }
83-804 .
83-805 .
83-806 . switch (msaw stuff)
83-807 . {
83-808 . case one:
83-809 . {
83-810 . run_this;
83-811 . break;
83-812 . }
83-813 . case two:
83-814 . {
83-815 . run_this;
83-816 . break;
83-817 . }
83-818 . default:
83-819 . {
83-820 . SwError;
83-821 . }
83-822 . }
83-823 .
83-824 . A = B-C;
83-825 . A = B-C;
83-826 . // max LOC 74
83-827 .
83-828 . }
83-829 .
83 83 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-05.c
84 84 Source: source/ft-app/ft-app-B1.0/msaw/msaw-06.c
84-0 . /*
84-1 . ----------------------------------------------------------------------------
84-2 . --| BEGIN PROLOGUE
84-3 . --|
84-4 . --| CLASSIFICATION: UNCLASSIFIED
84-5 . --|
84-6 . --| FILE NAME: msaw-06.c
84-7 . --|
84-8 . --| ABSTRACT:
84-9 . --| This file contains the 5 functions that do file msaw stuff.
84-10 . --|
84-11 . --| HISTORY:
84-12 . --| CCCQ_NAME:
84-13 . --| CCCQ_VER:
84-14 . --|
84-15 . --| END PROLOGUE
84-16 . ----------------------------------------------------------------------------
84-17 . */
84-18 .
84-19 . #include B;
84-20 . char D;
84-21 . char D;
84-22 . #define C;
84-23 . #define C;
84-24 .
84-25 .
84-26 .
84-27 . /*
84-28 . -----------------------------------------------------------------------------
84-29 . --| NAME: msaw.6.1
84-30 . --|
84-31 . --| ABSTRACT:
84-32 . --| This function does msaw stuff.
84-33 . --|
84-34 . --| RETURNS:
84-35 . --| NONE.
84-36 . --|
84-37 . ----------------------------------------------------------------------------
84-38 . */
84-39 . static void msaw.6.1(void)
84-40 . {
84-41 . A = B*C;
84-42 . A = B-C;
84-43 . A = B+C;
84-44 . A = B/C;
84-45 . FreePtr = HmiStringPtr;
84-46 . A = B+C;
84-47 .
84-48 . if (A > B)
84-49 . {
84-50 . A = B + C;
84-51 . D = E + F;
84-52 . }
84-53 .
84-54 .
84-55 . if (A != B)
84-56 . {
84-57 . A = B + C;
84-58 . D = E + F;
84-59 . }
84-60 .
84-61 . A = B/C;
84-62 . A = B/C;
84-63 .
84-64 . if (A le B)
84-65 . {
84-66 . A = B + C;
84-67 . D = E + F;
84-68 . }
84-69 .
84-70 .
84-71 . if (A ge B)
84-72 . {
84-73 . A = B + C;
84-74 . D = E + F;
84-75 . }
84-76 .
84-77 . A = B+C;
84-78 . // max LOC 12
84-79 .
84-80 . }
84-81 .
84-82 .
84-83 . /*
84-84 . -----------------------------------------------------------------------------
84-85 . --| NAME: msaw.6.2
84-86 . --|
84-87 . --| ABSTRACT:
84-88 . --| This function does msaw stuff.
84-89 . --|
84-90 . --| RETURNS:
84-91 . --| NONE.
84-92 . --|
84-93 . ----------------------------------------------------------------------------
84-94 . */
84-95 . static void msaw.6.2(void)
84-96 . {
84-97 .
84-98 . if (A ge B)
84-99 . {
84-100 . A = B + C;
84-101 . D = E + F;
84-102 . }
84-103 .
84-104 . /* LE SV TOC-2233 this is a msaw-06.2.2 req to assign*/
84-105 . A = B*C;
84-106 . A = B*C;
84-107 . A = B/C;
84-108 .
84-109 . if (A != B)
84-110 . {
84-111 . A = B + C;
84-112 . D = E + F;
84-113 . }
84-114 .
84-115 .
84-116 . switch (msaw stuff)
84-117 . {
84-118 . case one:
84-119 . {
84-120 . run_this;
84-121 . break;
84-122 . }
84-123 . case two:
84-124 . {
84-125 . run_this;
84-126 . break;
84-127 . }
84-128 . default:
84-129 . {
84-130 . SwError;
84-131 . }
84-132 . }
84-133 .
84-134 . A = B-C;
84-135 . A = B+C;
84-136 . A = B*C;
84-137 . A = B+C;
84-138 . A = B+C;
84-139 .
84-140 . if (A lt B)
84-141 . {
84-142 . A = B + C;
84-143 . D = E + F;
84-144 . }
84-145 .
84-146 . A = B*C;
84-147 .
84-148 . if (A lt B)
84-149 . {
84-150 . A = B + C;
84-151 . D = E + F;
84-152 . }
84-153 .
84-154 . A = B*C;
84-155 . // max LOC 15
84-156 .
84-157 . }
84-158 .
84-159 .
84-160 . /*
84-161 . -----------------------------------------------------------------------------
84-162 . --| NAME: msaw.6.3
84-163 . --|
84-164 . --| ABSTRACT:
84-165 . --| This function does msaw stuff.
84-166 . --|
84-167 . --| RETURNS:
84-168 . --| NONE.
84-169 . --|
84-170 . ----------------------------------------------------------------------------
84-171 . */
84-172 . static void msaw.6.3(void)
84-173 . {
84-174 . A = B-C;
84-175 . A = B*C;
84-176 .
84-177 . switch (msaw stuff)
84-178 . {
84-179 . case one:
84-180 . {
84-181 . run_this;
84-182 . break;
84-183 . }
84-184 . case two:
84-185 . {
84-186 . run_this;
84-187 . break;
84-188 . }
84-189 . default:
84-190 . {
84-191 . SwError;
84-192 . }
84-193 . }
84-194 .
84-195 . A = B*C;
84-196 .
84-197 . if (A gt B)
84-198 . {
84-199 . A = B + C;
84-200 . D = E + F;
84-201 . }
84-202 .
84-203 . A = B-C;
84-204 . A = B-C;
84-205 .
84-206 . if (A gt B)
84-207 . {
84-208 . A = B + C;
84-209 . D = E + F;
84-210 . }
84-211 .
84-212 . A = B-C;
84-213 .
84-214 . if (veg)
84-215 . // missing curly brace
84-216 . variable = orange;
84-217 .
84-218 . A = B/C;
84-219 . A = B*C;
84-220 .
84-221 . if (A le B)
84-222 . {
84-223 . A = B + C;
84-224 . D = E + F;
84-225 . }
84-226 .
84-227 . A = B*C;
84-228 . A = B*C;
84-229 . A = 0x0008;
84-230 . A = B+C;
84-231 . A = B*C;
84-232 . /* LE SV TOC-2234 this is a msaw-06.3.17 req to process*/
84-233 .
84-234 . if ($msaw stuff > $othermsaw stuff)
84-235 . /* LE SV TOC-008 we really should log all error calls */
84-236 . {
84-237 . A = B + C;
84-238 . }
84-239 .
84-240 . A = B*C;
84-241 .
84-242 . if (A > B)
84-243 . {
84-244 . A = B + C;
84-245 . D = E + F;
84-246 . }
84-247 .
84-248 . /* LE SV TOC-2235 this is a msaw-06.3.19 req to record*/
84-249 . A = B*C;
84-250 . A = B-C;
84-251 . A = B*C;
84-252 . A = B/C;
84-253 . A = B/C;
84-254 .
84-255 . switch (msaw stuff)
84-256 . {
84-257 . case one:
84-258 . {
84-259 . run_this;
84-260 . break;
84-261 . }
84-262 . case two:
84-263 . {
84-264 . run_this;
84-265 . break;
84-266 . }
84-267 . default:
84-268 . {
84-269 . SwError;
84-270 . }
84-271 . }
84-272 .
84-273 . A = B*C;
84-274 .
84-275 . if (A != B)
84-276 . {
84-277 . A = B + C;
84-278 . D = E + F;
84-279 . }
84-280 .
84-281 . A = B+C;
84-282 .
84-283 . switch (msaw stuff)
84-284 . {
84-285 . case one:
84-286 . {
84-287 . run_this;
84-288 . break;
84-289 . }
84-290 . case two:
84-291 . {
84-292 . run_this;
84-293 . break;
84-294 . }
84-295 . default:
84-296 . {
84-297 . SwError;
84-298 . }
84-299 . }
84-300 .
84-301 . A = B*C;
84-302 . /* LE SV TOC-2236 this is a msaw-06.3.30 req to process*/
84-303 . A = B*C;
84-304 . A = B*C;
84-305 . A = B+C;
84-306 . A = B*C;
84-307 . rcv_buffer = (U16 *) alloc(size+1);
84-308 .
84-309 . if (A != B)
84-310 . {
84-311 . A = B + C;
84-312 . D = E + F;
84-313 . }
84-314 .
84-315 .
84-316 . if (A != B)
84-317 . {
84-318 . A = B + C;
84-319 . D = E + F;
84-320 . }
84-321 .
84-322 . A = B-C;
84-323 . A = B*C;
84-324 . A = B*C;
84-325 . A = B*C;
84-326 . A = B-C;
84-327 .
84-328 . if (A < B)
84-329 . {
84-330 . A = B + C;
84-331 . D = E + F;
84-332 . }
84-333 .
84-334 .
84-335 . if ($msaw stuff > $othermsaw stuff)
84-336 . /* LE SV TOC-008 we really should log all error calls */
84-337 . {
84-338 . A = B + C;
84-339 . }
84-340 .
84-341 . A = B-C;
84-342 . A = B+C;
84-343 . A = B-C;
84-344 . A = B/C;
84-345 .
84-346 . if (A eq B)
84-347 . {
84-348 . A = B + C;
84-349 . D = E + F;
84-350 . }
84-351 .
84-352 . A = B+C;
84-353 . A = B-C;
84-354 . A = B*C;
84-355 . A = B-C;
84-356 . A = B-C;
84-357 .
84-358 . if (A < B)
84-359 . {
84-360 . A = B + C;
84-361 . D = E + F;
84-362 . }
84-363 .
84-364 . A = B+C;
84-365 . A = B*C;
84-366 . A = B-C;
84-367 .
84-368 . if (A != B)
84-369 . {
84-370 . A = B + C;
84-371 . D = E + F;
84-372 . }
84-373 .
84-374 . A = B+C;
84-375 . // max LOC 57
84-376 .
84-377 . }
84-378 .
84-379 .
84-380 . /*
84-381 . -----------------------------------------------------------------------------
84-382 . --| NAME: msaw.6.4
84-383 . --|
84-384 . --| ABSTRACT:
84-385 . --| This function does msaw stuff.
84-386 . --|
84-387 . --| RETURNS:
84-388 . --| NONE.
84-389 . --|
84-390 . ----------------------------------------------------------------------------
84-391 . */
84-392 . static void msaw.6.4(void)
84-393 . {
84-394 . A = B-C;
84-395 . A = B/C;
84-396 . FreePtr = HmiStringPtr;
84-397 . A = B*C;
84-398 . A = B+C;
84-399 .
84-400 . if (A < B)
84-401 . {
84-402 . A = B + C;
84-403 . D = E + F;
84-404 . }
84-405 .
84-406 . A = B-C;
84-407 . A = B/C;
84-408 . A = B/C;
84-409 . /* LE SV TOC-2237 this is a msaw-06.4.9 req to check unix*/
84-410 .
84-411 . if (A == B)
84-412 . {
84-413 . A = B + C;
84-414 . D = E + F;
84-415 . }
84-416 .
84-417 . /* LE SV TOC-2238 this is a msaw-06.4.10 req to increment*/
84-418 .
84-419 . if (A < = B)
84-420 . {
84-421 . A = B + C;
84-422 . D = E + F;
84-423 . }
84-424 .
84-425 . A = B-C;
84-426 . A = B*C;
84-427 . A = B-C;
84-428 . A = B*C;
84-429 . A = B*C;
84-430 . A = B/C;
84-431 . A = B*C;
84-432 .
84-433 . if (A le B)
84-434 . {
84-435 . A = B + C;
84-436 . D = E + F;
84-437 . }
84-438 .
84-439 . A = B-C;
84-440 .
84-441 . if (A lt B)
84-442 . {
84-443 . A = B + C;
84-444 . D = E + F;
84-445 . }
84-446 .
84-447 . /* LE SV TOC-2239 this is a msaw-06.4.21 req to call isr*/
84-448 .
84-449 . switch (msaw stuff)
84-450 . {
84-451 . case one:
84-452 . {
84-453 . switch (nested)
84-454 . {
84-455 . case:
84-456 . X = Y + Z;
84-457 . case:
84-458 . X = Y + Z;
84-459 . default:
84-460 . SwError;
84-461 . }
84-462 . }
84-463 . case two:
84-464 . {
84-465 . run_this;
84-466 . break;
84-467 . }
84-468 . default:
84-469 . {
84-470 . SwError;
84-471 . }
84-472 . }
84-473 .
84-474 . A = B*C;
84-475 .
84-476 . if (A < B)
84-477 . {
84-478 . A = B + C;
84-479 . D = E + F;
84-480 . }
84-481 .
84-482 . // TBD - what do I do now
84-483 . A = B-C;
84-484 .
84-485 . if (A > = B)
84-486 . {
84-487 . A = B + C;
84-488 . D = E + F;
84-489 . }
84-490 .
84-491 . /* LE SV TOC-2240 this is a msaw-06.4.25 req to set RTC*/
84-492 . A = B*C;
84-493 . A = B/C;
84-494 .
84-495 . if (A != B)
84-496 . {
84-497 . A = B + C;
84-498 . D = E + F;
84-499 . }
84-500 .
84-501 . A = B*C;
84-502 . A = B*C;
84-503 . A = B+C;
84-504 . A = B+C;
84-505 . A = B-C;
84-506 .
84-507 . if (A lt B)
84-508 . {
84-509 . A = B + C;
84-510 . D = E + F;
84-511 . }
84-512 .
84-513 . A = B-C;
84-514 . A = B-C;
84-515 . A = B/C;
84-516 . A = B*C;
84-517 . A = B*C;
84-518 . A = B+C;
84-519 .
84-520 . if (A eq B)
84-521 . {
84-522 . A = B + C;
84-523 . D = E + F;
84-524 . }
84-525 .
84-526 . A = B+C;
84-527 . A = B-C;
84-528 . A = 0x0003;
84-529 . A = B-C;
84-530 . A = B*C;
84-531 . A = B-C;
84-532 . A = B/C;
84-533 . A = B-C;
84-534 .
84-535 . if (A ge B)
84-536 . {
84-537 . A = B + C;
84-538 . D = E + F;
84-539 . }
84-540 .
84-541 . A = B*C;
84-542 . A = B+C;
84-543 .
84-544 . if (A ne B)
84-545 . {
84-546 . A = B + C;
84-547 . D = E + F;
84-548 . }
84-549 .
84-550 . A = B+C;
84-551 .
84-552 . if (A < B)
84-553 . {
84-554 . A = B + C;
84-555 . D = E + F;
84-556 . }
84-557 .
84-558 . A = B*C;
84-559 . A = B*C;
84-560 .
84-561 . if (A == B)
84-562 . {
84-563 . A = B + C;
84-564 . D = E + F;
84-565 . }
84-566 .
84-567 . A = B/C;
84-568 . A = B/C;
84-569 .
84-570 . if (A > B)
84-571 . {
84-572 . A = B + C;
84-573 . D = E + F;
84-574 . }
84-575 .
84-576 . A = B*C;
84-577 . A = B*C;
84-578 . A = B/C;
84-579 . A = B/C;
84-580 . A = 0x0009;
84-581 . A = B-C;
84-582 . A = B+C;
84-583 .
84-584 . if (A le B)
84-585 . {
84-586 . A = B + C;
84-587 . D = E + F;
84-588 . }
84-589 .
84-590 . A = 0x0006;
84-591 .
84-592 . if (A < B)
84-593 . {
84-594 . A = B + C;
84-595 . D = E + F;
84-596 . }
84-597 .
84-598 . // max LOC 67
84-599 .
84-600 . }
84-601 .
84-602 .
84-603 . /*
84-604 . -----------------------------------------------------------------------------
84-605 . --| NAME: msaw.6.5
84-606 . --|
84-607 . --| ABSTRACT:
84-608 . --| This function does msaw stuff.
84-609 . --|
84-610 . --| RETURNS:
84-611 . --| NONE.
84-612 . --|
84-613 . ----------------------------------------------------------------------------
84-614 . */
84-615 . static void msaw.6.5(void)
84-616 . {
84-617 . do forever;
84-618 .
84-619 . if (A gt B)
84-620 . {
84-621 . A = B + C;
84-622 . D = E + F;
84-623 . }
84-624 .
84-625 .
84-626 . if (A < = B)
84-627 . {
84-628 . A = B + C;
84-629 . D = E + F;
84-630 . }
84-631 .
84-632 .
84-633 . if (A gt B)
84-634 . {
84-635 . A = B + C;
84-636 . D = E + F;
84-637 . }
84-638 .
84-639 . A = B/C;
84-640 .
84-641 . if (A le B)
84-642 . {
84-643 . A = B + C;
84-644 . D = E + F;
84-645 . }
84-646 .
84-647 .
84-648 . if (A lt B)
84-649 . {
84-650 . A = B + C;
84-651 . D = E + F;
84-652 . }
84-653 .
84-654 . A = B+C;
84-655 . A = B/C;
84-656 .
84-657 . if (A ge B)
84-658 . {
84-659 . A = B + C;
84-660 . D = E + F;
84-661 . }
84-662 .
84-663 .
84-664 . if (A > B)
84-665 . {
84-666 . A = B + C;
84-667 . D = E + F;
84-668 . }
84-669 .
84-670 .
84-671 . /* dead_code = B + C;
84-672 . dead_code = D + E;
84-673 . dead_code = F + G; */
84-674 .
84-675 . A = B+C;
84-676 . A = B-C;
84-677 . /* LE SV TOC-2241 this is a msaw-06.5.13 req to translate*/
84-678 . A = B*C;
84-679 .
84-680 . if (A eq B)
84-681 . {
84-682 . A = B + C;
84-683 . D = E + F;
84-684 . }
84-685 .
84-686 .
84-687 . if (A ne B)
84-688 . {
84-689 . A = B + C;
84-690 . D = E + F;
84-691 . }
84-692 .
84-693 . A = B-C;
84-694 . A = B-C;
84-695 . A = B-C;
84-696 . A = B/C;
84-697 . A = B+C;
84-698 . /* LE SV TOC-2242 this is a msaw-06.5.21 req to call admin*/
84-699 . A = B-C;
84-700 . A = B-C;
84-701 . A = B*C;
84-702 . A = B-C;
84-703 . /* LE SV TOC-2243 this is a msaw-06.5.25 req to convert*/
84-704 . A = B+C;
84-705 . A = B*C;
84-706 . A = B/C;
84-707 . A = B-C;
84-708 . A = B-C;
84-709 . A = B+C;
84-710 .
84-711 . if (A gt B)
84-712 . {
84-713 . A = B + C;
84-714 . D = E + F;
84-715 . }
84-716 .
84-717 . A = B/C;
84-718 . A = B+C;
84-719 .
84-720 . if (A < = B)
84-721 . {
84-722 . A = B + C;
84-723 . D = E + F;
84-724 . }
84-725 .
84-726 .
84-727 . if (A le B)
84-728 . {
84-729 . A = B + C;
84-730 . D = E + F;
84-731 . }
84-732 .
84-733 . A = B-C;
84-734 . A = B/C;
84-735 . A = B*C;
84-736 . do forever;
84-737 .
84-738 . if (A == B)
84-739 . {
84-740 . A = B + C;
84-741 . D = E + F;
84-742 . }
84-743 .
84-744 . /* LE SV TOC-2244 this is a msaw-06.5.40 req to call admin*/
84-745 . A = B+C;
84-746 .
84-747 . if (A < B)
84-748 . {
84-749 . A = B + C;
84-750 . D = E + F;
84-751 . }
84-752 .
84-753 . A = B+C;
84-754 .
84-755 . if (A != B)
84-756 . {
84-757 . A = B + C;
84-758 . D = E + F;
84-759 . }
84-760 .
84-761 . // max LOC 43
84-762 .
84-763 . }
84-764 .
84 84 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-06.c
85 85 Source: source/ft-app/ft-app-B1.0/msaw/msaw-07.c
85-0 . /*
85-1 . ----------------------------------------------------------------------------
85-2 . --| BEGIN PROLOGUE
85-3 . --|
85-4 . --| CLASSIFICATION: UNCLASSIFIED
85-5 . --|
85-6 . --| FILE NAME: msaw-07.c
85-7 . --|
85-8 . --| ABSTRACT:
85-9 . --| This file contains the 2 functions that do file msaw stuff.
85-10 . --|
85-11 . --| HISTORY:
85-12 . --| CCCQ_NAME:
85-13 . --| CCCQ_VER:
85-14 . --|
85-15 . --| END PROLOGUE
85-16 . ----------------------------------------------------------------------------
85-17 . */
85-18 .
85-19 . #include A;
85-20 . float B;
85-21 . #define B;
85-22 . #define A;
85-23 .
85-24 .
85-25 .
85-26 . /*
85-27 . -----------------------------------------------------------------------------
85-28 . --| NAME: msaw.7.1
85-29 . --|
85-30 . --| ABSTRACT:
85-31 . --| This function does msaw stuff.
85-32 . --|
85-33 . --| RETURNS:
85-34 . --| NONE.
85-35 . --|
85-36 . ----------------------------------------------------------------------------
85-37 . */
85-38 . static void msaw.7.1(void)
85-39 . {
85-40 . A = B-C;
85-41 . A = B-C;
85-42 . A = 0x0007;
85-43 . A = B+C;
85-44 . A = B-C;
85-45 .
85-46 . if (A < B)
85-47 . {
85-48 . A = B + C;
85-49 . D = E + F;
85-50 . }
85-51 .
85-52 . /* LE SV TOC-2245 this is a msaw-07.1.6 req to halt*/
85-53 . A = B*C;
85-54 . A = B-C;
85-55 . A = B*C;
85-56 . A = B*C;
85-57 .
85-58 . switch (msaw stuff)
85-59 . {
85-60 . case:
85-61 . case:
85-62 . // stacked case statements but only if there is a new line in between
85-63 .
85-64 . case:
85-65 . case:
85-66 . case:
85-67 . {
85-68 . run_this;
85-69 . break;
85-70 . }
85-71 . default:
85-72 . {
85-73 . halt;
85-74 . }
85-75 . }
85-76 .
85-77 .
85-78 . if (A ne B)
85-79 . {
85-80 . A = B + C;
85-81 . D = E + F;
85-82 . }
85-83 .
85-84 .
85-85 . if (A < = B)
85-86 . {
85-87 . A = B + C;
85-88 . D = E + F;
85-89 . }
85-90 .
85-91 . A = B/C;
85-92 . A = B/C;
85-93 .
85-94 . if (A gt B)
85-95 . {
85-96 . A = B + C;
85-97 . D = E + F;
85-98 . }
85-99 .
85-100 . A = B+C;
85-101 . A = B/C;
85-102 . A = B-C;
85-103 . A = B-C;
85-104 . A = B-C;
85-105 . A = B-C;
85-106 .
85-107 . if (A ne B)
85-108 . {
85-109 . A = B + C;
85-110 . D = E + F;
85-111 . }
85-112 .
85-113 . A = B+C;
85-114 . /* LE SV TOC-2246 this is a msaw-07.1.23 req to recover*/
85-115 . A = (long)B + C;
85-116 . A = B-C;
85-117 . /* LE SV TOC-2247 this is a msaw-07.1.24 req to audit*/
85-118 . A = B/C;
85-119 .
85-120 . if (A eq B)
85-121 . {
85-122 . A = B + C;
85-123 . D = E + F;
85-124 . }
85-125 .
85-126 .
85-127 . if (A lt B)
85-128 . {
85-129 . A = B + C;
85-130 . D = E + F;
85-131 . }
85-132 .
85-133 .
85-134 . if (A lt B)
85-135 . {
85-136 . A = B + C;
85-137 . D = E + F;
85-138 . }
85-139 .
85-140 . A = B*C;
85-141 . A = B+C;
85-142 .
85-143 . switch (msaw stuff)
85-144 . {
85-145 . case one:
85-146 . {
85-147 . run_this;
85-148 . break;
85-149 . }
85-150 . case two:
85-151 . {
85-152 . run_this;
85-153 . break;
85-154 . }
85-155 . // missing default
85-156 . }
85-157 .
85-158 .
85-159 . if (A gt B)
85-160 . {
85-161 . A = B + C;
85-162 . D = E + F;
85-163 . }
85-164 .
85-165 .
85-166 . if (A == B)
85-167 . {
85-168 . A = B + C;
85-169 . D = E + F;
85-170 . }
85-171 .
85-172 . A = B/C;
85-173 .
85-174 . if (A < = B)
85-175 . {
85-176 . A = B + C;
85-177 . D = E + F;
85-178 . }
85-179 .
85-180 .
85-181 . if (A < B)
85-182 . {
85-183 . A = B + C;
85-184 . D = E + F;
85-185 . }
85-186 .
85-187 . /* LE SV TOC-2248 this is a msaw-07.1.35 req to process*/
85-188 . A = B*C;
85-189 . A = B/C;
85-190 .
85-191 . if (A != B)
85-192 . {
85-193 . A = B + C;
85-194 . D = E + F;
85-195 . }
85-196 .
85-197 . A = B*C;
85-198 . A = B+C;
85-199 . // max LOC 39
85-200 .
85-201 . }
85-202 .
85-203 .
85-204 . /*
85-205 . -----------------------------------------------------------------------------
85-206 . --| NAME: msaw.7.2
85-207 . --|
85-208 . --| ABSTRACT:
85-209 . --| This function does msaw stuff.
85-210 . --|
85-211 . --| RETURNS:
85-212 . --| NONE.
85-213 . --|
85-214 . ----------------------------------------------------------------------------
85-215 . */
85-216 . static void msaw.7.2(void)
85-217 . {
85-218 . A = B-C;
85-219 . A = B+C;
85-220 .
85-221 . if (A != B)
85-222 . {
85-223 . A = B + C;
85-224 . D = E + F;
85-225 . }
85-226 .
85-227 .
85-228 . if (A lt B)
85-229 . {
85-230 . A = B + C;
85-231 . D = E + F;
85-232 . }
85-233 .
85-234 .
85-235 . if (A != B)
85-236 . {
85-237 . A = B + C;
85-238 . D = E + F;
85-239 . }
85-240 .
85-241 . A = B-C;
85-242 . A = B-C;
85-243 .
85-244 . if (A gt B)
85-245 . {
85-246 . A = B + C;
85-247 . D = E + F;
85-248 . }
85-249 .
85-250 .
85-251 . if (A lt B)
85-252 . {
85-253 . A = B + C;
85-254 . D = E + F;
85-255 . }
85-256 .
85-257 . /* LE SV TOC-2249 this is a msaw-07.2.10 req to validate*/
85-258 . A = B*C;
85-259 .
85-260 . if (A lt B)
85-261 . {
85-262 . A = B + C;
85-263 . D = E + F;
85-264 . }
85-265 .
85-266 .
85-267 . if (A eq B)
85-268 . {
85-269 . A = B + C;
85-270 . D = E + F;
85-271 . }
85-272 .
85-273 . A = B*C;
85-274 .
85-275 . if (A < B)
85-276 . {
85-277 . A = B + C;
85-278 . D = E + F;
85-279 . }
85-280 .
85-281 .
85-282 . if (A > B)
85-283 . {
85-284 . A = B + C;
85-285 . D = E + F;
85-286 . }
85-287 .
85-288 .
85-289 . switch (msaw stuff)
85-290 . {
85-291 . case one:
85-292 . {
85-293 . run_this;
85-294 . break;
85-295 . }
85-296 . case two:
85-297 . {
85-298 . run_this;
85-299 . break;
85-300 . }
85-301 . default:
85-302 . {
85-303 . SwError;
85-304 . }
85-305 . }
85-306 .
85-307 . A = B+C;
85-308 . A = B*C;
85-309 .
85-310 . if (A lt B)
85-311 . {
85-312 . A = B + C;
85-313 . D = E + F;
85-314 . }
85-315 .
85-316 . A = B+C;
85-317 .
85-318 . switch (msaw stuff)
85-319 . {
85-320 . case one:
85-321 . {
85-322 . run_this;
85-323 . break;
85-324 . }
85-325 . case two:
85-326 . {
85-327 . run_this;
85-328 . break;
85-329 . }
85-330 . default:
85-331 . {
85-332 . SwError;
85-333 . }
85-334 . }
85-335 .
85-336 . A = 0x0006;
85-337 .
85-338 . if (A < = B)
85-339 . {
85-340 . A = B + C;
85-341 . D = E + F;
85-342 . }
85-343 .
85-344 .
85-345 . if (A != B)
85-346 . {
85-347 . A = B + C;
85-348 . D = E + F;
85-349 . }
85-350 .
85-351 . A = B*C;
85-352 . A = B+C;
85-353 . A = B*C;
85-354 . A = B/C;
85-355 . A = B*C;
85-356 .
85-357 . /* dead_block = C * D;
85-358 . dead_block = E * F; */
85-359 .
85-360 . A = B*C;
85-361 . A = B*C;
85-362 . A = B+C;
85-363 .
85-364 . switch (msaw stuff)
85-365 . {
85-366 . case one:
85-367 . {
85-368 . run_this;
85-369 . // missing break
85-370 . }
85-371 . case two:
85-372 . {
85-373 . run_this;
85-374 . break;
85-375 . }
85-376 . default:
85-377 . {
85-378 . SwError;
85-379 . }
85-380 . }
85-381 .
85-382 . A = B*C;
85-383 .
85-384 . if (A ge B)
85-385 . {
85-386 . A = B + C;
85-387 . D = E + F;
85-388 . }
85-389 .
85-390 . A = B+C;
85-391 . A = B*C;
85-392 . A = B*C;
85-393 . A = B/C;
85-394 . A = B*C;
85-395 . A = B+C;
85-396 . A = B-C;
85-397 . A = B-C;
85-398 . A = B-C;
85-399 . A = B*C;
85-400 . A = B-C;
85-401 . A = B/C;
85-402 . A = B-C;
85-403 . A = B+C;
85-404 . /* LE SV TOC-2250 this is a msaw-07.2.48 req to transform*/
85-405 . A = B+C;
85-406 .
85-407 . if (A lt B)
85-408 . {
85-409 . A = B + C;
85-410 . D = E + F;
85-411 . }
85-412 .
85-413 . A = B-C;
85-414 .
85-415 . if (A eq B)
85-416 . {
85-417 . A = B + C;
85-418 . D = E + F;
85-419 . }
85-420 .
85-421 . /* LE SV TOC-2251 this is a msaw-07.2.52 req to set RTC*/
85-422 .
85-423 . if (A > B)
85-424 . {
85-425 . A = B + C;
85-426 . D = E + F;
85-427 . }
85-428 .
85-429 . A = B/C;
85-430 . A = B+C;
85-431 . // max LOC 54
85-432 .
85-433 . }
85-434 .
85 85 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-07.c
86 86 Source: source/ft-app/ft-app-B1.0/msaw/msaw-08.c
86-0 . /*
86-1 . ----------------------------------------------------------------------------
86-2 . --| BEGIN PROLOGUE
86-3 . --|
86-4 . --| CLASSIFICATION: UNCLASSIFIED
86-5 . --|
86-6 . --| FILE NAME: msaw-08.c
86-7 . --|
86-8 . --| ABSTRACT:
86-9 . --| This file contains the 1 functions that do file msaw stuff.
86-10 . --|
86-11 . --| HISTORY:
86-12 . --| CCCQ_NAME:
86-13 . --| CCCQ_VER:
86-14 . --|
86-15 . --| END PROLOGUE
86-16 . ----------------------------------------------------------------------------
86-17 . */
86-18 .
86-19 . #define D;
86-20 .
86-21 .
86-22 .
86-23 . /*
86-24 . -----------------------------------------------------------------------------
86-25 . --| NAME: msaw.8.1
86-26 . --|
86-27 . --| ABSTRACT:
86-28 . --| This function does msaw stuff.
86-29 . --|
86-30 . --| RETURNS:
86-31 . --| NONE.
86-32 . --|
86-33 . ----------------------------------------------------------------------------
86-34 . */
86-35 . static void msaw.8.1(void)
86-36 . {
86-37 . A = B/C;
86-38 . A = B*C;
86-39 . A = B-C;
86-40 . A = B*C;
86-41 . /* LE SV TOC-2252 this is a msaw-08.1.5 req to fail*/
86-42 .
86-43 . if (A eq B)
86-44 . {
86-45 . A = B + C;
86-46 . D = E + F;
86-47 . }
86-48 .
86-49 . A = B/C;
86-50 .
86-51 . if (A > = B)
86-52 . {
86-53 . A = B + C;
86-54 . D = E + F;
86-55 . }
86-56 .
86-57 . A = B-C;
86-58 .
86-59 . if (A le B)
86-60 . {
86-61 . A = B + C;
86-62 . D = E + F;
86-63 . }
86-64 .
86-65 . A = B/C;
86-66 . A = B/C;
86-67 .
86-68 . if (A == B)
86-69 . {
86-70 . A = B + C;
86-71 . D = E + F;
86-72 . }
86-73 .
86-74 . A = B*C;
86-75 .
86-76 . /* dead_block = C * D;
86-77 . dead_block = E * F; */
86-78 .
86-79 .
86-80 . if (A gt B)
86-81 . {
86-82 . A = B + C;
86-83 . D = E + F;
86-84 . }
86-85 .
86-86 . A = B+C;
86-87 . rcv_buffer = (U16 *) alloc(size+1);
86-88 .
86-89 . if (A le B)
86-90 . {
86-91 . A = B + C;
86-92 . D = E + F;
86-93 . }
86-94 .
86-95 .
86-96 . if (A < = B)
86-97 . {
86-98 . A = B + C;
86-99 . D = E + F;
86-100 . }
86-101 .
86-102 . A = B-C;
86-103 .
86-104 . if (A lt B)
86-105 . {
86-106 . A = B + C;
86-107 . D = E + F;
86-108 . }
86-109 .
86-110 . A = B*C;
86-111 . A = B+C;
86-112 . /* LE SV TOC-2253 this is a msaw-08.1.22 req to fail*/
86-113 . A = B/C;
86-114 .
86-115 . if (A le B)
86-116 . {
86-117 . A = B + C;
86-118 . D = E + F;
86-119 . }
86-120 .
86-121 .
86-122 . if (A < = B)
86-123 . {
86-124 . A = B + C;
86-125 . D = E + F;
86-126 . }
86-127 .
86-128 . A = B-C;
86-129 . A = B/C;
86-130 .
86-131 . if (A < = B)
86-132 . {
86-133 . A = B + C;
86-134 . D = E + F;
86-135 . }
86-136 .
86-137 .
86-138 . if (A < B)
86-139 . {
86-140 . A = B + C;
86-141 . D = E + F;
86-142 . }
86-143 .
86-144 . A = B-C;
86-145 .
86-146 . if (A < B)
86-147 . {
86-148 . A = B + C;
86-149 . D = E + F;
86-150 . }
86-151 .
86-152 . A = B+C;
86-153 . A = B/C;
86-154 . A = B*C;
86-155 . A = B/C;
86-156 .
86-157 . if (A le B)
86-158 . {
86-159 . A = B + C;
86-160 . D = E + F;
86-161 . }
86-162 .
86-163 . A = B-C;
86-164 .
86-165 . if (A le B)
86-166 . {
86-167 . A = B + C;
86-168 . D = E + F;
86-169 . }
86-170 .
86-171 . A = B-C;
86-172 . A = B/C;
86-173 . A = B*C;
86-174 . A = B*C;
86-175 . A = B*C;
86-176 . A = B*C;
86-177 . A = B+C;
86-178 . A = B-C;
86-179 . A = B-C;
86-180 . A = B/C;
86-181 . A = B+C;
86-182 . /* LE SV TOC-2254 this is a msaw-08.1.49 req to assign*/
86-183 . A = B-C;
86-184 . A = B-C;
86-185 .
86-186 . if ($msaw stuff > $othermsaw stuff)
86-187 . /* LE SV TOC-008 we really should log all error calls */
86-188 . {
86-189 . A = B + C;
86-190 . }
86-191 .
86-192 .
86-193 . if (A > B)
86-194 . {
86-195 . A = B + C;
86-196 . D = E + F;
86-197 . }
86-198 .
86-199 . A = 0x0002;
86-200 . A = B/C;
86-201 . A = B+C;
86-202 . // max LOC 53
86-203 .
86-204 . }
86-205 .
86 86 Result: result/source/ft-app/ft-app-B1.0/msaw/msaw-08.c
87 87 Source: source/ft-app/ft-app-B1.0/pwr/pwr-01.c
87-0 . /*
87-1 . ----------------------------------------------------------------------------
87-2 . --| BEGIN PROLOGUE
87-3 . --|
87-4 . --| CLASSIFICATION: UNCLASSIFIED
87-5 . --|
87-6 . --| FILE NAME: pwr-01.c
87-7 . --|
87-8 . --| ABSTRACT:
87-9 . --| This file contains the 1 functions that do file pwr stuff.
87-10 . --|
87-11 . --| HISTORY:
87-12 . --| CCCQ_NAME:
87-13 . --| CCCQ_VER:
87-14 . --|
87-15 . --| END PROLOGUE
87-16 . ----------------------------------------------------------------------------
87-17 . */
87-18 .
87-19 . char D;
87-20 . #include C;
87-21 . char D;
87-22 . #define C;
87-23 . #define A;
87-24 .
87-25 .
87-26 .
87-27 . /*
87-28 . -----------------------------------------------------------------------------
87-29 . --| NAME: pwr.1.1
87-30 . --|
87-31 . --| ABSTRACT:
87-32 . --| This function does pwr stuff.
87-33 . --|
87-34 . --| RETURNS:
87-35 . --| NONE.
87-36 . --|
87-37 . ----------------------------------------------------------------------------
87-38 . */
87-39 . static void pwr.1.1(void)
87-40 . {
87-41 . A = B+C;
87-42 . A = B/C;
87-43 .
87-44 . switch (pwr stuff)
87-45 . {
87-46 . case one:
87-47 . {
87-48 . run_this;
87-49 . break;
87-50 . }
87-51 . case two:
87-52 . {
87-53 . run_this;
87-54 . break;
87-55 . }
87-56 . default:
87-57 . {
87-58 . SwError;
87-59 . }
87-60 . }
87-61 .
87-62 . /* LE SV TOC-2401 this is a pwr-01.1.4 req to store*/
87-63 . A = B/C;
87-64 . A = B*C;
87-65 . A = B-C;
87-66 . A = B-C;
87-67 . A = B*C;
87-68 .
87-69 . if (A lt B)
87-70 . {
87-71 . A = B + C;
87-72 . D = E + F;
87-73 . }
87-74 .
87-75 .
87-76 . /*
87-77 . dead_block = C * D;
87-78 . dead_block = E * F;
87-79 . */
87-80 .
87-81 .
87-82 . if (A > = B)
87-83 . {
87-84 . A = B + C;
87-85 . D = E + F;
87-86 . }
87-87 .
87-88 . A = B*C;
87-89 .
87-90 . if (A ne B)
87-91 . {
87-92 . A = B + C;
87-93 . D = E + F;
87-94 . }
87-95 .
87-96 . A = B*C;
87-97 .
87-98 . if (A lt B)
87-99 . {
87-100 . A = B + C;
87-101 . D = E + F;
87-102 . }
87-103 .
87-104 . // TBD - what do I do now
87-105 . A = B/C;
87-106 . A = B+C;
87-107 . A = B+C;
87-108 .
87-109 . switch (pwr stuff)
87-110 . {
87-111 . case one:
87-112 . {
87-113 . run_this;
87-114 . break;
87-115 . }
87-116 . case two:
87-117 . {
87-118 . run_this;
87-119 . break;
87-120 . }
87-121 . default:
87-122 . {
87-123 . SwError;
87-124 . }
87-125 . }
87-126 .
87-127 . A = B*C;
87-128 . A = B+C;
87-129 . A = B/C;
87-130 . A = B-C;
87-131 . A = B*C;
87-132 . A = B-C;
87-133 .
87-134 . if (A eq B)
87-135 . {
87-136 . A = B + C;
87-137 . D = E + F;
87-138 . }
87-139 .
87-140 . A = B*C;
87-141 . A = B-C;
87-142 . A = B*C;
87-143 .
87-144 . if (A lt B)
87-145 . {
87-146 . A = B + C;
87-147 . D = E + F;
87-148 . }
87-149 .
87-150 .
87-151 . if (A gt B)
87-152 . {
87-153 . A = B + C;
87-154 . D = E + F;
87-155 . }
87-156 .
87-157 .
87-158 . if (A gt B)
87-159 . {
87-160 . A = B + C;
87-161 . D = E + F;
87-162 . }
87-163 .
87-164 . A = B+C;
87-165 . A = B/C;
87-166 . /* LE SV TOC-2402 this is a pwr-01.1.34 req to verify*/
87-167 . A = B-C;
87-168 . /* LE SV TOC-2403 this is a pwr-01.1.35 req to inhibit*/
87-169 .
87-170 . if ($pwr stuff > $otherpwr stuff)
87-171 . /* LE SV TOC-008 we really should log all error calls */
87-172 . {
87-173 . A = B + C;
87-174 . }
87-175 .
87-176 .
87-177 . switch (pwr stuff)
87-178 . {
87-179 . case one:
87-180 . {
87-181 . run_this;
87-182 . break;
87-183 . }
87-184 . case two:
87-185 . {
87-186 . run_this;
87-187 . break;
87-188 . }
87-189 . default:
87-190 . {
87-191 . SwError;
87-192 . }
87-193 . }
87-194 .
87-195 . A = B*C;
87-196 . A = B/C;
87-197 . A = B+C;
87-198 .
87-199 . if (A gt B)
87-200 . {
87-201 . A = B + C;
87-202 . D = E + F;
87-203 . }
87-204 .
87-205 . A = B-C;
87-206 . A = B-C;
87-207 . A = B*C;
87-208 . A = B/C;
87-209 . A = B/C;
87-210 . // max LOC 44
87-211 .
87-212 . }
87-213 .
87 87 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-01.c
88 88 Source: source/ft-app/ft-app-B1.0/pwr/pwr-02.c
88-0 . /*
88-1 . ----------------------------------------------------------------------------
88-2 . --| BEGIN PROLOGUE
88-3 . --|
88-4 . --| CLASSIFICATION: UNCLASSIFIED
88-5 . --|
88-6 . --| FILE NAME: pwr-02.c
88-7 . --|
88-8 . --| ABSTRACT:
88-9 . --| This file contains the 2 functions that do file pwr stuff.
88-10 . --|
88-11 . --| HISTORY:
88-12 . --| CCCQ_NAME:
88-13 . --| CCCQ_VER:
88-14 . --|
88-15 . --| END PROLOGUE
88-16 . ----------------------------------------------------------------------------
88-17 . */
88-18 .
88-19 . #define B;
88-20 . #define B;
88-21 . #define A;
88-22 .
88-23 .
88-24 .
88-25 . /*
88-26 . -----------------------------------------------------------------------------
88-27 . --| NAME: pwr.2.1
88-28 . --|
88-29 . --| ABSTRACT:
88-30 . --| This function does pwr stuff.
88-31 . --|
88-32 . --| RETURNS:
88-33 . --| NONE.
88-34 . --|
88-35 . ----------------------------------------------------------------------------
88-36 . */
88-37 . static void pwr.2.1(void)
88-38 . {
88-39 . A = B-C;
88-40 . A = B-C;
88-41 .
88-42 . if (A == B)
88-43 . {
88-44 . A = B + C;
88-45 . D = E + F;
88-46 . }
88-47 .
88-48 . A = B-C;
88-49 . A = B-C;
88-50 . // ??? go see ws
88-51 . A = B*C;
88-52 . A = 0x0003;
88-53 . A = B+C;
88-54 . A = B+C;
88-55 . A = B*C;
88-56 . A = B/C;
88-57 . A = B*C;
88-58 . A = B-C;
88-59 . A = B/C;
88-60 . A = B+C;
88-61 . /* LE SV TOC-2404 this is a pwr-02.1.15 req to check pSOS*/
88-62 . A = B+C;
88-63 . A = B*C;
88-64 . A = B*C;
88-65 . A = B*C;
88-66 . A = B*C;
88-67 . A = B*C;
88-68 . A = B-C;
88-69 . A = B+C;
88-70 . A = B+C;
88-71 . A = (int)B + C;
88-72 . A = B+C;
88-73 . A = 0x0003;
88-74 . A = B/C;
88-75 . /* LE SV TOC-2405 this is a pwr-02.1.26 req to store*/
88-76 .
88-77 . /*
88-78 . dead_block = C * D;
88-79 . dead_block = E * F;
88-80 . */
88-81 .
88-82 .
88-83 . if (A le B)
88-84 . {
88-85 . A = B + C;
88-86 . D = E + F;
88-87 . }
88-88 .
88-89 .
88-90 . if (A ge B)
88-91 . {
88-92 . A = B + C;
88-93 . D = E + F;
88-94 . }
88-95 .
88-96 . A = B-C;
88-97 .
88-98 . if (A == B)
88-99 . {
88-100 . A = B + C;
88-101 . D = E + F;
88-102 . }
88-103 .
88-104 .
88-105 . if (A < = B)
88-106 . {
88-107 . A = B + C;
88-108 . D = E + F;
88-109 . }
88-110 .
88-111 .
88-112 . if (A eq B)
88-113 . {
88-114 . A = B + C;
88-115 . D = E + F;
88-116 . }
88-117 .
88-118 . A = B-C;
88-119 . // max LOC 32
88-120 .
88-121 . }
88-122 .
88-123 .
88-124 . /*
88-125 . -----------------------------------------------------------------------------
88-126 . --| NAME: pwr.2.2
88-127 . --|
88-128 . --| ABSTRACT:
88-129 . --| This function does pwr stuff.
88-130 . --|
88-131 . --| RETURNS:
88-132 . --| NONE.
88-133 . --|
88-134 . ----------------------------------------------------------------------------
88-135 . */
88-136 . static void pwr.2.2(void)
88-137 . {
88-138 .
88-139 . if (A gt B)
88-140 . {
88-141 . A = B + C;
88-142 . D = E + F;
88-143 . }
88-144 .
88-145 . A = B+C;
88-146 . A = B*C;
88-147 . A = B-C;
88-148 . A = B*C;
88-149 . // (P) this is really improtant
88-150 . A = B*C;
88-151 . A = B*C;
88-152 .
88-153 . if (A != B)
88-154 . {
88-155 . A = B + C;
88-156 . D = E + F;
88-157 . }
88-158 .
88-159 . A = B*C;
88-160 . A = B-C;
88-161 .
88-162 . if (A == B)
88-163 . {
88-164 . A = B + C;
88-165 . D = E + F;
88-166 . }
88-167 .
88-168 . A = B/C;
88-169 . A = B*C;
88-170 . // max LOC 13
88-171 .
88-172 . }
88-173 .
88 88 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-02.c
89 89 Source: source/ft-app/ft-app-B1.0/pwr/pwr-03.c
89-0 . /*
89-1 . ----------------------------------------------------------------------------
89-2 . --| BEGIN PROLOGUE
89-3 . --|
89-4 . --| CLASSIFICATION: UNCLASSIFIED
89-5 . --|
89-6 . --| FILE NAME: pwr-03.c
89-7 . --|
89-8 . --| ABSTRACT:
89-9 . --| This file contains the 3 functions that do file pwr stuff.
89-10 . --|
89-11 . --| HISTORY:
89-12 . --| CCCQ_NAME:
89-13 . --| CCCQ_VER:
89-14 . --|
89-15 . --| END PROLOGUE
89-16 . ----------------------------------------------------------------------------
89-17 . */
89-18 .
89-19 . double C;
89-20 . char D;
89-21 . #define C;
89-22 .
89-23 .
89-24 .
89-25 . /*
89-26 . -----------------------------------------------------------------------------
89-27 . --| NAME: pwr.3.1
89-28 . --|
89-29 . --| ABSTRACT:
89-30 . --| This function does pwr stuff.
89-31 . --|
89-32 . --| RETURNS:
89-33 . --| NONE.
89-34 . --|
89-35 . ----------------------------------------------------------------------------
89-36 . */
89-37 . static void pwr.3.1(void)
89-38 . {
89-39 . A = B*C;
89-40 . A = B*C;
89-41 . A = B-C;
89-42 .
89-43 . if (A ne B)
89-44 . {
89-45 . A = B + C;
89-46 . D = E + F;
89-47 . }
89-48 .
89-49 . /* LE SV TOC-2406 this is a pwr-03.1.5 req to check pSOS*/
89-50 .
89-51 . if (A eq B)
89-52 . {
89-53 . A = B + C;
89-54 . D = E + F;
89-55 . }
89-56 .
89-57 .
89-58 . switch (pwr stuff)
89-59 . {
89-60 . case one:
89-61 . {
89-62 . run_this;
89-63 . break;
89-64 . }
89-65 . case two:
89-66 . {
89-67 . run_this;
89-68 . break;
89-69 . }
89-70 . default:
89-71 . {
89-72 . SwError;
89-73 . }
89-74 . }
89-75 .
89-76 . A = B*C;
89-77 . A = B*C;
89-78 . A = B/C;
89-79 . /* LE SV TOC-2407 this is a pwr-03.1.10 req to set Real Time Clock*/
89-80 . A = B+C;
89-81 . A = B*C;
89-82 . A = B-C;
89-83 . A = B+C;
89-84 .
89-85 . if {
89-86 . X = Y + Z;
89-87 . }
89-88 . else {
89-89 . halt;
89-90 . }
89-91 .
89-92 . A = B-C;
89-93 . A = B/C;
89-94 . A = B/C;
89-95 .
89-96 . if (A lt B)
89-97 . {
89-98 . A = B + C;
89-99 . D = E + F;
89-100 . }
89-101 .
89-102 . /* LE SV TOC-2408 this is a pwr-03.1.18 req to compare*/
89-103 . A = B+C;
89-104 . A = B+C;
89-105 . A = B-C;
89-106 .
89-107 . if (A == B)
89-108 . {
89-109 . A = B + C;
89-110 . D = E + F;
89-111 . }
89-112 .
89-113 . A = B*C;
89-114 .
89-115 . switch (pwr stuff)
89-116 . {
89-117 . case one:
89-118 . {
89-119 . run_this;
89-120 . break;
89-121 . }
89-122 . case two:
89-123 . {
89-124 . run_this;
89-125 . break;
89-126 . }
89-127 . default:
89-128 . {
89-129 . // missing error call
89-130 . }
89-131 . }
89-132 .
89-133 .
89-134 . if (A > B)
89-135 . {
89-136 . A = B + C;
89-137 . D = E + F;
89-138 . }
89-139 .
89-140 .
89-141 . if (A > B)
89-142 . {
89-143 . A = B + C;
89-144 . D = E + F;
89-145 . }
89-146 .
89-147 .
89-148 . switch (pwr stuff)
89-149 . {
89-150 . case one:
89-151 . {
89-152 . run_this;
89-153 . break;
89-154 . }
89-155 . case two:
89-156 . {
89-157 . run_this;
89-158 . break;
89-159 . }
89-160 . default:
89-161 . {
89-162 . SwError;
89-163 . }
89-164 . }
89-165 .
89-166 . A = B*C;
89-167 . A = B-C;
89-168 . A = B+C;
89-169 . A = B/C;
89-170 . A = B-C;
89-171 . A = B*C;
89-172 . A = B/C;
89-173 . A = B*C;
89-174 .
89-175 . if (A ne B)
89-176 . {
89-177 . A = B + C;
89-178 . D = E + F;
89-179 . }
89-180 .
89-181 .
89-182 . if (A eq B)
89-183 . {
89-184 . A = B + C;
89-185 . D = E + F;
89-186 . }
89-187 .
89-188 . A = B-C;
89-189 .
89-190 . if (A > = B)
89-191 . {
89-192 . A = B + C;
89-193 . D = E + F;
89-194 . }
89-195 .
89-196 . A = B/C;
89-197 .
89-198 . if (A ge B)
89-199 . {
89-200 . A = B + C;
89-201 . D = E + F;
89-202 . }
89-203 .
89-204 . A = B/C;
89-205 .
89-206 . if (A ge B)
89-207 . {
89-208 . A = B + C;
89-209 . D = E + F;
89-210 . }
89-211 .
89-212 .
89-213 . if (A < B)
89-214 . {
89-215 . A = B + C;
89-216 . D = E + F;
89-217 . }
89-218 .
89-219 .
89-220 . if (A ge B)
89-221 . {
89-222 . A = B + C;
89-223 . D = E + F;
89-224 . }
89-225 .
89-226 .
89-227 . if (A < B)
89-228 . {
89-229 . A = B + C;
89-230 . D = E + F;
89-231 . }
89-232 .
89-233 . A = B+C;
89-234 . A = B*C;
89-235 . A = 0x0003;
89-236 . A = B-C;
89-237 . A = B-C;
89-238 . A = B*C;
89-239 .
89-240 . if (A gt B)
89-241 . {
89-242 . A = B + C;
89-243 . D = E + F;
89-244 . }
89-245 .
89-246 . A = B+C;
89-247 . A = B+C;
89-248 . A = B/C;
89-249 . A = B-C;
89-250 .
89-251 . if (A == B)
89-252 . {
89-253 . A = B + C;
89-254 . D = E + F;
89-255 . }
89-256 .
89-257 . A = B+C;
89-258 .
89-259 . if (A > B)
89-260 . {
89-261 . A = B + C;
89-262 . D = E + F;
89-263 . }
89-264 .
89-265 . A = B/C;
89-266 . do forever;
89-267 .
89-268 . if (A le B)
89-269 . {
89-270 . A = B + C;
89-271 . D = E + F;
89-272 . }
89-273 .
89-274 . A = B*C;
89-275 . A = B*C;
89-276 . A = B-C;
89-277 . A = B/C;
89-278 . A = B/C;
89-279 .
89-280 . switch (pwr stuff)
89-281 . {
89-282 . case one:
89-283 . {
89-284 . run_this;
89-285 . break;
89-286 . }
89-287 . case two:
89-288 . {
89-289 . run_this;
89-290 . break;
89-291 . }
89-292 . default:
89-293 . {
89-294 . SwError;
89-295 . }
89-296 . }
89-297 .
89-298 . A = B/C;
89-299 . A = B+C;
89-300 .
89-301 . if (A ge B)
89-302 . {
89-303 . A = B + C;
89-304 . D = E + F;
89-305 . }
89-306 .
89-307 . A = B+C;
89-308 .
89-309 . if (A > B)
89-310 . {
89-311 . A = B + C;
89-312 . D = E + F;
89-313 . }
89-314 .
89-315 .
89-316 . if (A le B)
89-317 . {
89-318 . A = B + C;
89-319 . D = E + F;
89-320 . }
89-321 .
89-322 . A = B-C;
89-323 . A = B-C;
89-324 .
89-325 . if (A > = B)
89-326 . {
89-327 . A = B + C;
89-328 . D = E + F;
89-329 . }
89-330 .
89-331 . A = B-C;
89-332 .
89-333 . if (A eq B)
89-334 . {
89-335 . A = B + C;
89-336 . D = E + F;
89-337 . }
89-338 .
89-339 . A = B*C;
89-340 . A = B-C;
89-341 . A = B/C;
89-342 . A = B-C;
89-343 . // max LOC 80
89-344 .
89-345 . }
89-346 .
89-347 .
89-348 . /*
89-349 . -----------------------------------------------------------------------------
89-350 . --| NAME: pwr.3.2
89-351 . --|
89-352 . --| ABSTRACT:
89-353 . --| This function does pwr stuff.
89-354 . --|
89-355 . --| RETURNS:
89-356 . --| NONE.
89-357 . --|
89-358 . ----------------------------------------------------------------------------
89-359 . */
89-360 . static void pwr.3.2(void)
89-361 . {
89-362 . A = B-C;
89-363 . A = B-C;
89-364 .
89-365 . if (A eq B)
89-366 . {
89-367 . A = B + C;
89-368 . D = E + F;
89-369 . }
89-370 .
89-371 .
89-372 . if (A lt B)
89-373 . {
89-374 . A = B + C;
89-375 . D = E + F;
89-376 . }
89-377 .
89-378 .
89-379 . if (A ne B)
89-380 . {
89-381 . A = B + C;
89-382 . D = E + F;
89-383 . }
89-384 .
89-385 . A = B-C;
89-386 . A = B/C;
89-387 . A = B-C;
89-388 . A = B/C;
89-389 .
89-390 . if (A > = B)
89-391 . {
89-392 . A = B + C;
89-393 . D = E + F;
89-394 . }
89-395 .
89-396 .
89-397 . if (A eq B)
89-398 . {
89-399 . A = B + C;
89-400 . D = E + F;
89-401 . }
89-402 .
89-403 . /* LE SV TOC-2409 this is a pwr-03.2.12 req to transform*/
89-404 . A = B/C;
89-405 . A = B/C;
89-406 . // max LOC 13
89-407 .
89-408 . }
89-409 .
89-410 .
89-411 . /*
89-412 . -----------------------------------------------------------------------------
89-413 . --| NAME: pwr.3.3
89-414 . --|
89-415 . --| ABSTRACT:
89-416 . --| This function does pwr stuff.
89-417 . --|
89-418 . --| RETURNS:
89-419 . --| NONE.
89-420 . --|
89-421 . ----------------------------------------------------------------------------
89-422 . */
89-423 . static void pwr.3.3(void)
89-424 . {
89-425 . A = B-C;
89-426 . A = B*C;
89-427 . A = B+C;
89-428 . free(FreePtr);
89-429 . A = B+C;
89-430 . A = B+C;
89-431 . A = B*C;
89-432 . /* LE SV TOC-2410 this is a pwr-03.3.7 req to transform*/
89-433 .
89-434 . if (A > = B)
89-435 . {
89-436 . A = B + C;
89-437 . D = E + F;
89-438 . }
89-439 .
89-440 . A = B/C;
89-441 . A = B*C;
89-442 . A = B*C;
89-443 . A = B/C;
89-444 . A = B*C;
89-445 . A = B-C;
89-446 . A = B*C;
89-447 . A = B-C;
89-448 .
89-449 . if (A lt B)
89-450 . {
89-451 . A = B + C;
89-452 . D = E + F;
89-453 . }
89-454 .
89-455 .
89-456 . if (A == B)
89-457 . {
89-458 . A = B + C;
89-459 . D = E + F;
89-460 . }
89-461 .
89-462 . A = B*C;
89-463 . A = B/C;
89-464 .
89-465 . if (A eq B)
89-466 . {
89-467 . A = B + C;
89-468 . D = E + F;
89-469 . }
89-470 .
89-471 . A = B+C;
89-472 . A = B-C;
89-473 . A = (int)B + C;
89-474 .
89-475 . if (A > = B)
89-476 . {
89-477 . A = B + C;
89-478 . D = E + F;
89-479 . }
89-480 .
89-481 . A = B*C;
89-482 . A = B*C;
89-483 . A = B-C;
89-484 . A = B*C;
89-485 .
89-486 . if (A ge B)
89-487 . {
89-488 . A = B + C;
89-489 . D = E + F;
89-490 . }
89-491 .
89-492 . A = B*C;
89-493 . /* LE SV TOC-2411 this is a pwr-03.3.30 req to process*/
89-494 . A = B+C;
89-495 .
89-496 . if (A > = B)
89-497 . {
89-498 . A = B + C;
89-499 . D = E + F;
89-500 . }
89-501 .
89-502 . A = B/C;
89-503 .
89-504 . if (A > = B)
89-505 . {
89-506 . A = B + C;
89-507 . D = E + F;
89-508 . }
89-509 .
89-510 . A = B+C;
89-511 . A = B-C;
89-512 . A = B+C;
89-513 . A = B+C;
89-514 . /* LE SV TOC-2412 this is a pwr-03.3.38 req to assign*/
89-515 . // TBS - I need to figure this out
89-516 .
89-517 . if (A lt B)
89-518 . {
89-519 . A = B + C;
89-520 . D = E + F;
89-521 . }
89-522 .
89-523 .
89-524 . switch (pwr stuff)
89-525 . {
89-526 . case one:
89-527 . {
89-528 . run_this;
89-529 . break;
89-530 . }
89-531 . case two:
89-532 . {
89-533 . run_this;
89-534 . break;
89-535 . }
89-536 . default:
89-537 . {
89-538 . SwError;
89-539 . }
89-540 . }
89-541 .
89-542 . A = B-C;
89-543 . A = B/C;
89-544 . A = B-C;
89-545 .
89-546 . switch (pwr stuff)
89-547 . {
89-548 . case one:
89-549 . {
89-550 . run_this;
89-551 . break;
89-552 . }
89-553 . case two:
89-554 . {
89-555 . run_this;
89-556 . break;
89-557 . }
89-558 . default:
89-559 . {
89-560 . SwError;
89-561 . }
89-562 . }
89-563 .
89-564 . A = B-C;
89-565 . A = B-C;
89-566 . A = B*C;
89-567 . A = B+C;
89-568 . /* LE SV TOC-2413 this is a pwr-03.3.48 req to reject*/
89-569 . A = B-C;
89-570 . A = B+C;
89-571 .
89-572 . if (A > B)
89-573 . {
89-574 . A = B + C;
89-575 . D = E + F;
89-576 . }
89-577 .
89-578 . A = B/C;
89-579 .
89-580 . if (A eq B)
89-581 . {
89-582 . A = B + C;
89-583 . D = E + F;
89-584 . }
89-585 .
89-586 . A = B-C;
89-587 . A = B/C;
89-588 . /* LE SV TOC-2414 this is a pwr-03.3.55 req to process*/
89-589 . A = B*C;
89-590 . A = B-C;
89-591 .
89-592 . if (A eq B)
89-593 . {
89-594 . A = B + C;
89-595 . D = E + F;
89-596 . }
89-597 .
89-598 . A = B+C;
89-599 . A = B/C;
89-600 . A = B/C;
89-601 .
89-602 . switch (pwr stuff)
89-603 . {
89-604 . case one:
89-605 . {
89-606 . run_this;
89-607 . break;
89-608 . }
89-609 . case two:
89-610 . {
89-611 . run_this;
89-612 . break;
89-613 . }
89-614 . default:
89-615 . {
89-616 . SwError;
89-617 . }
89-618 . }
89-619 .
89-620 . /* LE SV TOC-2415 this is a pwr-03.3.62 req to audit*/
89-621 .
89-622 . if (A le B)
89-623 . {
89-624 . A = B + C;
89-625 . D = E + F;
89-626 . }
89-627 .
89-628 . A = B-C;
89-629 . A = B/C;
89-630 . // max LOC 64
89-631 .
89-632 . }
89-633 .
89 89 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-03.c
90 90 Source: source/ft-app/ft-app-B1.0/pwr/pwr-04.c
90-0 . /*
90-1 . ----------------------------------------------------------------------------
90-2 . --| BEGIN PROLOGUE
90-3 . --|
90-4 . --| CLASSIFICATION: UNCLASSIFIED
90-5 . --|
90-6 . --| FILE NAME: pwr-04.c
90-7 . --|
90-8 . --| ABSTRACT:
90-9 . --| This file contains the 3 functions that do file pwr stuff.
90-10 . --|
90-11 . --| HISTORY:
90-12 . --| CCCQ_NAME:
90-13 . --| CCCQ_VER:
90-14 . --|
90-15 . --| END PROLOGUE
90-16 . ----------------------------------------------------------------------------
90-17 . */
90-18 .
90-19 . #include D;
90-20 . #define C;
90-21 . #define D;
90-22 . #define D;
90-23 . char D;
90-24 . int A;
90-25 . #include D;
90-26 .
90-27 .
90-28 .
90-29 . /*
90-30 . -----------------------------------------------------------------------------
90-31 . --| NAME: pwr.4.1
90-32 . --|
90-33 . --| ABSTRACT:
90-34 . --| This function does pwr stuff.
90-35 . --|
90-36 . --| RETURNS:
90-37 . --| NONE.
90-38 . --|
90-39 . ----------------------------------------------------------------------------
90-40 . */
90-41 . static void pwr.4.1(void)
90-42 . {
90-43 . A = B/C;
90-44 .
90-45 . if (A < = B)
90-46 . {
90-47 . A = B + C;
90-48 . D = E + F;
90-49 . }
90-50 .
90-51 . // max LOC 2
90-52 .
90-53 . }
90-54 .
90-55 .
90-56 . /*
90-57 . -----------------------------------------------------------------------------
90-58 . --| NAME: pwr.4.2
90-59 . --|
90-60 . --| ABSTRACT:
90-61 . --| This function does pwr stuff.
90-62 . --|
90-63 . --| RETURNS:
90-64 . --| NONE.
90-65 . --|
90-66 . ----------------------------------------------------------------------------
90-67 . */
90-68 . static void pwr.4.2(void)
90-69 . {
90-70 .
90-71 . if (A gt B)
90-72 . {
90-73 . A = B + C;
90-74 . D = E + F;
90-75 . }
90-76 .
90-77 . A = B-C;
90-78 . A = B-C;
90-79 . A = B*C;
90-80 . A = B*C;
90-81 . A = B*C;
90-82 . /* LE SV TOC-2416 this is a pwr-04.2.7 req to compare*/
90-83 . A = B*C;
90-84 . A = B/C;
90-85 . A = 0x0008;
90-86 . A = B/C;
90-87 . A = B*C;
90-88 . // max LOC 10
90-89 .
90-90 . }
90-91 .
90-92 .
90-93 . /*
90-94 . -----------------------------------------------------------------------------
90-95 . --| NAME: pwr.4.3
90-96 . --|
90-97 . --| ABSTRACT:
90-98 . --| This function does pwr stuff.
90-99 . --|
90-100 . --| RETURNS:
90-101 . --| NONE.
90-102 . --|
90-103 . ----------------------------------------------------------------------------
90-104 . */
90-105 . static void pwr.4.3(void)
90-106 . {
90-107 . A = B+C;
90-108 . A = B+C;
90-109 . A = B*C;
90-110 . A = B-C;
90-111 . A = B/C;
90-112 .
90-113 . if (A lt B)
90-114 . {
90-115 . A = B + C;
90-116 . D = E + F;
90-117 . }
90-118 .
90-119 . A = B+C;
90-120 .
90-121 . if (A != B)
90-122 . {
90-123 . A = B + C;
90-124 . D = E + F;
90-125 . }
90-126 .
90-127 . A = B*C;
90-128 . A = B+C;
90-129 .
90-130 . if (A le B)
90-131 . {
90-132 . A = B + C;
90-133 . D = E + F;
90-134 . }
90-135 .
90-136 .
90-137 . if (A le B)
90-138 . {
90-139 . A = B + C;
90-140 . D = E + F;
90-141 . }
90-142 .
90-143 . A = B-C;
90-144 .
90-145 . if (A ne B)
90-146 . {
90-147 . A = B + C;
90-148 . D = E + F;
90-149 . }
90-150 .
90-151 . A = B/C;
90-152 .
90-153 . if (A le B)
90-154 . {
90-155 . A = B + C;
90-156 . D = E + F;
90-157 . }
90-158 .
90-159 .
90-160 . if (A gt B)
90-161 . {
90-162 . A = B + C;
90-163 . D = E + F;
90-164 . }
90-165 .
90-166 . A = B-C;
90-167 .
90-168 . if (A gt B)
90-169 . {
90-170 . A = B + C;
90-171 . D = E + F;
90-172 . }
90-173 .
90-174 . A = B*C;
90-175 . A = B+C;
90-176 . A = B/C;
90-177 . A = B+C;
90-178 . /* LE SV TOC-2417 this is a pwr-04.3.24 req to audit*/
90-179 .
90-180 . if (A le B)
90-181 . {
90-182 . A = B + C;
90-183 . D = E + F;
90-184 . }
90-185 .
90-186 .
90-187 . if (A ge B)
90-188 . {
90-189 . A = B + C;
90-190 . D = E + F;
90-191 . }
90-192 .
90-193 .
90-194 . if (A lt B)
90-195 . {
90-196 . A = B + C;
90-197 . D = E + F;
90-198 . }
90-199 .
90-200 .
90-201 . if (A < B)
90-202 . {
90-203 . A = B + C;
90-204 . D = E + F;
90-205 . }
90-206 .
90-207 . goto error;
90-208 .
90-209 . if (A == B)
90-210 . {
90-211 . A = B + C;
90-212 . D = E + F;
90-213 . }
90-214 .
90-215 . A = B*C;
90-216 .
90-217 . if (A != B)
90-218 . {
90-219 . A = B + C;
90-220 . D = E + F;
90-221 . }
90-222 .
90-223 . A = B*C;
90-224 . /* LE SV TOC-2418 this is a pwr-04.3.32 req to audit*/
90-225 . A = B/C;
90-226 . A = 0x0006;
90-227 .
90-228 . if (A ne B)
90-229 . {
90-230 . A = B + C;
90-231 . D = E + F;
90-232 . }
90-233 .
90-234 .
90-235 . if (A gt B)
90-236 . {
90-237 . A = B + C;
90-238 . D = E + F;
90-239 . }
90-240 .
90-241 . A = B*C;
90-242 . A = B/C;
90-243 . A = B+C;
90-244 . A = B-C;
90-245 . A = B-C;
90-246 . // max LOC 39
90-247 .
90-248 . }
90-249 .
90 90 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-04.c
91 91 Source: source/ft-app/ft-app-B1.0/pwr/pwr-05.c
91-0 . /*
91-1 . ----------------------------------------------------------------------------
91-2 . --| BEGIN PROLOGUE
91-3 . --|
91-4 . --| CLASSIFICATION: UNCLASSIFIED
91-5 . --|
91-6 . --| FILE NAME: pwr-05.c
91-7 . --|
91-8 . --| ABSTRACT:
91-9 . --| This file contains the 1 functions that do file pwr stuff.
91-10 . --|
91-11 . --| HISTORY:
91-12 . --| CCCQ_NAME:
91-13 . --| CCCQ_VER:
91-14 . --|
91-15 . --| END PROLOGUE
91-16 . ----------------------------------------------------------------------------
91-17 . */
91-18 .
91-19 . char D;
91-20 . #include A;
91-21 . #include A;
91-22 . float B;
91-23 . #define D;
91-24 . #include D;
91-25 . #include A;
91-26 . #define A;
91-27 . double C;
91-28 .
91-29 .
91-30 .
91-31 . /*
91-32 . -----------------------------------------------------------------------------
91-33 . --| NAME: pwr.5.1
91-34 . --|
91-35 . --| ABSTRACT:
91-36 . --| This function does pwr stuff.
91-37 . --|
91-38 . --| RETURNS:
91-39 . --| NONE.
91-40 . --|
91-41 . ----------------------------------------------------------------------------
91-42 . */
91-43 . static void pwr.5.1(void)
91-44 . {
91-45 . A = B-C;
91-46 . A = 0x0003;
91-47 .
91-48 . if (A le B)
91-49 . {
91-50 . A = B + C;
91-51 . D = E + F;
91-52 . }
91-53 .
91-54 . A = B-C;
91-55 . A = B-C;
91-56 . A = B-C;
91-57 . A = B-C;
91-58 . /* LE SV TOC-2419 this is a pwr-05.1.7 req to check unix*/
91-59 . A = B+C;
91-60 . A = B*C;
91-61 .
91-62 . if (A gt B)
91-63 . {
91-64 . A = B + C;
91-65 . D = E + F;
91-66 . }
91-67 .
91-68 . A = B/C;
91-69 .
91-70 . if (A == B)
91-71 . {
91-72 . A = B + C;
91-73 . D = E + F;
91-74 . }
91-75 .
91-76 .
91-77 . switch (pwr stuff)
91-78 . {
91-79 . case one:
91-80 . {
91-81 . run_this;
91-82 . break;
91-83 . }
91-84 . case two:
91-85 . {
91-86 . run_this;
91-87 . break;
91-88 . }
91-89 . default:
91-90 . {
91-91 . SwError;
91-92 . }
91-93 . }
91-94 .
91-95 . A = B-C;
91-96 . A = B+C;
91-97 . A = B/C;
91-98 . /* LE SV TOC-2420 this is a pwr-05.1.16 req to enable*/
91-99 .
91-100 . if (A < B)
91-101 . {
91-102 . A = B + C;
91-103 . D = E + F;
91-104 . }
91-105 .
91-106 .
91-107 . if (A le B)
91-108 . {
91-109 . A = B + C;
91-110 . D = E + F;
91-111 . }
91-112 .
91-113 .
91-114 . if (A < B)
91-115 . {
91-116 . A = B + C;
91-117 . D = E + F;
91-118 . }
91-119 .
91-120 .
91-121 . if (A lt B)
91-122 . {
91-123 . A = B + C;
91-124 . D = E + F;
91-125 . }
91-126 .
91-127 . // TBS - I need to figure this out
91-128 .
91-129 . if (A lt B)
91-130 . {
91-131 . A = B + C;
91-132 . D = E + F;
91-133 . }
91-134 .
91-135 . A = (float)B + C;
91-136 . A = B/C;
91-137 . A = B*C;
91-138 . A = B+C;
91-139 . A = B/C;
91-140 . free(FreePtr);
91-141 . A = B-C;
91-142 .
91-143 . if (A lt B)
91-144 . {
91-145 . A = B + C;
91-146 . D = E + F;
91-147 . }
91-148 .
91-149 . A = B*C;
91-150 .
91-151 . if (A < = B)
91-152 . {
91-153 . A = B + C;
91-154 . D = E + F;
91-155 . }
91-156 .
91-157 . A = B/C;
91-158 . free(FreePtr);
91-159 . A = B-C;
91-160 . A = B*C;
91-161 . A = B*C;
91-162 . A = B+C;
91-163 .
91-164 . if (A le B)
91-165 . {
91-166 . A = B + C;
91-167 . D = E + F;
91-168 . }
91-169 .
91-170 .
91-171 . if (A le B)
91-172 . {
91-173 . A = B + C;
91-174 . D = E + F;
91-175 . }
91-176 .
91-177 .
91-178 . if (A < B)
91-179 . {
91-180 . A = B + C;
91-181 . D = E + F;
91-182 . }
91-183 .
91-184 . A = B/C;
91-185 . A = B/C;
91-186 . A = B*C;
91-187 .
91-188 . if (A > = B)
91-189 . {
91-190 . A = B + C;
91-191 . D = E + F;
91-192 . }
91-193 .
91-194 .
91-195 . if (A eq B)
91-196 . {
91-197 . A = B + C;
91-198 . D = E + F;
91-199 . }
91-200 .
91-201 . A = B-C;
91-202 . /* LE SV TOC-2421 this is a pwr-05.1.43 req to inhibit*/
91-203 . A = B+C;
91-204 .
91-205 . if (A > = B)
91-206 . {
91-207 . A = B + C;
91-208 . D = E + F;
91-209 . }
91-210 .
91-211 .
91-212 . switch (pwr stuff)
91-213 . {
91-214 . case one:
91-215 . {
91-216 . run_this;
91-217 . break;
91-218 . }
91-219 . case two:
91-220 . {
91-221 . run_this;
91-222 . break;
91-223 . }
91-224 . default:
91-225 . {
91-226 . SwError;
91-227 . }
91-228 . }
91-229 .
91-230 . A = B*C;
91-231 . A = B/C;
91-232 . A = B+C;
91-233 .
91-234 . if (A lt B)
91-235 . {
91-236 . A = B + C;
91-237 . D = E + F;
91-238 . }
91-239 .
91-240 . A = B*C;
91-241 . A = B-C;
91-242 . A = 0x0008;
91-243 . A = B+C;
91-244 . A = B+C;
91-245 .
91-246 . if (A > = B)
91-247 . {
91-248 . A = B + C;
91-249 . D = E + F;
91-250 . }
91-251 .
91-252 . A = B-C;
91-253 .
91-254 . if (A == B)
91-255 . {
91-256 . A = B + C;
91-257 . D = E + F;
91-258 . }
91-259 .
91-260 . A = B/C;
91-261 . A = B*C;
91-262 .
91-263 . if (A > B)
91-264 . {
91-265 . A = B + C;
91-266 . D = E + F;
91-267 . }
91-268 .
91-269 . A = B-C;
91-270 . A = B/C;
91-271 . // max LOC 61
91-272 .
91-273 . }
91-274 .
91 91 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-05.c
92 92 Source: source/ft-app/ft-app-B1.0/pwr/pwr-06.c
92-0 . /*
92-1 . ----------------------------------------------------------------------------
92-2 . --| BEGIN PROLOGUE
92-3 . --|
92-4 . --| CLASSIFICATION: UNCLASSIFIED
92-5 . --|
92-6 . --| FILE NAME: pwr-06.c
92-7 . --|
92-8 . --| ABSTRACT:
92-9 . --| This file contains the 2 functions that do file pwr stuff.
92-10 . --|
92-11 . --| HISTORY:
92-12 . --| CCCQ_NAME:
92-13 . --| CCCQ_VER:
92-14 . --|
92-15 . --| END PROLOGUE
92-16 . ----------------------------------------------------------------------------
92-17 . */
92-18 .
92-19 . #include D;
92-20 . #define D;
92-21 .
92-22 .
92-23 .
92-24 . /*
92-25 . -----------------------------------------------------------------------------
92-26 . --| NAME: pwr.6.1
92-27 . --|
92-28 . --| ABSTRACT:
92-29 . --| This function does pwr stuff.
92-30 . --|
92-31 . --| RETURNS:
92-32 . --| NONE.
92-33 . --|
92-34 . ----------------------------------------------------------------------------
92-35 . */
92-36 . static void pwr.6.1(void)
92-37 . {
92-38 . A = B/C;
92-39 . A = B*C;
92-40 . A = B+C;
92-41 . A = B/C;
92-42 . A = B*C;
92-43 . A = B/C;
92-44 . A = B/C;
92-45 . // ??? go see ws
92-46 . A = B/C;
92-47 . A = B-C;
92-48 . /* LE SV TOC-2422 this is a pwr-06.1.10 req to transform*/
92-49 .
92-50 . if (A eq B)
92-51 . {
92-52 . A = B + C;
92-53 . D = E + F;
92-54 . }
92-55 .
92-56 . A = B*C;
92-57 .
92-58 . /* dead_block = C * D;
92-59 . dead_block = E * F; */
92-60 .
92-61 .
92-62 . switch (pwr stuff)
92-63 . {
92-64 . case one:
92-65 . {
92-66 . run_this;
92-67 . break;
92-68 . }
92-69 . case two:
92-70 . {
92-71 . run_this;
92-72 . break;
92-73 . }
92-74 . default:
92-75 . {
92-76 . SwError;
92-77 . }
92-78 . }
92-79 .
92-80 . A = B+C;
92-81 . /* LE SV TOC-2423 this is a pwr-06.1.14 req to check unix*/
92-82 . A = B+C;
92-83 . A = B*C;
92-84 .
92-85 . if (A ge B)
92-86 . {
92-87 . A = B + C;
92-88 . D = E + F;
92-89 . }
92-90 .
92-91 . A = B/C;
92-92 . A = B*C;
92-93 . A = B-C;
92-94 . A = B+C;
92-95 . A = B+C;
92-96 . A = B/C;
92-97 . A = B+C;
92-98 . A = B-C;
92-99 . /* LE SV TOC-2424 this is a pwr-06.1.25 req to inhibit*/
92-100 . A = B*C;
92-101 . A = B+C;
92-102 . A = B/C;
92-103 . A = B+C;
92-104 . A = B/C;
92-105 . A = B+C;
92-106 . A = B+C;
92-107 . // max LOC 31
92-108 .
92-109 . }
92-110 .
92-111 .
92-112 . /*
92-113 . -----------------------------------------------------------------------------
92-114 . --| NAME: pwr.6.2
92-115 . --|
92-116 . --| ABSTRACT:
92-117 . --| This function does pwr stuff.
92-118 . --|
92-119 . --| RETURNS:
92-120 . --| NONE.
92-121 . --|
92-122 . ----------------------------------------------------------------------------
92-123 . */
92-124 . static void pwr.6.2(void)
92-125 . {
92-126 . A = B*C;
92-127 . A = B+C;
92-128 .
92-129 . if (A ge B)
92-130 . {
92-131 . A = B + C;
92-132 . D = E + F;
92-133 . }
92-134 .
92-135 .
92-136 . switch (pwr stuff)
92-137 . {
92-138 . case one:
92-139 . {
92-140 . run_this;
92-141 . break;
92-142 . }
92-143 . case two:
92-144 . {
92-145 . run_this;
92-146 . break;
92-147 . }
92-148 . default:
92-149 . {
92-150 . SwError;
92-151 . }
92-152 . }
92-153 .
92-154 . FreePtr = HmiStringPtr;
92-155 . A = B-C;
92-156 . A = B+C;
92-157 . A = B+C;
92-158 . A = B/C;
92-159 . A = B+C;
92-160 . A = B*C;
92-161 . A = B*C;
92-162 . A = B+C;
92-163 . A = B*C;
92-164 .
92-165 . if (A == B)
92-166 . {
92-167 . A = B + C;
92-168 . D = E + F;
92-169 . }
92-170 .
92-171 .
92-172 . switch (pwr stuff)
92-173 . {
92-174 . case one:
92-175 . {
92-176 . run_this;
92-177 . break;
92-178 . }
92-179 . case two:
92-180 . {
92-181 . run_this;
92-182 . break;
92-183 . }
92-184 . default:
92-185 . {
92-186 . SwError;
92-187 . }
92-188 . }
92-189 .
92-190 . A = B+C;
92-191 .
92-192 . switch (pwr stuff)
92-193 . {
92-194 . case:
92-195 . case:
92-196 . // stacked case statements but only if there is a new line in between
92-197 .
92-198 . case:
92-199 . case:
92-200 . case:
92-201 . {
92-202 . run_this;
92-203 . break;
92-204 . }
92-205 . default:
92-206 . {
92-207 . halt;
92-208 . }
92-209 . }
92-210 .
92-211 .
92-212 . if (A < B)
92-213 . {
92-214 . A = B + C;
92-215 . D = E + F;
92-216 . }
92-217 .
92-218 . A = B+C;
92-219 . A = B*C;
92-220 . A = B*C;
92-221 . A = B*C;
92-222 . A = B-C;
92-223 . A = B*C;
92-224 . A = B+C;
92-225 . A = B/C;
92-226 .
92-227 . if (A == B)
92-228 . {
92-229 . A = B + C;
92-230 . D = E + F;
92-231 . }
92-232 .
92-233 . A = B*C;
92-234 . A = B/C;
92-235 . A = B-C;
92-236 .
92-237 . if (A eq B)
92-238 . {
92-239 . A = B + C;
92-240 . D = E + F;
92-241 . }
92-242 .
92-243 . A = B/C;
92-244 .
92-245 . if (A != B)
92-246 . {
92-247 . A = B + C;
92-248 . D = E + F;
92-249 . }
92-250 .
92-251 . A = B+C;
92-252 . A = B-C;
92-253 .
92-254 . if (A le B)
92-255 . {
92-256 . A = B + C;
92-257 . D = E + F;
92-258 . }
92-259 .
92-260 . /* LE SV TOC-2425 this is a pwr-06.2.36 req to store*/
92-261 . A = B+C;
92-262 . A = B-C;
92-263 . A = B-C;
92-264 .
92-265 . if (A gt B)
92-266 . {
92-267 . A = B + C;
92-268 . D = E + F;
92-269 . }
92-270 .
92-271 . A = B+C;
92-272 .
92-273 . if (A < B)
92-274 . {
92-275 . A = B + C;
92-276 . D = E + F;
92-277 . }
92-278 .
92-279 .
92-280 . if (A gt B)
92-281 . {
92-282 . A = B + C;
92-283 . D = E + F;
92-284 . }
92-285 .
92-286 .
92-287 . if (A ne B)
92-288 . {
92-289 . A = B + C;
92-290 . D = E + F;
92-291 . }
92-292 .
92-293 .
92-294 . if (A ge B)
92-295 . {
92-296 . A = B + C;
92-297 . D = E + F;
92-298 . }
92-299 .
92-300 . A = B+C;
92-301 . A = B+C;
92-302 . free(FreePtr);
92-303 . A = B+C;
92-304 .
92-305 . if (A > B)
92-306 . {
92-307 . A = B + C;
92-308 . D = E + F;
92-309 . }
92-310 .
92-311 . A = B/C;
92-312 .
92-313 . if (A gt B)
92-314 . {
92-315 . A = B + C;
92-316 . D = E + F;
92-317 . }
92-318 .
92-319 . A = B*C;
92-320 . A = B*C;
92-321 . A = B+C;
92-322 . A = B-C;
92-323 . A = B+C;
92-324 . /* LE SV TOC-2426 this is a pwr-06.2.56 req to validate*/
92-325 . A = B*C;
92-326 . A = B+C;
92-327 . A = B-C;
92-328 . /* LE SV TOC-2427 this is a pwr-06.2.59 req to set RTC*/
92-329 .
92-330 . if (A > B)
92-331 . {
92-332 . A = B + C;
92-333 . D = E + F;
92-334 . }
92-335 .
92-336 .
92-337 . if (A > = B)
92-338 . {
92-339 . A = B + C;
92-340 . D = E + F;
92-341 . }
92-342 .
92-343 . A = 0x0002;
92-344 .
92-345 . if (A ne B)
92-346 . {
92-347 . A = B + C;
92-348 . D = E + F;
92-349 . }
92-350 .
92-351 . A = B-C;
92-352 . A = B-C;
92-353 . // ??? go see ws
92-354 . A = B*C;
92-355 . rcv_buffer = (U16 *) alloc(size+1);
92-356 .
92-357 . if (A ge B)
92-358 . {
92-359 . A = B + C;
92-360 . D = E + F;
92-361 . }
92-362 .
92-363 .
92-364 . if (A ne B)
92-365 . {
92-366 . A = B + C;
92-367 . D = E + F;
92-368 . }
92-369 .
92-370 .
92-371 . if (A < B)
92-372 . {
92-373 . A = B + C;
92-374 . D = E + F;
92-375 . }
92-376 .
92-377 .
92-378 . if (A ge B)
92-379 . {
92-380 . A = B + C;
92-381 . D = E + F;
92-382 . }
92-383 .
92-384 .
92-385 . if (A le B)
92-386 . {
92-387 . A = B + C;
92-388 . D = E + F;
92-389 . }
92-390 .
92-391 .
92-392 . if (A le B)
92-393 . {
92-394 . A = B + C;
92-395 . D = E + F;
92-396 . }
92-397 .
92-398 . A = B-C;
92-399 . A = B/C;
92-400 .
92-401 . if (A != B)
92-402 . {
92-403 . A = B + C;
92-404 . D = E + F;
92-405 . }
92-406 .
92-407 . // max LOC 73
92-408 .
92-409 . }
92-410 .
92 92 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-06.c
93 93 Source: source/ft-app/ft-app-B1.0/pwr/pwr-07.c
93-0 . /*
93-1 . ----------------------------------------------------------------------------
93-2 . --| BEGIN PROLOGUE
93-3 . --|
93-4 . --| CLASSIFICATION: UNCLASSIFIED
93-5 . --|
93-6 . --| FILE NAME: pwr-07.c
93-7 . --|
93-8 . --| ABSTRACT:
93-9 . --| This file contains the 8 functions that do file pwr stuff.
93-10 . --|
93-11 . --| HISTORY:
93-12 . --| CCCQ_NAME:
93-13 . --| CCCQ_VER:
93-14 . --|
93-15 . --| END PROLOGUE
93-16 . ----------------------------------------------------------------------------
93-17 . */
93-18 .
93-19 . #define A;
93-20 . #include C;
93-21 . float B;
93-22 . #define D;
93-23 .
93-24 .
93-25 .
93-26 . /*
93-27 . -----------------------------------------------------------------------------
93-28 . --| NAME: pwr.7.1
93-29 . --|
93-30 . --| ABSTRACT:
93-31 . --| This function does pwr stuff.
93-32 . --|
93-33 . --| RETURNS:
93-34 . --| NONE.
93-35 . --|
93-36 . ----------------------------------------------------------------------------
93-37 . */
93-38 . static void pwr.7.1(void)
93-39 . {
93-40 . A = B/C;
93-41 . A = B/C;
93-42 . /* LE SV TOC-2428 this is a pwr-07.1.3 req to check pSOS*/
93-43 . A = B-C;
93-44 .
93-45 . if (A ge B)
93-46 . {
93-47 . A = B + C;
93-48 . D = E + F;
93-49 . }
93-50 .
93-51 . A = B*C;
93-52 . A = B/C;
93-53 . A = B*C;
93-54 . A = B*C;
93-55 . A = B*C;
93-56 . A = B-C;
93-57 . A = B/C;
93-58 . A = B/C;
93-59 . // max LOC 12
93-60 .
93-61 . }
93-62 .
93-63 .
93-64 . /*
93-65 . -----------------------------------------------------------------------------
93-66 . --| NAME: pwr.7.2
93-67 . --|
93-68 . --| ABSTRACT:
93-69 . --| This function does pwr stuff.
93-70 . --|
93-71 . --| RETURNS:
93-72 . --| NONE.
93-73 . --|
93-74 . ----------------------------------------------------------------------------
93-75 . */
93-76 . static void pwr.7.2(void)
93-77 . {
93-78 .
93-79 . if (A le B)
93-80 . {
93-81 . A = B + C;
93-82 . D = E + F;
93-83 . }
93-84 .
93-85 .
93-86 . if (A < B)
93-87 . {
93-88 . A = B + C;
93-89 . D = E + F;
93-90 . }
93-91 .
93-92 . /* LE SV TOC-2429 this is a pwr-07.2.3 req to audit*/
93-93 . A = B*C;
93-94 . A = 0x0007;
93-95 .
93-96 . /* dead_code = B + C;
93-97 . dead_code = D + E;
93-98 . dead_code = F + G; */
93-99 .
93-100 . A = B+C;
93-101 . A = B/C;
93-102 .
93-103 . switch (pwr stuff)
93-104 . {
93-105 . case one:
93-106 . {
93-107 . run_this;
93-108 . break;
93-109 . }
93-110 . case two:
93-111 . {
93-112 . run_this;
93-113 . break;
93-114 . }
93-115 . default:
93-116 . {
93-117 . SwError;
93-118 . }
93-119 . }
93-120 .
93-121 . A = B*C;
93-122 .
93-123 . if (A eq B)
93-124 . {
93-125 . A = B + C;
93-126 . D = E + F;
93-127 . }
93-128 .
93-129 . A = B/C;
93-130 . A = B-C;
93-131 . A = B-C;
93-132 . A = B/C;
93-133 . A = B/C;
93-134 . A = B*C;
93-135 . A = B/C;
93-136 . A = B+C;
93-137 . A = B-C;
93-138 . A = B-C;
93-139 . A = B+C;
93-140 . A = B-C;
93-141 .
93-142 . if (A gt B)
93-143 . {
93-144 . A = B + C;
93-145 . D = E + F;
93-146 . }
93-147 .
93-148 . A = B-C;
93-149 .
93-150 . switch (pwr stuff)
93-151 . {
93-152 . case one:
93-153 . {
93-154 . run_this;
93-155 . break;
93-156 . }
93-157 . case two:
93-158 . {
93-159 . run_this;
93-160 . break;
93-161 . }
93-162 . default:
93-163 . {
93-164 . SwError;
93-165 . }
93-166 . }
93-167 .
93-168 . A = B+C;
93-169 . /* LE SV TOC-2430 this is a pwr-07.2.25 req to increment*/
93-170 . A = B+C;
93-171 . A = B-C;
93-172 . A = B-C;
93-173 .
93-174 . switch (pwr stuff)
93-175 . {
93-176 . case one:
93-177 . {
93-178 . run_this;
93-179 . break;
93-180 . }
93-181 . case two:
93-182 . {
93-183 . run_this;
93-184 . break;
93-185 . }
93-186 . default:
93-187 . {
93-188 . SwError;
93-189 . }
93-190 . }
93-191 .
93-192 . A = B+C;
93-193 . A = B*C;
93-194 .
93-195 . if (A ne B)
93-196 . {
93-197 . A = B + C;
93-198 . D = E + F;
93-199 . }
93-200 .
93-201 . A = B*C;
93-202 . A = B+C;
93-203 . A = B/C;
93-204 . A = B*C;
93-205 . A = B*C;
93-206 . A = B+C;
93-207 . do forever;
93-208 .
93-209 . switch (pwr stuff)
93-210 . {
93-211 . case one:
93-212 . {
93-213 . run_this;
93-214 . break;
93-215 . }
93-216 . case two:
93-217 . {
93-218 . run_this;
93-219 . break;
93-220 . }
93-221 . default:
93-222 . {
93-223 . SwError;
93-224 . }
93-225 . }
93-226 .
93-227 . /* LE SV TOC-2431 this is a pwr-07.2.39 req to transform*/
93-228 .
93-229 . if (A ge B)
93-230 . {
93-231 . A = B + C;
93-232 . D = E + F;
93-233 . }
93-234 .
93-235 .
93-236 . if (A > B)
93-237 . {
93-238 . A = B + C;
93-239 . D = E + F;
93-240 . }
93-241 .
93-242 . A = B*C;
93-243 . // max LOC 41
93-244 .
93-245 . }
93-246 .
93-247 .
93-248 . /*
93-249 . -----------------------------------------------------------------------------
93-250 . --| NAME: pwr.7.3
93-251 . --|
93-252 . --| ABSTRACT:
93-253 . --| This function does pwr stuff.
93-254 . --|
93-255 . --| RETURNS:
93-256 . --| NONE.
93-257 . --|
93-258 . ----------------------------------------------------------------------------
93-259 . */
93-260 . static void pwr.7.3(void)
93-261 . {
93-262 . /* LE SV TOC-2432 this is a pwr-07.3.1 req to detect error*/
93-263 .
93-264 . if (A gt B)
93-265 . {
93-266 . A = B + C;
93-267 . D = E + F;
93-268 . }
93-269 .
93-270 .
93-271 . if (A eq B)
93-272 . {
93-273 . A = B + C;
93-274 . D = E + F;
93-275 . }
93-276 .
93-277 . A = B/C;
93-278 . A = B/C;
93-279 . A = B-C;
93-280 . A = B*C;
93-281 .
93-282 . if (A == B)
93-283 . {
93-284 . A = B + C;
93-285 . D = E + F;
93-286 . }
93-287 .
93-288 . A = B/C;
93-289 . A = B*C;
93-290 . A = B-C;
93-291 . A = B/C;
93-292 . /* LE SV TOC-2433 this is a pwr-07.3.12 req to set Real Time Clock*/
93-293 .
93-294 . if (A le B)
93-295 . {
93-296 . A = B + C;
93-297 . D = E + F;
93-298 . }
93-299 .
93-300 . A = B*C;
93-301 . A = B/C;
93-302 . A = B+C;
93-303 .
93-304 . if (A lt B)
93-305 . {
93-306 . A = B + C;
93-307 . D = E + F;
93-308 . }
93-309 .
93-310 .
93-311 . if (A > B)
93-312 . {
93-313 . A = B + C;
93-314 . D = E + F;
93-315 . }
93-316 .
93-317 .
93-318 . if (A ge B)
93-319 . {
93-320 . A = B + C;
93-321 . D = E + F;
93-322 . }
93-323 .
93-324 . A = B/C;
93-325 .
93-326 . if (A le B)
93-327 . {
93-328 . A = B + C;
93-329 . D = E + F;
93-330 . }
93-331 .
93-332 . A = B+C;
93-333 . // max LOC 21
93-334 .
93-335 . }
93-336 .
93-337 .
93-338 . /*
93-339 . -----------------------------------------------------------------------------
93-340 . --| NAME: pwr.7.4
93-341 . --|
93-342 . --| ABSTRACT:
93-343 . --| This function does pwr stuff.
93-344 . --|
93-345 . --| RETURNS:
93-346 . --| NONE.
93-347 . --|
93-348 . ----------------------------------------------------------------------------
93-349 . */
93-350 . static void pwr.7.4(void)
93-351 . {
93-352 .
93-353 . if (A != B)
93-354 . {
93-355 . A = B + C;
93-356 . D = E + F;
93-357 . }
93-358 .
93-359 . A = B/C;
93-360 . /* LE SV TOC-2434 this is a pwr-07.4.3 req to validate*/
93-361 . A = B+C;
93-362 . A = B-C;
93-363 . A = B/C;
93-364 . A = B-C;
93-365 . A = B+C;
93-366 .
93-367 . if (A ge B)
93-368 . {
93-369 . A = B + C;
93-370 . D = E + F;
93-371 . }
93-372 .
93-373 .
93-374 . if (A < B)
93-375 . {
93-376 . A = B + C;
93-377 . D = E + F;
93-378 . }
93-379 .
93-380 .
93-381 . if (A ne B)
93-382 . {
93-383 . A = B + C;
93-384 . D = E + F;
93-385 . }
93-386 .
93-387 .
93-388 . if (A le B)
93-389 . {
93-390 . A = B + C;
93-391 . D = E + F;
93-392 . }
93-393 .
93-394 . A = B-C;
93-395 . A = B+C;
93-396 . A = B/C;
93-397 . A = B+C;
93-398 .
93-399 . if (A gt B)
93-400 . {
93-401 . A = B + C;
93-402 . D = E + F;
93-403 . }
93-404 .
93-405 . A = B+C;
93-406 . A = B*C;
93-407 .
93-408 . if (A < B)
93-409 . {
93-410 . A = B + C;
93-411 . D = E + F;
93-412 . }
93-413 .
93-414 . A = B*C;
93-415 . A = B-C;
93-416 .
93-417 . if (A gt B)
93-418 . {
93-419 . A = B + C;
93-420 . D = E + F;
93-421 . }
93-422 .
93-423 . A = B-C;
93-424 .
93-425 . if (A le B)
93-426 . {
93-427 . A = B + C;
93-428 . D = E + F;
93-429 . }
93-430 .
93-431 .
93-432 . if (A == B)
93-433 . {
93-434 . A = B + C;
93-435 . D = E + F;
93-436 . }
93-437 .
93-438 . A = B*C;
93-439 . A = B/C;
93-440 . A = B*C;
93-441 . A = B-C;
93-442 . do forever;
93-443 .
93-444 . if (A > = B)
93-445 . {
93-446 . A = B + C;
93-447 . D = E + F;
93-448 . }
93-449 .
93-450 .
93-451 . if (A ge B)
93-452 . {
93-453 . A = B + C;
93-454 . D = E + F;
93-455 . }
93-456 .
93-457 . A = B/C;
93-458 . // max LOC 32
93-459 .
93-460 . }
93-461 .
93-462 .
93-463 . /*
93-464 . -----------------------------------------------------------------------------
93-465 . --| NAME: pwr.7.5
93-466 . --|
93-467 . --| ABSTRACT:
93-468 . --| This function does pwr stuff.
93-469 . --|
93-470 . --| RETURNS:
93-471 . --| NONE.
93-472 . --|
93-473 . ----------------------------------------------------------------------------
93-474 . */
93-475 . static void pwr.7.5(void)
93-476 . {
93-477 . A = B*C;
93-478 . A = B+C;
93-479 . /* LE SV TOC-2435 this is a pwr-07.5.3 req to record*/
93-480 . A = B+C;
93-481 . A = B*C;
93-482 . A = B/C;
93-483 . A = B+C;
93-484 .
93-485 . if (A lt B)
93-486 . {
93-487 . A = B + C;
93-488 . D = E + F;
93-489 . }
93-490 .
93-491 . A = B*C;
93-492 .
93-493 . switch (pwr stuff)
93-494 . {
93-495 . case one:
93-496 . {
93-497 . switch (nested)
93-498 . {
93-499 . case:
93-500 . X = Y + Z;
93-501 . case:
93-502 . X = Y + Z;
93-503 . default:
93-504 . SwError;
93-505 . }
93-506 . }
93-507 . case two:
93-508 . {
93-509 . run_this;
93-510 . break;
93-511 . }
93-512 . default:
93-513 . {
93-514 . SwError;
93-515 . }
93-516 . }
93-517 .
93-518 . A = B/C;
93-519 .
93-520 . if (A < = B)
93-521 . {
93-522 . A = B + C;
93-523 . D = E + F;
93-524 . }
93-525 .
93-526 . A = B+C;
93-527 .
93-528 . if (A < B)
93-529 . {
93-530 . A = B + C;
93-531 . D = E + F;
93-532 . }
93-533 .
93-534 . A = B+C;
93-535 .
93-536 . if (A lt B)
93-537 . {
93-538 . A = B + C;
93-539 . D = E + F;
93-540 . }
93-541 .
93-542 . /* LE SV TOC-2436 this is a pwr-07.5.15 req to record*/
93-543 . A = B+C;
93-544 . A = B+C;
93-545 . A = B+C;
93-546 . A = B/C;
93-547 . A = B+C;
93-548 . A = B-C;
93-549 . A = (float)B + C;
93-550 . A = B*C;
93-551 . A = B/C;
93-552 . A = B/C;
93-553 . A = B+C;
93-554 . A = B-C;
93-555 . A = B/C;
93-556 .
93-557 . if (A ge B)
93-558 . {
93-559 . A = B + C;
93-560 . D = E + F;
93-561 . }
93-562 .
93-563 .
93-564 . if (A eq B)
93-565 . {
93-566 . A = B + C;
93-567 . D = E + F;
93-568 . }
93-569 .
93-570 . // max LOC 28
93-571 .
93-572 . }
93-573 .
93-574 .
93-575 . /*
93-576 . -----------------------------------------------------------------------------
93-577 . --| NAME: pwr.7.6
93-578 . --|
93-579 . --| ABSTRACT:
93-580 . --| This function does pwr stuff.
93-581 . --|
93-582 . --| RETURNS:
93-583 . --| NONE.
93-584 . --|
93-585 . ----------------------------------------------------------------------------
93-586 . */
93-587 . static void pwr.7.6(void)
93-588 . {
93-589 . A = B+C;
93-590 . A = 0x0002;
93-591 .
93-592 . if (veg)
93-593 . // missing curly brace
93-594 . variable = orange;
93-595 .
93-596 . A = B/C;
93-597 . A = B-C;
93-598 .
93-599 . if (A < B)
93-600 . {
93-601 . A = B + C;
93-602 . D = E + F;
93-603 . }
93-604 .
93-605 . A = B*C;
93-606 . A = B+C;
93-607 . A = B+C;
93-608 .
93-609 . if (A < = B)
93-610 . {
93-611 . A = B + C;
93-612 . D = E + F;
93-613 . }
93-614 .
93-615 . A = B+C;
93-616 . A = B*C;
93-617 .
93-618 . if (A > B)
93-619 . {
93-620 . A = B + C;
93-621 . D = E + F;
93-622 . }
93-623 .
93-624 . A = B-C;
93-625 .
93-626 . if (A > = B)
93-627 . {
93-628 . A = B + C;
93-629 . D = E + F;
93-630 . }
93-631 .
93-632 .
93-633 . if (A lt B)
93-634 . {
93-635 . A = B + C;
93-636 . D = E + F;
93-637 . }
93-638 .
93-639 . A = B*C;
93-640 .
93-641 . if (A ge B)
93-642 . {
93-643 . A = B + C;
93-644 . D = E + F;
93-645 . }
93-646 .
93-647 . A = B*C;
93-648 .
93-649 . if (A < B)
93-650 . {
93-651 . A = B + C;
93-652 . D = E + F;
93-653 . }
93-654 .
93-655 . // max LOC 18
93-656 .
93-657 . }
93-658 .
93-659 .
93-660 . /*
93-661 . -----------------------------------------------------------------------------
93-662 . --| NAME: pwr.7.7
93-663 . --|
93-664 . --| ABSTRACT:
93-665 . --| This function does pwr stuff.
93-666 . --|
93-667 . --| RETURNS:
93-668 . --| NONE.
93-669 . --|
93-670 . ----------------------------------------------------------------------------
93-671 . */
93-672 . static void pwr.7.7(void)
93-673 . {
93-674 .
93-675 . #ifdef LAZY
93-676 . // this is not nice
93-677 . A = B + C;
93-678 . A = B + C;
93-679 . #endif
93-680 .
93-681 .
93-682 . if (A != B)
93-683 . {
93-684 . A = B + C;
93-685 . D = E + F;
93-686 . }
93-687 .
93-688 . A = B+C;
93-689 . A = B+C;
93-690 .
93-691 . if (A != B)
93-692 . {
93-693 . A = B + C;
93-694 . D = E + F;
93-695 . }
93-696 .
93-697 .
93-698 . switch (pwr stuff)
93-699 . {
93-700 . case one:
93-701 . {
93-702 . switch (nested)
93-703 . {
93-704 . case:
93-705 . X = Y + Z;
93-706 . case:
93-707 . X = Y + Z;
93-708 . default:
93-709 . SwError;
93-710 . }
93-711 . }
93-712 . case two:
93-713 . {
93-714 . run_this;
93-715 . break;
93-716 . }
93-717 . default:
93-718 . {
93-719 . SwError;
93-720 . }
93-721 . }
93-722 .
93-723 . A = B-C;
93-724 .
93-725 . if (A > = B)
93-726 . {
93-727 . A = B + C;
93-728 . D = E + F;
93-729 . }
93-730 .
93-731 .
93-732 . if (A eq B)
93-733 . {
93-734 . A = B + C;
93-735 . D = E + F;
93-736 . }
93-737 .
93-738 . A = B-C;
93-739 .
93-740 . if (A > = B)
93-741 . {
93-742 . A = B + C;
93-743 . D = E + F;
93-744 . }
93-745 .
93-746 . A = B*C;
93-747 . A = 0x0006;
93-748 . A = B*C;
93-749 .
93-750 . if (A eq B)
93-751 . {
93-752 . A = B + C;
93-753 . D = E + F;
93-754 . }
93-755 .
93-756 . A = B/C;
93-757 .
93-758 . if (A ne B)
93-759 . {
93-760 . A = B + C;
93-761 . D = E + F;
93-762 . }
93-763 .
93-764 . do forever;
93-765 . A = B+C;
93-766 . A = B-C;
93-767 . A = B+C;
93-768 .
93-769 . if (A == B)
93-770 . {
93-771 . A = B + C;
93-772 . D = E + F;
93-773 . }
93-774 .
93-775 . A = B*C;
93-776 . A = B-C;
93-777 . A = B+C;
93-778 . A = B*C;
93-779 . A = B+C;
93-780 . A = B*C;
93-781 . A = B/C;
93-782 . /* LE SV TOC-2437 this is a pwr-07.7.26 req to enable*/
93-783 .
93-784 . if (A < B)
93-785 . {
93-786 . A = B + C;
93-787 . D = E + F;
93-788 . }
93-789 .
93-790 . A = B-C;
93-791 . A = B/C;
93-792 . A = B+C;
93-793 . A = B*C;
93-794 . A = B*C;
93-795 .
93-796 . if (A < = B)
93-797 . {
93-798 . A = B + C;
93-799 . D = E + F;
93-800 . }
93-801 .
93-802 . A = B+C;
93-803 . A = B+C;
93-804 . A = B-C;
93-805 .
93-806 . if (A le B)
93-807 . {
93-808 . A = B + C;
93-809 . D = E + F;
93-810 . }
93-811 .
93-812 .
93-813 . if (A gt B)
93-814 . {
93-815 . A = B + C;
93-816 . D = E + F;
93-817 . }
93-818 .
93-819 . A = B+C;
93-820 .
93-821 . if (A le B)
93-822 . {
93-823 . A = B + C;
93-824 . D = E + F;
93-825 . }
93-826 .
93-827 . /* LE SV TOC-2438 this is a pwr-07.7.40 req to validate*/
93-828 . A = B*C;
93-829 . A = B*C;
93-830 . A = B+C;
93-831 .
93-832 . if (A ne B)
93-833 . {
93-834 . A = B + C;
93-835 . D = E + F;
93-836 . }
93-837 .
93-838 . /* LE SV TOC-2439 this is a pwr-07.7.44 req to reject*/
93-839 . A = B+C;
93-840 . A = B-C;
93-841 . A = B+C;
93-842 . A = B+C;
93-843 . A = B-C;
93-844 . A = B-C;
93-845 . A = B/C;
93-846 . // max LOC 50
93-847 .
93-848 . }
93-849 .
93-850 .
93-851 . /*
93-852 . -----------------------------------------------------------------------------
93-853 . --| NAME: pwr.7.8
93-854 . --|
93-855 . --| ABSTRACT:
93-856 . --| This function does pwr stuff.
93-857 . --|
93-858 . --| RETURNS:
93-859 . --| NONE.
93-860 . --|
93-861 . ----------------------------------------------------------------------------
93-862 . */
93-863 . static void pwr.7.8(void)
93-864 . {
93-865 . /* LE SV TOC-2440 this is a pwr-07.8.1 req to check pSOS*/
93-866 . free(FreePtr);
93-867 .
93-868 . if (A eq B)
93-869 . {
93-870 . A = B + C;
93-871 . D = E + F;
93-872 . }
93-873 .
93-874 . A = 0x0007;
93-875 . A = B*C;
93-876 . A = B-C;
93-877 . A = B/C;
93-878 . A = B/C;
93-879 .
93-880 . if (A > = B)
93-881 . {
93-882 . A = B + C;
93-883 . D = E + F;
93-884 . }
93-885 .
93-886 . A = B*C;
93-887 .
93-888 . if (A ge B)
93-889 . {
93-890 . A = B + C;
93-891 . D = E + F;
93-892 . }
93-893 .
93-894 .
93-895 . switch (pwr stuff)
93-896 . {
93-897 . case one:
93-898 . {
93-899 . run_this;
93-900 . break;
93-901 . }
93-902 . case two:
93-903 . {
93-904 . run_this;
93-905 . break;
93-906 . }
93-907 . // missing default
93-908 . }
93-909 .
93-910 . A = B/C;
93-911 . A = B/C;
93-912 . A = B/C;
93-913 . A = B/C;
93-914 .
93-915 . if (A == B)
93-916 . {
93-917 . A = B + C;
93-918 . D = E + F;
93-919 . }
93-920 .
93-921 . A = B-C;
93-922 . A = B-C;
93-923 . A = B-C;
93-924 . A = B*C;
93-925 . A = B*C;
93-926 . A = B*C;
93-927 . A = B/C;
93-928 .
93-929 . if (A > = B)
93-930 . {
93-931 . A = B + C;
93-932 . D = E + F;
93-933 . }
93-934 .
93-935 . A = B/C;
93-936 . A = B/C;
93-937 . A = B/C;
93-938 . A = B-C;
93-939 .
93-940 . if (A lt B)
93-941 . {
93-942 . A = B + C;
93-943 . D = E + F;
93-944 . }
93-945 .
93-946 .
93-947 . switch (pwr stuff)
93-948 . {
93-949 . case one:
93-950 . {
93-951 . run_this;
93-952 . break;
93-953 . }
93-954 . case two:
93-955 . {
93-956 . run_this;
93-957 . break;
93-958 . }
93-959 . default:
93-960 . {
93-961 . SwError;
93-962 . }
93-963 . }
93-964 .
93-965 . A = B/C;
93-966 . /* LE SV TOC-2441 this is a pwr-07.8.29 req to recover*/
93-967 . A = B/C;
93-968 . A = B/C;
93-969 . A = B+C;
93-970 . A = B-C;
93-971 . A = B*C;
93-972 .
93-973 . if (A gt B)
93-974 . {
93-975 . A = B + C;
93-976 . D = E + F;
93-977 . }
93-978 .
93-979 .
93-980 . if (A ne B)
93-981 . {
93-982 . A = B + C;
93-983 . D = E + F;
93-984 . }
93-985 .
93-986 . A = B+C;
93-987 . A = B-C;
93-988 . A = B*C;
93-989 . // max LOC 38
93-990 .
93-991 . }
93-992 .
93 93 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-07.c
94 94 Source: source/ft-app/ft-app-B1.0/pwr/pwr-08.c
94-0 . /*
94-1 . ----------------------------------------------------------------------------
94-2 . --| BEGIN PROLOGUE
94-3 . --|
94-4 . --| CLASSIFICATION: UNCLASSIFIED
94-5 . --|
94-6 . --| FILE NAME: pwr-08.c
94-7 . --|
94-8 . --| ABSTRACT:
94-9 . --| This file contains the 3 functions that do file pwr stuff.
94-10 . --|
94-11 . --| HISTORY:
94-12 . --| CCCQ_NAME:
94-13 . --| CCCQ_VER:
94-14 . --|
94-15 . --| END PROLOGUE
94-16 . ----------------------------------------------------------------------------
94-17 . */
94-18 .
94-19 . char D;
94-20 .
94-21 .
94-22 .
94-23 . /*
94-24 . -----------------------------------------------------------------------------
94-25 . --| NAME: pwr.8.1
94-26 . --|
94-27 . --| ABSTRACT:
94-28 . --| This function does pwr stuff.
94-29 . --|
94-30 . --| RETURNS:
94-31 . --| NONE.
94-32 . --|
94-33 . ----------------------------------------------------------------------------
94-34 . */
94-35 . static void pwr.8.1(void)
94-36 . {
94-37 .
94-38 . if {
94-39 . X = Y + Z;
94-40 . }
94-41 . else {
94-42 . halt;
94-43 . }
94-44 .
94-45 . A = B+C;
94-46 . A = B+C;
94-47 . A = B/C;
94-48 . A = B*C;
94-49 . A = B*C;
94-50 . A = B+C;
94-51 . A = B+C;
94-52 . A = B*C;
94-53 . A = B+C;
94-54 . A = B*C;
94-55 . A = B/C;
94-56 .
94-57 . switch (pwr stuff)
94-58 . {
94-59 . case one:
94-60 . {
94-61 . run_this;
94-62 . break;
94-63 . }
94-64 . case two:
94-65 . {
94-66 . run_this;
94-67 . break;
94-68 . }
94-69 . // missing default
94-70 . }
94-71 .
94-72 . A = B+C;
94-73 . FreePtr = HmiStringPtr;
94-74 . A = B-C;
94-75 . A = B-C;
94-76 . A = B+C;
94-77 . A = B*C;
94-78 .
94-79 . if (A le B)
94-80 . {
94-81 . A = B + C;
94-82 . D = E + F;
94-83 . }
94-84 .
94-85 . /* LE SV TOC-2442 this is a pwr-08.1.18 req to audit*/
94-86 . A = B*C;
94-87 .
94-88 . if (A ne B)
94-89 . {
94-90 . A = B + C;
94-91 . D = E + F;
94-92 . }
94-93 .
94-94 .
94-95 . if (A lt B)
94-96 . {
94-97 . A = B + C;
94-98 . D = E + F;
94-99 . }
94-100 .
94-101 . A = B/C;
94-102 .
94-103 . if (A ge B)
94-104 . {
94-105 . A = B + C;
94-106 . D = E + F;
94-107 . }
94-108 .
94-109 . A = B+C;
94-110 . A = B*C;
94-111 . A = B/C;
94-112 . A = B+C;
94-113 . A = B/C;
94-114 . A = B-C;
94-115 .
94-116 . #ifdef LAZY
94-117 . // this is not nice
94-118 . A = B + C;
94-119 . A = B + C;
94-120 . #endif
94-121 .
94-122 . A = B/C;
94-123 .
94-124 . if (A le B)
94-125 . {
94-126 . A = B + C;
94-127 . D = E + F;
94-128 . }
94-129 .
94-130 . /* LE SV TOC-2443 this is a pwr-08.1.31 req to call isr*/
94-131 . A = B+C;
94-132 . A = B-C;
94-133 . A = B/C;
94-134 . /* LE SV TOC-2444 this is a pwr-08.1.34 req to audit*/
94-135 .
94-136 . if (A eq B)
94-137 . {
94-138 . A = B + C;
94-139 . D = E + F;
94-140 . }
94-141 .
94-142 .
94-143 . if (A ne B)
94-144 . {
94-145 . A = B + C;
94-146 . D = E + F;
94-147 . }
94-148 .
94-149 . A = B/C;
94-150 . A = B-C;
94-151 . A = B/C;
94-152 . // max LOC 38
94-153 .
94-154 . }
94-155 .
94-156 .
94-157 . /*
94-158 . -----------------------------------------------------------------------------
94-159 . --| NAME: pwr.8.2
94-160 . --|
94-161 . --| ABSTRACT:
94-162 . --| This function does pwr stuff.
94-163 . --|
94-164 . --| RETURNS:
94-165 . --| NONE.
94-166 . --|
94-167 . ----------------------------------------------------------------------------
94-168 . */
94-169 . static void pwr.8.2(void)
94-170 . {
94-171 . A = B-C;
94-172 . /* LE SV TOC-2445 this is a pwr-08.2.2 req to assign*/
94-173 .
94-174 . if (A > B)
94-175 . {
94-176 . A = B + C;
94-177 . D = E + F;
94-178 . }
94-179 .
94-180 .
94-181 . switch (pwr stuff)
94-182 . {
94-183 . case one:
94-184 . {
94-185 . run_this;
94-186 . break;
94-187 . }
94-188 . case two:
94-189 . {
94-190 . run_this;
94-191 . break;
94-192 . }
94-193 . default:
94-194 . {
94-195 . SwError;
94-196 . }
94-197 . }
94-198 .
94-199 . A = B-C;
94-200 .
94-201 . if (A > = B)
94-202 . {
94-203 . A = B + C;
94-204 . D = E + F;
94-205 . }
94-206 .
94-207 . A = B*C;
94-208 . A = B/C;
94-209 .
94-210 . if (A > = B)
94-211 . {
94-212 . A = B + C;
94-213 . D = E + F;
94-214 . }
94-215 .
94-216 .
94-217 . if (A > = B)
94-218 . {
94-219 . A = B + C;
94-220 . D = E + F;
94-221 . }
94-222 .
94-223 . A = B/C;
94-224 . A = B+C;
94-225 .
94-226 . if (A ne B)
94-227 . {
94-228 . A = B + C;
94-229 . D = E + F;
94-230 . }
94-231 .
94-232 .
94-233 . if (A < B)
94-234 . {
94-235 . A = B + C;
94-236 . D = E + F;
94-237 . }
94-238 .
94-239 .
94-240 . if (A < = B)
94-241 . {
94-242 . A = B + C;
94-243 . D = E + F;
94-244 . }
94-245 .
94-246 .
94-247 . if (A > = B)
94-248 . {
94-249 . A = B + C;
94-250 . D = E + F;
94-251 . }
94-252 .
94-253 .
94-254 . if (A eq B)
94-255 . {
94-256 . A = B + C;
94-257 . D = E + F;
94-258 . }
94-259 .
94-260 . A = B+C;
94-261 . A = B-C;
94-262 . A = B*C;
94-263 . A = B+C;
94-264 . /* LE SV TOC-2446 this is a pwr-08.2.21 req to record*/
94-265 . A = B*C;
94-266 . A = B*C;
94-267 . A = B/C;
94-268 . A = B-C;
94-269 . A = B-C;
94-270 .
94-271 . /*
94-272 . dead_code = B - C;
94-273 . dead_code = D - E;
94-274 . dead_code = F - G;
94-275 . */
94-276 .
94-277 . A = B*C;
94-278 .
94-279 . if (A < = B)
94-280 . {
94-281 . A = B + C;
94-282 . D = E + F;
94-283 . }
94-284 .
94-285 .
94-286 . if (A ne B)
94-287 . {
94-288 . A = B + C;
94-289 . D = E + F;
94-290 . }
94-291 .
94-292 . A = B*C;
94-293 .
94-294 . if (A == B)
94-295 . {
94-296 . A = B + C;
94-297 . D = E + F;
94-298 . }
94-299 .
94-300 .
94-301 . if (A < B)
94-302 . {
94-303 . A = B + C;
94-304 . D = E + F;
94-305 . }
94-306 .
94-307 . /* LE SV TOC-2447 this is a pwr-08.2.32 req to set Real Time Clock*/
94-308 . A = B-C;
94-309 .
94-310 . if (A ne B)
94-311 . {
94-312 . A = B + C;
94-313 . D = E + F;
94-314 . }
94-315 .
94-316 .
94-317 . if (A gt B)
94-318 . {
94-319 . A = B + C;
94-320 . D = E + F;
94-321 . }
94-322 .
94-323 . A = B*C;
94-324 .
94-325 . if (A < B)
94-326 . {
94-327 . A = B + C;
94-328 . D = E + F;
94-329 . }
94-330 .
94-331 . A = B*C;
94-332 .
94-333 . if (A < = B)
94-334 . {
94-335 . A = B + C;
94-336 . D = E + F;
94-337 . }
94-338 .
94-339 . A = B/C;
94-340 .
94-341 . #ifdef LAZY
94-342 . // this is not nice
94-343 . A = B + C;
94-344 . A = B + C;
94-345 . #endif
94-346 .
94-347 . A = B/C;
94-348 . A = B/C;
94-349 . A = B-C;
94-350 . A = B*C;
94-351 . A = B*C;
94-352 . A = 0x0002;
94-353 . A = B-C;
94-354 . A = B/C;
94-355 .
94-356 . if (A ne B)
94-357 . {
94-358 . A = B + C;
94-359 . D = E + F;
94-360 . }
94-361 .
94-362 . A = 0x0002;
94-363 . A = (int)B + C;
94-364 . A = B*C;
94-365 . A = B*C;
94-366 . A = B*C;
94-367 .
94-368 . switch (pwr stuff)
94-369 . {
94-370 . case one:
94-371 . {
94-372 . run_this;
94-373 . break;
94-374 . }
94-375 . case two:
94-376 . {
94-377 . run_this;
94-378 . break;
94-379 . }
94-380 . default:
94-381 . {
94-382 . SwError;
94-383 . }
94-384 . }
94-385 .
94-386 . // max LOC 51
94-387 .
94-388 . }
94-389 .
94-390 .
94-391 . /*
94-392 . -----------------------------------------------------------------------------
94-393 . --| NAME: pwr.8.3
94-394 . --|
94-395 . --| ABSTRACT:
94-396 . --| This function does pwr stuff.
94-397 . --|
94-398 . --| RETURNS:
94-399 . --| NONE.
94-400 . --|
94-401 . ----------------------------------------------------------------------------
94-402 . */
94-403 . static void pwr.8.3(void)
94-404 . {
94-405 .
94-406 . if (A < B)
94-407 . {
94-408 . A = B + C;
94-409 . D = E + F;
94-410 . }
94-411 .
94-412 .
94-413 . if (A ne B)
94-414 . {
94-415 . A = B + C;
94-416 . D = E + F;
94-417 . }
94-418 .
94-419 . A = B/C;
94-420 .
94-421 . if (A le B)
94-422 . {
94-423 . A = B + C;
94-424 . D = E + F;
94-425 . }
94-426 .
94-427 .
94-428 . if (A ne B)
94-429 . {
94-430 . A = B + C;
94-431 . D = E + F;
94-432 . }
94-433 .
94-434 . // TBD - what do I do now
94-435 . A = B+C;
94-436 . A = B*C;
94-437 . A = B*C;
94-438 . A = B+C;
94-439 . A = B-C;
94-440 .
94-441 . if (A lt B)
94-442 . {
94-443 . A = B + C;
94-444 . D = E + F;
94-445 . }
94-446 .
94-447 . A = B/C;
94-448 .
94-449 . if (A != B)
94-450 . {
94-451 . A = B + C;
94-452 . D = E + F;
94-453 . }
94-454 .
94-455 . A = B/C;
94-456 . A = B-C;
94-457 . A = B/C;
94-458 . /* LE SV TOC-2448 this is a pwr-08.3.17 req to reject*/
94-459 .
94-460 . if (A == B)
94-461 . {
94-462 . A = B + C;
94-463 . D = E + F;
94-464 . }
94-465 .
94-466 . A = B+C;
94-467 .
94-468 . if (A == B)
94-469 . {
94-470 . A = B + C;
94-471 . D = E + F;
94-472 . }
94-473 .
94-474 . A = B/C;
94-475 . /* LE SV TOC-2449 this is a pwr-08.3.21 req to update*/
94-476 . A = B*C;
94-477 . A = B/C;
94-478 .
94-479 . if (A eq B)
94-480 . {
94-481 . A = B + C;
94-482 . D = E + F;
94-483 . }
94-484 .
94-485 . A = B/C;
94-486 . A = B*C;
94-487 . A = 0x0007;
94-488 . A = B/C;
94-489 . A = B-C;
94-490 . A = B-C;
94-491 . A = B/C;
94-492 . /* LE SV TOC-2450 this is a pwr-08.3.30 req to call admin*/
94-493 . A = B+C;
94-494 .
94-495 . if (A < = B)
94-496 . {
94-497 . A = B + C;
94-498 . D = E + F;
94-499 . }
94-500 .
94-501 .
94-502 . if (A lt B)
94-503 . {
94-504 . A = B + C;
94-505 . D = E + F;
94-506 . }
94-507 .
94-508 . A = B*C;
94-509 .
94-510 . if (A == B)
94-511 . {
94-512 . A = B + C;
94-513 . D = E + F;
94-514 . }
94-515 .
94-516 . A = B/C;
94-517 . /* LE SV TOC-2451 this is a pwr-08.3.36 req to call isr*/
94-518 .
94-519 . if (A > B)
94-520 . {
94-521 . A = B + C;
94-522 . D = E + F;
94-523 . }
94-524 .
94-525 . A = B-C;
94-526 . A = B+C;
94-527 .
94-528 . switch (pwr stuff)
94-529 . {
94-530 . case one:
94-531 . {
94-532 . run_this;
94-533 . break;
94-534 . }
94-535 . case two:
94-536 . {
94-537 . run_this;
94-538 . break;
94-539 . }
94-540 . default:
94-541 . {
94-542 . SwError;
94-543 . }
94-544 . }
94-545 .
94-546 . A = B-C;
94-547 . A = B*C;
94-548 .
94-549 . if (A < = B)
94-550 . {
94-551 . A = B + C;
94-552 . D = E + F;
94-553 . }
94-554 .
94-555 . A = B*C;
94-556 .
94-557 . if (A eq B)
94-558 . {
94-559 . A = B + C;
94-560 . D = E + F;
94-561 . }
94-562 .
94-563 . // max LOC 44
94-564 .
94-565 . }
94-566 .
94 94 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-08.c
95 95 Source: source/ft-app/ft-app-B1.0/pwr/pwr-09.c
95-0 . /*
95-1 . ----------------------------------------------------------------------------
95-2 . --| BEGIN PROLOGUE
95-3 . --|
95-4 . --| CLASSIFICATION: UNCLASSIFIED
95-5 . --|
95-6 . --| FILE NAME: pwr-09.c
95-7 . --|
95-8 . --| ABSTRACT:
95-9 . --| This file contains the 1 functions that do file pwr stuff.
95-10 . --|
95-11 . --| HISTORY:
95-12 . --| CCCQ_NAME:
95-13 . --| CCCQ_VER:
95-14 . --|
95-15 . --| END PROLOGUE
95-16 . ----------------------------------------------------------------------------
95-17 . */
95-18 .
95-19 . #include A;
95-20 . float B;
95-21 . #define B;
95-22 . #include B;
95-23 .
95-24 .
95-25 .
95-26 . /*
95-27 . -----------------------------------------------------------------------------
95-28 . --| NAME: pwr.9.1
95-29 . --|
95-30 . --| ABSTRACT:
95-31 . --| This function does pwr stuff.
95-32 . --|
95-33 . --| RETURNS:
95-34 . --| NONE.
95-35 . --|
95-36 . ----------------------------------------------------------------------------
95-37 . */
95-38 . static void pwr.9.1(void)
95-39 . {
95-40 .
95-41 . switch (pwr stuff)
95-42 . {
95-43 . case one:
95-44 . {
95-45 . run_this;
95-46 . break;
95-47 . }
95-48 . case two:
95-49 . {
95-50 . run_this;
95-51 . break;
95-52 . }
95-53 . default:
95-54 . {
95-55 . SwError;
95-56 . }
95-57 . }
95-58 .
95-59 .
95-60 . if (A == B)
95-61 . {
95-62 . A = B + C;
95-63 . D = E + F;
95-64 . }
95-65 .
95-66 . A = B+C;
95-67 . A = B/C;
95-68 .
95-69 . if (A le B)
95-70 . {
95-71 . A = B + C;
95-72 . D = E + F;
95-73 . }
95-74 .
95-75 . A = B-C;
95-76 . A = B-C;
95-77 . A = B*C;
95-78 .
95-79 . switch (pwr stuff)
95-80 . {
95-81 . case one:
95-82 . {
95-83 . run_this;
95-84 . break;
95-85 . }
95-86 . case two:
95-87 . {
95-88 . run_this;
95-89 . break;
95-90 . }
95-91 . default:
95-92 . {
95-93 . SwError;
95-94 . }
95-95 . }
95-96 .
95-97 . A = B/C;
95-98 . A = B*C;
95-99 . /* LE SV TOC-2452 this is a pwr-09.1.12 req to translate*/
95-100 .
95-101 . if (A le B)
95-102 . {
95-103 . A = B + C;
95-104 . D = E + F;
95-105 . }
95-106 .
95-107 . A = B+C;
95-108 . A = B*C;
95-109 . A = B/C;
95-110 . A = B*C;
95-111 . A = B/C;
95-112 . /* LE SV TOC-2453 this is a pwr-09.1.18 req to check unix*/
95-113 .
95-114 . if (A != B)
95-115 . {
95-116 . A = B + C;
95-117 . D = E + F;
95-118 . }
95-119 .
95-120 . A = B/C;
95-121 . A = B/C;
95-122 . A = B*C;
95-123 . A = B+C;
95-124 .
95-125 . switch (pwr stuff)
95-126 . {
95-127 . case one:
95-128 . {
95-129 . run_this;
95-130 . break;
95-131 . }
95-132 . case two:
95-133 . {
95-134 . run_this;
95-135 . break;
95-136 . }
95-137 . // missing default
95-138 . }
95-139 .
95-140 . A = B*C;
95-141 . A = B/C;
95-142 . A = B-C;
95-143 . A = B-C;
95-144 . A = B+C;
95-145 . A = B*C;
95-146 .
95-147 . if (A != B)
95-148 . {
95-149 . A = B + C;
95-150 . D = E + F;
95-151 . }
95-152 .
95-153 . A = B-C;
95-154 . // max LOC 30
95-155 .
95-156 . }
95-157 .
95 95 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-09.c
96 96 Source: source/ft-app/ft-app-B1.0/pwr/pwr-10.c
96-0 . /*
96-1 . ----------------------------------------------------------------------------
96-2 . --| BEGIN PROLOGUE
96-3 . --|
96-4 . --| CLASSIFICATION: UNCLASSIFIED
96-5 . --|
96-6 . --| FILE NAME: pwr-10.c
96-7 . --|
96-8 . --| ABSTRACT:
96-9 . --| This file contains the 1 functions that do file pwr stuff.
96-10 . --|
96-11 . --| HISTORY:
96-12 . --| CCCQ_NAME:
96-13 . --| CCCQ_VER:
96-14 . --|
96-15 . --| END PROLOGUE
96-16 . ----------------------------------------------------------------------------
96-17 . */
96-18 .
96-19 . #include D;
96-20 . #include D;
96-21 .
96-22 .
96-23 .
96-24 . /*
96-25 . -----------------------------------------------------------------------------
96-26 . --| NAME: pwr.10.1
96-27 . --|
96-28 . --| ABSTRACT:
96-29 . --| This function does pwr stuff.
96-30 . --|
96-31 . --| RETURNS:
96-32 . --| NONE.
96-33 . --|
96-34 . ----------------------------------------------------------------------------
96-35 . */
96-36 . static void pwr.10.1(void)
96-37 . {
96-38 .
96-39 . if (A != B)
96-40 . {
96-41 . A = B + C;
96-42 . D = E + F;
96-43 . }
96-44 .
96-45 . A = B-C;
96-46 . A = B/C;
96-47 . A = B-C;
96-48 . A = B+C;
96-49 . A = B+C;
96-50 .
96-51 . if (A lt B)
96-52 . {
96-53 . A = B + C;
96-54 . D = E + F;
96-55 . }
96-56 .
96-57 .
96-58 . if (A == B)
96-59 . {
96-60 . A = B + C;
96-61 . D = E + F;
96-62 . }
96-63 .
96-64 .
96-65 . if (A == B)
96-66 . {
96-67 . A = B + C;
96-68 . D = E + F;
96-69 . }
96-70 .
96-71 .
96-72 . if (A le B)
96-73 . {
96-74 . A = B + C;
96-75 . D = E + F;
96-76 . }
96-77 .
96-78 . A = B/C;
96-79 .
96-80 . if (A ne B)
96-81 . {
96-82 . A = B + C;
96-83 . D = E + F;
96-84 . }
96-85 .
96-86 . A = B-C;
96-87 . A = B*C;
96-88 .
96-89 . if (A ne B)
96-90 . {
96-91 . A = B + C;
96-92 . D = E + F;
96-93 . }
96-94 .
96-95 . /* LE SV TOC-2454 this is a pwr-10.1.16 req to set RTC*/
96-96 . A = 0x0004;
96-97 . A = B+C;
96-98 . A = B+C;
96-99 . A = B/C;
96-100 . A = B+C;
96-101 .
96-102 . switch (pwr stuff)
96-103 . {
96-104 . case one:
96-105 . {
96-106 . run_this;
96-107 . break;
96-108 . }
96-109 . case two:
96-110 . {
96-111 . run_this;
96-112 . break;
96-113 . }
96-114 . default:
96-115 . {
96-116 . SwError;
96-117 . }
96-118 . }
96-119 .
96-120 . A = B+C;
96-121 .
96-122 . switch (pwr stuff)
96-123 . {
96-124 . case one:
96-125 . {
96-126 . run_this;
96-127 . break;
96-128 . }
96-129 . case two:
96-130 . {
96-131 . run_this;
96-132 . break;
96-133 . }
96-134 . default:
96-135 . {
96-136 . SwError;
96-137 . }
96-138 . }
96-139 .
96-140 .
96-141 . switch (pwr stuff)
96-142 . {
96-143 . case one:
96-144 . {
96-145 . run_this;
96-146 . break;
96-147 . }
96-148 . case two:
96-149 . {
96-150 . run_this;
96-151 . break;
96-152 . }
96-153 . default:
96-154 . {
96-155 . SwError;
96-156 . }
96-157 . }
96-158 .
96-159 .
96-160 . if (A > = B)
96-161 . {
96-162 . A = B + C;
96-163 . D = E + F;
96-164 . }
96-165 .
96-166 . A = B*C;
96-167 . /* LE SV TOC-2455 this is a pwr-10.1.26 req to detect error*/
96-168 . A = B-C;
96-169 . A = B/C;
96-170 . // TBS - I need to figure this out
96-171 . A = B+C;
96-172 . A = B-C;
96-173 . // max LOC 29
96-174 .
96-175 . }
96-176 .
96 96 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-10.c
97 97 Source: source/ft-app/ft-app-B1.0/pwr/pwr-11.c
97-0 . /*
97-1 . ----------------------------------------------------------------------------
97-2 . --| BEGIN PROLOGUE
97-3 . --|
97-4 . --| CLASSIFICATION: UNCLASSIFIED
97-5 . --|
97-6 . --| FILE NAME: pwr-11.c
97-7 . --|
97-8 . --| ABSTRACT:
97-9 . --| This file contains the 1 functions that do file pwr stuff.
97-10 . --|
97-11 . --| HISTORY:
97-12 . --| CCCQ_NAME:
97-13 . --| CCCQ_VER:
97-14 . --|
97-15 . --| END PROLOGUE
97-16 . ----------------------------------------------------------------------------
97-17 . */
97-18 .
97-19 . #include C;
97-20 . #define D;
97-21 . float B;
97-22 . int A;
97-23 . #define D;
97-24 . #include D;
97-25 . #include C;
97-26 . #include A;
97-27 . #define C;
97-28 .
97-29 .
97-30 .
97-31 . /*
97-32 . -----------------------------------------------------------------------------
97-33 . --| NAME: pwr.11.1
97-34 . --|
97-35 . --| ABSTRACT:
97-36 . --| This function does pwr stuff.
97-37 . --|
97-38 . --| RETURNS:
97-39 . --| NONE.
97-40 . --|
97-41 . ----------------------------------------------------------------------------
97-42 . */
97-43 . static void pwr.11.1(void)
97-44 . {
97-45 .
97-46 . if (A ge B)
97-47 . {
97-48 . A = B + C;
97-49 . D = E + F;
97-50 . }
97-51 .
97-52 .
97-53 . if (A == B)
97-54 . {
97-55 . A = B + C;
97-56 . D = E + F;
97-57 . }
97-58 .
97-59 . A = B+C;
97-60 . A = B/C;
97-61 . A = B/C;
97-62 . A = B*C;
97-63 . A = B/C;
97-64 .
97-65 . if (A < B)
97-66 . {
97-67 . A = B + C;
97-68 . D = E + F;
97-69 . }
97-70 .
97-71 . A = B-C;
97-72 .
97-73 . if {
97-74 . X = Y + Z;
97-75 . }
97-76 . else {
97-77 . halt;
97-78 . }
97-79 .
97-80 . A = B-C;
97-81 . A = B+C;
97-82 . A = B/C;
97-83 . /* LE SV TOC-2456 this is a pwr-11.1.13 req to verify*/
97-84 .
97-85 . /* dead_block = C * D;
97-86 . dead_block = E * F; */
97-87 .
97-88 . A = B+C;
97-89 .
97-90 . if (A == B)
97-91 . {
97-92 . A = B + C;
97-93 . D = E + F;
97-94 . }
97-95 .
97-96 .
97-97 . if (A < = B)
97-98 . {
97-99 . A = B + C;
97-100 . D = E + F;
97-101 . }
97-102 .
97-103 . A = B+C;
97-104 . A = B+C;
97-105 . A = B+C;
97-106 . A = B-C;
97-107 .
97-108 . if (A le B)
97-109 . {
97-110 . A = B + C;
97-111 . D = E + F;
97-112 . }
97-113 .
97-114 . A = B-C;
97-115 . A = B/C;
97-116 . A = B*C;
97-117 . /* LE SV TOC-2457 this is a pwr-11.1.24 req to reject*/
97-118 .
97-119 . if (A > = B)
97-120 . {
97-121 . A = B + C;
97-122 . D = E + F;
97-123 . }
97-124 .
97-125 . A = B/C;
97-126 .
97-127 . if (A gt B)
97-128 . {
97-129 . A = B + C;
97-130 . D = E + F;
97-131 . }
97-132 .
97-133 .
97-134 . switch (pwr stuff)
97-135 . {
97-136 . case:
97-137 . case:
97-138 . // stacked case statements but only if there is a new line in between
97-139 .
97-140 . case:
97-141 . case:
97-142 . case:
97-143 . {
97-144 . run_this;
97-145 . break;
97-146 . }
97-147 . default:
97-148 . {
97-149 . halt;
97-150 . }
97-151 . }
97-152 .
97-153 . A = B*C;
97-154 . /* LE SV TOC-2458 this is a pwr-11.1.28 req to check unix*/
97-155 .
97-156 . if (A ge B)
97-157 . {
97-158 . A = B + C;
97-159 . D = E + F;
97-160 . }
97-161 .
97-162 .
97-163 . if (A gt B)
97-164 . {
97-165 . A = B + C;
97-166 . D = E + F;
97-167 . }
97-168 .
97-169 . A = B/C;
97-170 . A = B+C;
97-171 .
97-172 . if (A < = B)
97-173 . {
97-174 . A = B + C;
97-175 . D = E + F;
97-176 . }
97-177 .
97-178 . A = B/C;
97-179 . A = B-C;
97-180 . A = B*C;
97-181 .
97-182 . if (A gt B)
97-183 . {
97-184 . A = B + C;
97-185 . D = E + F;
97-186 . }
97-187 .
97-188 . A = B-C;
97-189 .
97-190 . if (A lt B)
97-191 . {
97-192 . A = B + C;
97-193 . D = E + F;
97-194 . }
97-195 .
97-196 . A = B+C;
97-197 . /* LE SV TOC-2459 this is a pwr-11.1.40 req to compare*/
97-198 . A = B-C;
97-199 . A = B*C;
97-200 . A = B+C;
97-201 . A = B-C;
97-202 . A = B*C;
97-203 . // max LOC 44
97-204 .
97-205 . }
97-206 .
97 97 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-11.c
98 98 Source: source/ft-app/ft-app-B1.0/pwr/pwr-12.c
98-0 . /*
98-1 . ----------------------------------------------------------------------------
98-2 . --| BEGIN PROLOGUE
98-3 . --|
98-4 . --| CLASSIFICATION: UNCLASSIFIED
98-5 . --|
98-6 . --| FILE NAME: pwr-12.c
98-7 . --|
98-8 . --| ABSTRACT:
98-9 . --| This file contains the 4 functions that do file pwr stuff.
98-10 . --|
98-11 . --| HISTORY:
98-12 . --| CCCQ_NAME:
98-13 . --| CCCQ_VER:
98-14 . --|
98-15 . --| END PROLOGUE
98-16 . ----------------------------------------------------------------------------
98-17 . */
98-18 .
98-19 . float B;
98-20 . #include C;
98-21 . #include D;
98-22 . char D;
98-23 . #include D;
98-24 .
98-25 .
98-26 .
98-27 . /*
98-28 . -----------------------------------------------------------------------------
98-29 . --| NAME: pwr.12.1
98-30 . --|
98-31 . --| ABSTRACT:
98-32 . --| This function does pwr stuff.
98-33 . --|
98-34 . --| RETURNS:
98-35 . --| NONE.
98-36 . --|
98-37 . ----------------------------------------------------------------------------
98-38 . */
98-39 . static void pwr.12.1(void)
98-40 . {
98-41 . A = B*C;
98-42 . A = B+C;
98-43 . A = B+C;
98-44 . A = B/C;
98-45 . A = B-C;
98-46 .
98-47 . if (A == B)
98-48 . {
98-49 . A = B + C;
98-50 . D = E + F;
98-51 . }
98-52 .
98-53 . A = B/C;
98-54 . A = B-C;
98-55 . A = B/C;
98-56 .
98-57 . if (A eq B)
98-58 . {
98-59 . A = B + C;
98-60 . D = E + F;
98-61 . }
98-62 .
98-63 . A = B/C;
98-64 . A = B*C;
98-65 .
98-66 . if (A eq B)
98-67 . {
98-68 . A = B + C;
98-69 . D = E + F;
98-70 . }
98-71 .
98-72 . A = B+C;
98-73 . A = B-C;
98-74 .
98-75 . if (A != B)
98-76 . {
98-77 . A = B + C;
98-78 . D = E + F;
98-79 . }
98-80 .
98-81 . A = B-C;
98-82 . A = B/C;
98-83 .
98-84 . switch (pwr stuff)
98-85 . {
98-86 . case one:
98-87 . {
98-88 . run_this;
98-89 . break;
98-90 . }
98-91 . case two:
98-92 . {
98-93 . run_this;
98-94 . break;
98-95 . }
98-96 . default:
98-97 . {
98-98 . SwError;
98-99 . }
98-100 . }
98-101 .
98-102 . /* LE SV TOC-2460 this is a pwr-12.1.20 req to transform*/
98-103 . A = B-C;
98-104 . A = B+C;
98-105 .
98-106 . if (A lt B)
98-107 . {
98-108 . A = B + C;
98-109 . D = E + F;
98-110 . }
98-111 .
98-112 . /* LE SV TOC-2461 this is a pwr-12.1.23 req to assign*/
98-113 . free(FreePtr);
98-114 . A = B-C;
98-115 . A = B*C;
98-116 . A = B-C;
98-117 .
98-118 . if (A eq B)
98-119 . {
98-120 . A = B + C;
98-121 . D = E + F;
98-122 . }
98-123 .
98-124 . A = B+C;
98-125 . A = B+C;
98-126 . A = B*C;
98-127 . A = B+C;
98-128 . A = B+C;
98-129 . A = B*C;
98-130 . A = B-C;
98-131 .
98-132 . if (A < B)
98-133 . {
98-134 . A = B + C;
98-135 . D = E + F;
98-136 . }
98-137 .
98-138 . A = B+C;
98-139 .
98-140 . if (A > B)
98-141 . {
98-142 . A = B + C;
98-143 . D = E + F;
98-144 . }
98-145 .
98-146 . A = B+C;
98-147 . A = B-C;
98-148 . A = B-C;
98-149 . A = B*C;
98-150 .
98-151 . if (A lt B)
98-152 . {
98-153 . A = B + C;
98-154 . D = E + F;
98-155 . }
98-156 .
98-157 .
98-158 . if (A eq B)
98-159 . {
98-160 . A = B + C;
98-161 . D = E + F;
98-162 . }
98-163 .
98-164 .
98-165 . if (A ne B)
98-166 . {
98-167 . A = B + C;
98-168 . D = E + F;
98-169 . }
98-170 .
98-171 .
98-172 . if (A ne B)
98-173 . {
98-174 . A = B + C;
98-175 . D = E + F;
98-176 . }
98-177 .
98-178 . A = B+C;
98-179 . A = B*C;
98-180 .
98-181 . if (A eq B)
98-182 . {
98-183 . A = B + C;
98-184 . D = E + F;
98-185 . }
98-186 .
98-187 . A = B+C;
98-188 . A = B-C;
98-189 . A = B+C;
98-190 . A = B*C;
98-191 . A = B-C;
98-192 . A = B-C;
98-193 . A = B/C;
98-194 . // max LOC 54
98-195 .
98-196 . }
98-197 .
98-198 .
98-199 . /*
98-200 . -----------------------------------------------------------------------------
98-201 . --| NAME: pwr.12.2
98-202 . --|
98-203 . --| ABSTRACT:
98-204 . --| This function does pwr stuff.
98-205 . --|
98-206 . --| RETURNS:
98-207 . --| NONE.
98-208 . --|
98-209 . ----------------------------------------------------------------------------
98-210 . */
98-211 . static void pwr.12.2(void)
98-212 . {
98-213 . A = B+C;
98-214 . A = B+C;
98-215 . A = B-C;
98-216 .
98-217 . if (A eq B)
98-218 . {
98-219 . A = B + C;
98-220 . D = E + F;
98-221 . }
98-222 .
98-223 .
98-224 . /* dead_code = B + C;
98-225 . dead_code = D + E;
98-226 . dead_code = F + G; */
98-227 .
98-228 . A = B+C;
98-229 .
98-230 . switch (pwr stuff)
98-231 . {
98-232 . case one:
98-233 . {
98-234 . run_this;
98-235 . break;
98-236 . }
98-237 . case two:
98-238 . {
98-239 . run_this;
98-240 . break;
98-241 . }
98-242 . default:
98-243 . {
98-244 . SwError;
98-245 . }
98-246 . }
98-247 .
98-248 . A = B-C;
98-249 . A = B-C;
98-250 .
98-251 . switch (pwr stuff)
98-252 . {
98-253 . case one:
98-254 . {
98-255 . run_this;
98-256 . break;
98-257 . }
98-258 . case two:
98-259 . {
98-260 . run_this;
98-261 . break;
98-262 . }
98-263 . default:
98-264 . {
98-265 . SwError;
98-266 . }
98-267 . }
98-268 .
98-269 . // TBD - what do I do now
98-270 .
98-271 . if (A eq B)
98-272 . {
98-273 . A = B + C;
98-274 . D = E + F;
98-275 . }
98-276 .
98-277 . A = B+C;
98-278 . A = B-C;
98-279 .
98-280 . switch (pwr stuff)
98-281 . {
98-282 . case one:
98-283 . {
98-284 . run_this;
98-285 . break;
98-286 . }
98-287 . case two:
98-288 . {
98-289 . run_this;
98-290 . break;
98-291 . }
98-292 . default:
98-293 . {
98-294 . SwError;
98-295 . }
98-296 . }
98-297 .
98-298 .
98-299 . if (A ne B)
98-300 . {
98-301 . A = B + C;
98-302 . D = E + F;
98-303 . }
98-304 .
98-305 . A = B-C;
98-306 .
98-307 . if (A le B)
98-308 . {
98-309 . A = B + C;
98-310 . D = E + F;
98-311 . }
98-312 .
98-313 . A = B/C;
98-314 . A = B+C;
98-315 . A = 0x0003;
98-316 . A = B+C;
98-317 . A = B*C;
98-318 . A = B*C;
98-319 . A = B/C;
98-320 . A = B-C;
98-321 . /* LE SV TOC-2462 this is a pwr-12.2.24 req to detect error*/
98-322 . A = B*C;
98-323 .
98-324 . if (A lt B)
98-325 . {
98-326 . A = B + C;
98-327 . D = E + F;
98-328 . }
98-329 .
98-330 .
98-331 . if (A gt B)
98-332 . {
98-333 . A = B + C;
98-334 . D = E + F;
98-335 . }
98-336 .
98-337 . A = B-C;
98-338 . A = B/C;
98-339 . A = B/C;
98-340 .
98-341 . switch (pwr stuff)
98-342 . {
98-343 . case one:
98-344 . {
98-345 . run_this;
98-346 . break;
98-347 . }
98-348 . case two:
98-349 . {
98-350 . run_this;
98-351 . break;
98-352 . }
98-353 . default:
98-354 . {
98-355 . SwError;
98-356 . }
98-357 . }
98-358 .
98-359 . A = B*C;
98-360 . A = B/C;
98-361 . A = B*C;
98-362 . A = B+C;
98-363 .
98-364 . if (A lt B)
98-365 . {
98-366 . A = B + C;
98-367 . D = E + F;
98-368 . }
98-369 .
98-370 . A = B-C;
98-371 .
98-372 . if (A le B)
98-373 . {
98-374 . A = B + C;
98-375 . D = E + F;
98-376 . }
98-377 .
98-378 .
98-379 . if (A == B)
98-380 . {
98-381 . A = B + C;
98-382 . D = E + F;
98-383 . }
98-384 .
98-385 . A = B*C;
98-386 . A = B*C;
98-387 . A = B*C;
98-388 . A = B*C;
98-389 . A = B-C;
98-390 . A = B+C;
98-391 . A = B*C;
98-392 . A = B-C;
98-393 . A = B-C;
98-394 . A = B+C;
98-395 . A = B*C;
98-396 . A = B*C;
98-397 . A = B*C;
98-398 . // max LOC 51
98-399 .
98-400 . }
98-401 .
98-402 .
98-403 . /*
98-404 . -----------------------------------------------------------------------------
98-405 . --| NAME: pwr.12.3
98-406 . --|
98-407 . --| ABSTRACT:
98-408 . --| This function does pwr stuff.
98-409 . --|
98-410 . --| RETURNS:
98-411 . --| NONE.
98-412 . --|
98-413 . ----------------------------------------------------------------------------
98-414 . */
98-415 . static void pwr.12.3(void)
98-416 . {
98-417 . A = B*C;
98-418 . /* LE SV TOC-2463 this is a pwr-12.3.2 req to record*/
98-419 . A = B*C;
98-420 . A = B+C;
98-421 .
98-422 . if (A != B)
98-423 . {
98-424 . A = B + C;
98-425 . D = E + F;
98-426 . }
98-427 .
98-428 . A = B-C;
98-429 . A = B*C;
98-430 . A = B*C;
98-431 . A = B-C;
98-432 . A = 0x0003;
98-433 . A = B-C;
98-434 .
98-435 . if (A < B)
98-436 . {
98-437 . A = B + C;
98-438 . D = E + F;
98-439 . }
98-440 .
98-441 . A = B+C;
98-442 . A = B-C;
98-443 . A = B-C;
98-444 .
98-445 . if (A ne B)
98-446 . {
98-447 . A = B + C;
98-448 . D = E + F;
98-449 . }
98-450 .
98-451 .
98-452 . if (A eq B)
98-453 . {
98-454 . A = B + C;
98-455 . D = E + F;
98-456 . }
98-457 .
98-458 . A = B+C;
98-459 . goto error;
98-460 . A = B-C;
98-461 . /* LE SV TOC-2464 this is a pwr-12.3.18 req to enable*/
98-462 .
98-463 . switch (pwr stuff)
98-464 . {
98-465 . case one:
98-466 . {
98-467 . run_this;
98-468 . break;
98-469 . }
98-470 . case two:
98-471 . {
98-472 . run_this;
98-473 . break;
98-474 . }
98-475 . default:
98-476 . {
98-477 . SwError;
98-478 . }
98-479 . }
98-480 .
98-481 . A = B/C;
98-482 . A = B-C;
98-483 . A = B+C;
98-484 . /* LE SV TOC-2465 this is a pwr-12.3.22 req to audit*/
98-485 . A = B+C;
98-486 . A = B*C;
98-487 . A = B-C;
98-488 .
98-489 . switch (pwr stuff)
98-490 . {
98-491 . case one:
98-492 . {
98-493 . run_this;
98-494 . break;
98-495 . }
98-496 . case two:
98-497 . {
98-498 . run_this;
98-499 . break;
98-500 . }
98-501 . default:
98-502 . {
98-503 . // missing error call
98-504 . }
98-505 . }
98-506 .
98-507 . A = B-C;
98-508 . A = (float)B + C;
98-509 .
98-510 . if (A < = B)
98-511 . {
98-512 . A = B + C;
98-513 . D = E + F;
98-514 . }
98-515 .
98-516 . A = B-C;
98-517 . A = B-C;
98-518 . A = B/C;
98-519 . A = B/C;
98-520 . A = B-C;
98-521 . A = B/C;
98-522 . A = B*C;
98-523 . A = B-C;
98-524 .
98-525 . if (A le B)
98-526 . {
98-527 . A = B + C;
98-528 . D = E + F;
98-529 . }
98-530 .
98-531 . A = B/C;
98-532 . do forever;
98-533 .
98-534 . if (A gt B)
98-535 . {
98-536 . A = B + C;
98-537 . D = E + F;
98-538 . }
98-539 .
98-540 .
98-541 . if (A ge B)
98-542 . {
98-543 . A = B + C;
98-544 . D = E + F;
98-545 . }
98-546 .
98-547 . A = B*C;
98-548 . A = B+C;
98-549 . A = 0x0006;
98-550 .
98-551 . if (A ge B)
98-552 . {
98-553 . A = B + C;
98-554 . D = E + F;
98-555 . }
98-556 .
98-557 . A = B-C;
98-558 .
98-559 . if (A < B)
98-560 . {
98-561 . A = B + C;
98-562 . D = E + F;
98-563 . }
98-564 .
98-565 .
98-566 . if (A > = B)
98-567 . {
98-568 . A = B + C;
98-569 . D = E + F;
98-570 . }
98-571 .
98-572 . A = B/C;
98-573 . A = B/C;
98-574 . A = B/C;
98-575 . A = B-C;
98-576 .
98-577 . if (A == B)
98-578 . {
98-579 . A = B + C;
98-580 . D = E + F;
98-581 . }
98-582 .
98-583 .
98-584 . if (A lt B)
98-585 . {
98-586 . A = B + C;
98-587 . D = E + F;
98-588 . }
98-589 .
98-590 . A = B*C;
98-591 . A = B+C;
98-592 .
98-593 . if (A > = B)
98-594 . {
98-595 . A = B + C;
98-596 . D = E + F;
98-597 . }
98-598 .
98-599 .
98-600 . if (A le B)
98-601 . {
98-602 . A = B + C;
98-603 . D = E + F;
98-604 . }
98-605 .
98-606 . A = B*C;
98-607 . A = B+C;
98-608 .
98-609 . if (A < B)
98-610 . {
98-611 . A = B + C;
98-612 . D = E + F;
98-613 . }
98-614 .
98-615 . /* LE SV TOC-2466 this is a pwr-12.3.58 req to detect error*/
98-616 .
98-617 . switch (pwr stuff)
98-618 . {
98-619 . case one:
98-620 . {
98-621 . run_this;
98-622 . break;
98-623 . }
98-624 . case two:
98-625 . {
98-626 . run_this;
98-627 . break;
98-628 . }
98-629 . default:
98-630 . {
98-631 . SwError;
98-632 . }
98-633 . }
98-634 .
98-635 . /* LE SV TOC-2467 this is a pwr-12.3.59 req to call admin*/
98-636 . A = B*C;
98-637 . A = B-C;
98-638 .
98-639 . if (A < B)
98-640 . {
98-641 . A = B + C;
98-642 . D = E + F;
98-643 . }
98-644 .
98-645 . A = B-C;
98-646 . A = B*C;
98-647 . A = B*C;
98-648 .
98-649 . if (A != B)
98-650 . {
98-651 . A = B + C;
98-652 . D = E + F;
98-653 . }
98-654 .
98-655 . A = B+C;
98-656 .
98-657 . if (A ne B)
98-658 . {
98-659 . A = B + C;
98-660 . D = E + F;
98-661 . }
98-662 .
98-663 . /* LE SV TOC-2468 this is a pwr-12.3.68 req to set RTC*/
98-664 .
98-665 . if (A eq B)
98-666 . {
98-667 . A = B + C;
98-668 . D = E + F;
98-669 . }
98-670 .
98-671 .
98-672 . if (A lt B)
98-673 . {
98-674 . A = B + C;
98-675 . D = E + F;
98-676 . }
98-677 .
98-678 .
98-679 . if (A != B)
98-680 . {
98-681 . A = B + C;
98-682 . D = E + F;
98-683 . }
98-684 .
98-685 . A = B-C;
98-686 . A = B*C;
98-687 . A = B*C;
98-688 . // max LOC 73
98-689 .
98-690 . }
98-691 .
98-692 .
98-693 . /*
98-694 . -----------------------------------------------------------------------------
98-695 . --| NAME: pwr.12.4
98-696 . --|
98-697 . --| ABSTRACT:
98-698 . --| This function does pwr stuff.
98-699 . --|
98-700 . --| RETURNS:
98-701 . --| NONE.
98-702 . --|
98-703 . ----------------------------------------------------------------------------
98-704 . */
98-705 . static void pwr.12.4(void)
98-706 . {
98-707 . A = B*C;
98-708 .
98-709 . if (A gt B)
98-710 . {
98-711 . A = B + C;
98-712 . D = E + F;
98-713 . }
98-714 .
98-715 . A = B-C;
98-716 .
98-717 . if (A gt B)
98-718 . {
98-719 . A = B + C;
98-720 . D = E + F;
98-721 . }
98-722 .
98-723 . A = B*C;
98-724 . A = B*C;
98-725 .
98-726 . if (A gt B)
98-727 . {
98-728 . A = B + C;
98-729 . D = E + F;
98-730 . }
98-731 .
98-732 . A = B-C;
98-733 .
98-734 . if (A > = B)
98-735 . {
98-736 . A = B + C;
98-737 . D = E + F;
98-738 . }
98-739 .
98-740 .
98-741 . if (A == B)
98-742 . {
98-743 . A = B + C;
98-744 . D = E + F;
98-745 . }
98-746 .
98-747 . A = B-C;
98-748 . A = B+C;
98-749 . A = B+C;
98-750 . A = B*C;
98-751 . A = B/C;
98-752 . A = B/C;
98-753 . A = B+C;
98-754 . A = B/C;
98-755 . A = B-C;
98-756 . A = B*C;
98-757 . A = B/C;
98-758 . /* LE SV TOC-2469 this is a pwr-12.4.22 req to call isr*/
98-759 . A = B/C;
98-760 .
98-761 . switch (pwr stuff)
98-762 . {
98-763 . case one:
98-764 . {
98-765 . run_this;
98-766 . break;
98-767 . }
98-768 . case two:
98-769 . {
98-770 . run_this;
98-771 . break;
98-772 . }
98-773 . default:
98-774 . {
98-775 . SwError;
98-776 . }
98-777 . }
98-778 .
98-779 . A = B/C;
98-780 .
98-781 . if (A > B)
98-782 . {
98-783 . A = B + C;
98-784 . D = E + F;
98-785 . }
98-786 .
98-787 .
98-788 . if (A le B)
98-789 . {
98-790 . A = B + C;
98-791 . D = E + F;
98-792 . }
98-793 .
98-794 . A = B*C;
98-795 . A = B-C;
98-796 . A = B-C;
98-797 .
98-798 . switch (pwr stuff)
98-799 . {
98-800 . case one:
98-801 . {
98-802 . run_this;
98-803 . break;
98-804 . }
98-805 . case two:
98-806 . {
98-807 . run_this;
98-808 . break;
98-809 . }
98-810 . // missing default
98-811 . }
98-812 .
98-813 . A = B*C;
98-814 . A = B-C;
98-815 .
98-816 . if (A ne B)
98-817 . {
98-818 . A = B + C;
98-819 . D = E + F;
98-820 . }
98-821 .
98-822 .
98-823 . if (A ne B)
98-824 . {
98-825 . A = B + C;
98-826 . D = E + F;
98-827 . }
98-828 .
98-829 . // ??? go see ws
98-830 . A = B+C;
98-831 .
98-832 . if (veg)
98-833 . // missing curly brace
98-834 . variable = orange;
98-835 .
98-836 .
98-837 . if (A le B)
98-838 . {
98-839 . A = B + C;
98-840 . D = E + F;
98-841 . }
98-842 .
98-843 . A = B+C;
98-844 . A = B-C;
98-845 . A = B-C;
98-846 . A = B/C;
98-847 .
98-848 . if (A < B)
98-849 . {
98-850 . A = B + C;
98-851 . D = E + F;
98-852 . }
98-853 .
98-854 .
98-855 . if (A < B)
98-856 . {
98-857 . A = B + C;
98-858 . D = E + F;
98-859 . }
98-860 .
98-861 . A = B+C;
98-862 . A = B/C;
98-863 .
98-864 . if (A lt B)
98-865 . {
98-866 . A = B + C;
98-867 . D = E + F;
98-868 . }
98-869 .
98-870 .
98-871 . if (A le B)
98-872 . {
98-873 . A = B + C;
98-874 . D = E + F;
98-875 . }
98-876 .
98-877 .
98-878 . if (A > = B)
98-879 . {
98-880 . A = B + C;
98-881 . D = E + F;
98-882 . }
98-883 .
98-884 . A = B*C;
98-885 .
98-886 . if (A eq B)
98-887 . {
98-888 . A = B + C;
98-889 . D = E + F;
98-890 . }
98-891 .
98-892 .
98-893 . if (A < = B)
98-894 . {
98-895 . A = B + C;
98-896 . D = E + F;
98-897 . }
98-898 .
98-899 . A = B/C;
98-900 . A = B/C;
98-901 .
98-902 . if (A lt B)
98-903 . {
98-904 . A = B + C;
98-905 . D = E + F;
98-906 . }
98-907 .
98-908 . A = B-C;
98-909 . A = B/C;
98-910 .
98-911 . if (A == B)
98-912 . {
98-913 . A = B + C;
98-914 . D = E + F;
98-915 . }
98-916 .
98-917 . A = B*C;
98-918 . /* LE SV TOC-2470 this is a pwr-12.4.57 req to reject*/
98-919 . A = B+C;
98-920 . A = B/C;
98-921 . A = B/C;
98-922 . A = B*C;
98-923 . A = B*C;
98-924 .
98-925 . if (A != B)
98-926 . {
98-927 . A = B + C;
98-928 . D = E + F;
98-929 . }
98-930 .
98-931 . A = B+C;
98-932 . A = B-C;
98-933 .
98-934 . if (A gt B)
98-935 . {
98-936 . A = B + C;
98-937 . D = E + F;
98-938 . }
98-939 .
98-940 . A = B-C;
98-941 . A = B-C;
98-942 .
98-943 . if (A ne B)
98-944 . {
98-945 . A = B + C;
98-946 . D = E + F;
98-947 . }
98-948 .
98-949 .
98-950 . switch (pwr stuff)
98-951 . {
98-952 . case:
98-953 . case:
98-954 . // stacked case statements but only if there is a new line in between
98-955 .
98-956 . case:
98-957 . case:
98-958 . case:
98-959 . {
98-960 . run_this;
98-961 . break;
98-962 . }
98-963 . default:
98-964 . {
98-965 . halt;
98-966 . }
98-967 . }
98-968 .
98-969 . A = B/C;
98-970 . A = B*C;
98-971 . A = B/C;
98-972 . A = B+C;
98-973 . A = 0x0003;
98-974 .
98-975 . if (A le B)
98-976 . {
98-977 . A = B + C;
98-978 . D = E + F;
98-979 . }
98-980 .
98-981 .
98-982 . if (A ge B)
98-983 . {
98-984 . A = B + C;
98-985 . D = E + F;
98-986 . }
98-987 .
98-988 . A = B+C;
98-989 . A = B/C;
98-990 . A = B/C;
98-991 . // max LOC 77
98-992 .
98-993 . }
98-994 .
98 98 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-12.c
99 99 Source: source/ft-app/ft-app-B1.0/pwr/pwr-13.c
99-0 . /*
99-1 . ----------------------------------------------------------------------------
99-2 . --| BEGIN PROLOGUE
99-3 . --|
99-4 . --| CLASSIFICATION: UNCLASSIFIED
99-5 . --|
99-6 . --| FILE NAME: pwr-13.c
99-7 . --|
99-8 . --| ABSTRACT:
99-9 . --| This file contains the 1 functions that do file pwr stuff.
99-10 . --|
99-11 . --| HISTORY:
99-12 . --| CCCQ_NAME:
99-13 . --| CCCQ_VER:
99-14 . --|
99-15 . --| END PROLOGUE
99-16 . ----------------------------------------------------------------------------
99-17 . */
99-18 .
99-19 . #include C;
99-20 . #include D;
99-21 . int A;
99-22 . #include A;
99-23 . int A;
99-24 .
99-25 .
99-26 .
99-27 . /*
99-28 . -----------------------------------------------------------------------------
99-29 . --| NAME: pwr.13.1
99-30 . --|
99-31 . --| ABSTRACT:
99-32 . --| This function does pwr stuff.
99-33 . --|
99-34 . --| RETURNS:
99-35 . --| NONE.
99-36 . --|
99-37 . ----------------------------------------------------------------------------
99-38 . */
99-39 . static void pwr.13.1(void)
99-40 . {
99-41 . A = B*C;
99-42 . A = B*C;
99-43 .
99-44 . switch (pwr stuff)
99-45 . {
99-46 . case one:
99-47 . {
99-48 . run_this;
99-49 . break;
99-50 . }
99-51 . case two:
99-52 . {
99-53 . run_this;
99-54 . break;
99-55 . }
99-56 . default:
99-57 . {
99-58 . SwError;
99-59 . }
99-60 . }
99-61 .
99-62 . A = B-C;
99-63 .
99-64 . if (A > = B)
99-65 . {
99-66 . A = B + C;
99-67 . D = E + F;
99-68 . }
99-69 .
99-70 .
99-71 . if (A < = B)
99-72 . {
99-73 . A = B + C;
99-74 . D = E + F;
99-75 . }
99-76 .
99-77 .
99-78 . if (A < = B)
99-79 . {
99-80 . A = B + C;
99-81 . D = E + F;
99-82 . }
99-83 .
99-84 . A = B/C;
99-85 .
99-86 . switch (pwr stuff)
99-87 . {
99-88 . case one:
99-89 . {
99-90 . run_this;
99-91 . break;
99-92 . }
99-93 . case two:
99-94 . {
99-95 . run_this;
99-96 . break;
99-97 . }
99-98 . default:
99-99 . {
99-100 . SwError;
99-101 . }
99-102 . }
99-103 .
99-104 .
99-105 . if (A ne B)
99-106 . {
99-107 . A = B + C;
99-108 . D = E + F;
99-109 . }
99-110 .
99-111 . A = B/C;
99-112 . A = B+C;
99-113 . A = B+C;
99-114 . /* LE SV TOC-2471 this is a pwr-13.1.14 req to call admin*/
99-115 . A = B-C;
99-116 . A = B+C;
99-117 .
99-118 . if (A > B)
99-119 . {
99-120 . A = B + C;
99-121 . D = E + F;
99-122 . }
99-123 .
99-124 . A = B*C;
99-125 . A = B-C;
99-126 .
99-127 . if (A ge B)
99-128 . {
99-129 . A = B + C;
99-130 . D = E + F;
99-131 . }
99-132 .
99-133 .
99-134 . if (A ne B)
99-135 . {
99-136 . A = B + C;
99-137 . D = E + F;
99-138 . }
99-139 .
99-140 .
99-141 . if (A < = B)
99-142 . {
99-143 . A = B + C;
99-144 . D = E + F;
99-145 . }
99-146 .
99-147 . A = B-C;
99-148 . A = B-C;
99-149 . A = B-C;
99-150 . A = B*C;
99-151 . A = 0x0002;
99-152 .
99-153 . if (A == B)
99-154 . {
99-155 . A = B + C;
99-156 . D = E + F;
99-157 . }
99-158 .
99-159 . A = B-C;
99-160 .
99-161 . if (A gt B)
99-162 . {
99-163 . A = B + C;
99-164 . D = E + F;
99-165 . }
99-166 .
99-167 . A = B+C;
99-168 . A = B*C;
99-169 .
99-170 . if (A < = B)
99-171 . {
99-172 . A = B + C;
99-173 . D = E + F;
99-174 . }
99-175 .
99-176 . /* LE SV TOC-2472 this is a pwr-13.1.32 req to assign*/
99-177 . A = B*C;
99-178 .
99-179 . switch (pwr stuff)
99-180 . {
99-181 . case one:
99-182 . {
99-183 . run_this;
99-184 . break;
99-185 . }
99-186 . case two:
99-187 . {
99-188 . run_this;
99-189 . break;
99-190 . }
99-191 . default:
99-192 . {
99-193 . SwError;
99-194 . }
99-195 . }
99-196 .
99-197 .
99-198 . if (A > = B)
99-199 . {
99-200 . A = B + C;
99-201 . D = E + F;
99-202 . }
99-203 .
99-204 . A = B/C;
99-205 . A = B-C;
99-206 . A = B-C;
99-207 .
99-208 . if (A == B)
99-209 . {
99-210 . A = B + C;
99-211 . D = E + F;
99-212 . }
99-213 .
99-214 . // (P) this is really improtant
99-215 .
99-216 . if (A eq B)
99-217 . {
99-218 . A = B + C;
99-219 . D = E + F;
99-220 . }
99-221 .
99-222 . A = B-C;
99-223 . /* LE SV TOC-2473 this is a pwr-13.1.41 req to translate*/
99-224 . A = (float)B + C;
99-225 . A = B-C;
99-226 . /* LE SV TOC-2474 this is a pwr-13.1.42 req to detect error*/
99-227 . A = B-C;
99-228 . A = B-C;
99-229 . A = B/C;
99-230 . A = B+C;
99-231 . A = B+C;
99-232 . A = B+C;
99-233 .
99-234 . if (A le B)
99-235 . {
99-236 . A = B + C;
99-237 . D = E + F;
99-238 . }
99-239 .
99-240 . A = B/C;
99-241 .
99-242 . if (A ne B)
99-243 . {
99-244 . A = B + C;
99-245 . D = E + F;
99-246 . }
99-247 .
99-248 . A = B-C;
99-249 .
99-250 . if (A > B)
99-251 . {
99-252 . A = B + C;
99-253 . D = E + F;
99-254 . }
99-255 .
99-256 . A = 0x0001;
99-257 . A = B/C;
99-258 . A = B/C;
99-259 .
99-260 . if (A < B)
99-261 . {
99-262 . A = B + C;
99-263 . D = E + F;
99-264 . }
99-265 .
99-266 .
99-267 . if (A > = B)
99-268 . {
99-269 . A = B + C;
99-270 . D = E + F;
99-271 . }
99-272 .
99-273 . A = B/C;
99-274 . A = B/C;
99-275 . A = B-C;
99-276 . // max LOC 59
99-277 .
99-278 . }
99-279 .
99 99 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-13.c