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

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

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

12/08/2003 16:09:41

Details Report

1 1 Source: source/pr-app/pr-app-MSAW123/msaw-01.c
 1-0 . /*
 1-1 . ----------------------------------------------------------------------------
 1-2 . --| BEGIN PROLOGUE
 1-3 . --|
 1-4 . --| CLASSIFICATION: UNCLASSIFIED
 1-5 . --|
 1-6 . --| FILE NAME:      msaw-01.c
 1-7 . --|
 1-8 . --| ABSTRACT:
 1-9 . --|   This file contains the 1 functions that do file msaw stuff.
 1-10 . --|
 1-11 . --| HISTORY:
 1-12 . --|   CCCQ_NAME:
 1-13 . --|   CCCQ_VER: 
 1-14 . --|
 1-15 . --| END PROLOGUE
 1-16 . ----------------------------------------------------------------------------
 1-17 . */
 1-18 . 
 1-19 . #include D;
 1-20 . #define D;
 1-21 . #define B;
 1-22 . #define C;
 1-23 . #include A;
 1-24 . #define C;
 1-25 . 
 1-26 . 
 1-27 . 
 1-28 . /*
 1-29 . -----------------------------------------------------------------------------
 1-30 . --| NAME:   msaw.1.1
 1-31 . --|
 1-32 . --| ABSTRACT:
 1-33 . --|   This function does msaw stuff.
 1-34 . --|
 1-35 . --| RETURNS:
 1-36 . --|   NONE.
 1-37 . --|
 1-38 . ----------------------------------------------------------------------------
 1-39 . */
 1-40 . static void msaw.1.1(void)
 1-41 . {
 1-42 . A = B*C;
 1-43 . 
 1-44 . switch (msaw stuff)
 1-45 . {
 1-46 .    case one:
 1-47 .    {
 1-48 .       run_this; 
 1-49 .       break;
 1-50 .    }
 1-51 .    case two:
 1-52 .    {
 1-53 .       run_this;
 1-54 .       break;
 1-55 .    }
 1-56 .    default:
 1-57 .    {
 1-58 .        SwError;
 1-59 .    }
 1-60 . }
 1-61 . 
 1-62 . 
 1-63 . if (A != B)
 1-64 . {
 1-65 .    A = B + C;
 1-66 .    D = E + F;
 1-67 . }
 1-68 . 
 1-69 . 
 1-70 . if (A gt B)
 1-71 . {
 1-72 .    A = B + C;
 1-73 .    D = E + F;
 1-74 . }
 1-75 . 
 1-76 . A = B*C;
 1-77 . 
 1-78 . if (A gt B)
 1-79 . {
 1-80 .    A = B + C;
 1-81 .    D = E + F;
 1-82 . }
 1-83 . 
 1-84 . A = B-C;
 1-85 . A = B/C;
 1-86 . A = B*C;
 1-87 . 
 1-88 . if (A gt B)
 1-89 . {
 1-90 .    A = B + C;
 1-91 .    D = E + F;
 1-92 . }
 1-93 . 
 1-94 . A = B-C;
 1-95 . 
 1-96 . if (A le B)
 1-97 . {
 1-98 .    A = B + C;
 1-99 .    D = E + F;
 1-100 . }
 1-101 . 
 1-102 . A = B*C;
 1-103 . 
 1-104 . if (A <  B)
 1-105 . {
 1-106 .    A = B + C;
 1-107 .    D = E + F;
 1-108 . }
 1-109 . 
 1-110 . 
 1-111 . if (A != B)
 1-112 . {
 1-113 .    A = B + C;
 1-114 .    D = E + F;
 1-115 . }
 1-116 . 
 1-117 . A = B+C;
 1-118 . A = B/C;
 1-119 . 
 1-120 . if (A le B)
 1-121 . {
 1-122 .    A = B + C;
 1-123 .    D = E + F;
 1-124 . }
 1-125 . 
 1-126 . A = B+C;
 1-127 . 
 1-128 . if (A > = B)
 1-129 . {
 1-130 .    A = B + C;
 1-131 .    D = E + F;
 1-132 . }
 1-133 . 
 1-134 . A = B-C;
 1-135 . A = B+C;
 1-136 . A = B+C;
 1-137 . A = B/C;
 1-138 . A = B-C;
 1-139 . 
 1-140 . switch (msaw stuff)
 1-141 . {
 1-142 .    case one:
 1-143 .    {
 1-144 .       run_this; 
 1-145 .       break;
 1-146 .    }
 1-147 .    case two:
 1-148 .    {
 1-149 .       run_this;
 1-150 .       break;
 1-151 .    }
 1-152 .    default:
 1-153 .    {
 1-154 .        SwError;
 1-155 .    }
 1-156 . }
 1-157 . 
 1-158 . A = B-C;
 1-159 . A = B/C;
 1-160 . /* LE SV TOC-2201 this is a msaw-01.1.29 req to increment*/
 1-161 . 
 1-162 . switch (msaw stuff)
 1-163 . {
 1-164 .    case one:
 1-165 .    {
 1-166 .       run_this; 
 1-167 .       break;
 1-168 .    }
 1-169 .    case two:
 1-170 .    {
 1-171 .       run_this;
 1-172 .       break;
 1-173 .    }
 1-174 .    default:
 1-175 .    {
 1-176 .        SwError;
 1-177 .    }
 1-178 . }
 1-179 . 
 1-180 . A = B/C;
 1-181 . 
 1-182 . if (A ge B)
 1-183 . {
 1-184 .    A = B + C;
 1-185 .    D = E + F;
 1-186 . }
 1-187 . 
 1-188 . A = B+C;
 1-189 . A = 0x0009;
 1-190 . A = B+C;
 1-191 . A = B*C;
 1-192 . A = B*C;
 1-193 . 
 1-194 . if (A ne B)
 1-195 . {
 1-196 .    A = B + C;
 1-197 .    D = E + F;
 1-198 . }
 1-199 . 
 1-200 . 
 1-201 . if (A ge B)
 1-202 . {
 1-203 .    A = B + C;
 1-204 .    D = E + F;
 1-205 . }
 1-206 . 
 1-207 . A = B/C;
 1-208 . 
 1-209 . if (A ne B)
 1-210 . {
 1-211 .    A = B + C;
 1-212 .    D = E + F;
 1-213 . }
 1-214 . 
 1-215 . A = B*C;
 1-216 . A = (long)B + C;
 1-217 . A = B+C;
 1-218 . A = B-C;
 1-219 . A = B/C;
 1-220 . A = B+C;
 1-221 . A = B-C;
 1-222 . A = B/C;
 1-223 . A = B/C;
 1-224 . // max LOC 47
 1-225 . 
 1-226 . }
 1-227 . 

1 1 Result: result/source/pr-app/pr-app-MSAW123/msaw-01.c


2 2 Source: source/pr-app/pr-app-MSAW123/msaw-02.c
 2-0 . 
 2-1 . 
 2-2 . #define A;
 2-3 . #include C;
 2-4 . float B;
 2-5 . #define A;
 2-6 . #define B;
 2-7 . double C;
 2-8 . 
 2-9 . 
 2-10 . 
 2-11 . /*
 2-12 . -----------------------------------------------------------------------------
 2-13 . --| NAME:   msaw.2.1
 2-14 . --|
 2-15 . --| ABSTRACT:
 2-16 . --|   This function does msaw stuff.
 2-17 . --|
 2-18 . --| RETURNS:
 2-19 . --|   NONE.
 2-20 . --|
 2-21 . ----------------------------------------------------------------------------
 2-22 . */
 2-23 . static void msaw.2.1(void)
 2-24 . {
 2-25 . A = B*C;
 2-26 . A = B+C;
 2-27 . 
 2-28 . switch (msaw stuff)
 2-29 . {
 2-30 .    case one:
 2-31 .    {
 2-32 .       run_this; 
 2-33 .       break;
 2-34 .    }
 2-35 .    case two:
 2-36 .    {
 2-37 .       run_this;
 2-38 .       break;
 2-39 .    }
 2-40 .    default:
 2-41 .    {
 2-42 .        SwError;
 2-43 .    }
 2-44 . }
 2-45 . 
 2-46 . 
 2-47 . if (A le B)
 2-48 . {
 2-49 .    A = B + C;
 2-50 .    D = E + F;
 2-51 . }
 2-52 . 
 2-53 . /* LE SV TOC-2202 this is a msaw-02.1.5 req to recover*/
 2-54 . A = B-C;
 2-55 . A = B*C;
 2-56 . A = B+C;
 2-57 . A = B*C;
 2-58 . /* LE SV TOC-2203 this is a msaw-02.1.9 req to process*/
 2-59 . 
 2-60 . switch (msaw stuff)
 2-61 . {
 2-62 .    case one:
 2-63 .    {
 2-64 .       run_this; 
 2-65 .       break;
 2-66 .    }
 2-67 .    case two:
 2-68 .    {
 2-69 .       run_this;
 2-70 .       break;
 2-71 .    }
 2-72 .    default:
 2-73 .    {
 2-74 .        SwError;
 2-75 .    }
 2-76 . }
 2-77 . 
 2-78 . A = B/C;
 2-79 . A = B*C;
 2-80 . /* LE SV TOC-2204 this is a msaw-02.1.12 req to compare*/
 2-81 . A = B+C;
 2-82 . A = B+C;
 2-83 . A = 0x0001;
 2-84 . 
 2-85 . if (A gt B)
 2-86 . {
 2-87 .    A = B + C;
 2-88 .    D = E + F;
 2-89 . }
 2-90 . 
 2-91 . 
 2-92 . switch (msaw stuff)
 2-93 . {
 2-94 .    case one:
 2-95 .    {
 2-96 .       run_this; 
 2-97 .       break;
 2-98 .    }
 2-99 .    case two:
 2-100 .    {
 2-101 .       run_this;
 2-102 .       break;
 2-103 .    }
 2-104 .    default:
 2-105 .    {
 2-106 .        SwError;
 2-107 .    }
 2-108 . }
 2-109 . 
 2-110 . A = B/C;
 2-111 . /* LE SV TOC-2205 this is a msaw-02.1.17 req to transform*/
 2-112 . 
 2-113 . if (A >  B)
 2-114 . {
 2-115 .    A = B + C;
 2-116 .    D = E + F;
 2-117 . }
 2-118 . 
 2-119 . 
 2-120 . if (A <  B)
 2-121 . {
 2-122 .    A = B + C;
 2-123 .    D = E + F;
 2-124 . }
 2-125 . 
 2-126 . A = B-C;
 2-127 . 
 2-128 . if (A ne B)
 2-129 . {
 2-130 .    A = B + C;
 2-131 .    D = E + F;
 2-132 . }
 2-133 . 
 2-134 . 
 2-135 . if (A ge B)
 2-136 . {
 2-137 .    A = B + C;
 2-138 .    D = E + F;
 2-139 . }
 2-140 . 
 2-141 . /* LE SV TOC-2206 this is a msaw-02.1.22 req to recover*/
 2-142 . A = B+C;
 2-143 . A = B/C;
 2-144 . A = B*C;
 2-145 . A = B-C;
 2-146 . A = B/C;
 2-147 . A = B-C;
 2-148 . 
 2-149 . if (A gt B)
 2-150 . {
 2-151 .    A = B + C;
 2-152 .    D = E + F;
 2-153 . }
 2-154 . 
 2-155 . A = B*C;
 2-156 . A = B/C;
 2-157 . A = B+C;
 2-158 . 
 2-159 . if (A > = B)
 2-160 . {
 2-161 .    A = B + C;
 2-162 .    D = E + F;
 2-163 . }
 2-164 . 
 2-165 . FreePtr = HmiStringPtr;
 2-166 . 
 2-167 . if (A != B)
 2-168 . {
 2-169 .    A = B + C;
 2-170 .    D = E + F;
 2-171 . }
 2-172 . 
 2-173 . A = B/C;
 2-174 . A = B+C;
 2-175 . 
 2-176 . if (A == B)
 2-177 . {
 2-178 .    A = B + C;
 2-179 .    D = E + F;
 2-180 . }
 2-181 . 
 2-182 . /* LE SV TOC-2207 this is a msaw-02.1.37 req to check unix*/
 2-183 . 
 2-184 . if (A ge B)
 2-185 . {
 2-186 .    A = B + C;
 2-187 .    D = E + F;
 2-188 . }
 2-189 . 
 2-190 . A = B-C;
 2-191 . 
 2-192 . if (A == B)
 2-193 . {
 2-194 .    A = B + C;
 2-195 .    D = E + F;
 2-196 . }
 2-197 . 
 2-198 . A = B-C;
 2-199 . A = B+C;
 2-200 . A = B*C;
 2-201 . A = B-C;
 2-202 . A = B/C;
 2-203 . A = B+C;
 2-204 . A = B/C;
 2-205 . A = B-C;
 2-206 . A = B/C;
 2-207 . A = 0x0002;
 2-208 . 
 2-209 . if (A le B)
 2-210 . {
 2-211 .    A = B + C;
 2-212 .    D = E + F;
 2-213 . }
 2-214 . 
 2-215 . A = B+C;
 2-216 . 
 2-217 . switch (msaw stuff)
 2-218 . {
 2-219 .    case one:
 2-220 .    {
 2-221 .       run_this;
 2-222 .       break;
 2-223 .    }
 2-224 .    case two:
 2-225 .    {
 2-226 .       run_this;
 2-227 .       break;
 2-228 .    }
 2-229 .    // missing default
 2-230 . }
 2-231 . 
 2-232 . A = B/C;
 2-233 . A = B*C;
 2-234 . A = B/C;
 2-235 . 
 2-236 . if (A eq B)
 2-237 . {
 2-238 .    A = B + C;
 2-239 .    D = E + F;
 2-240 . }
 2-241 . 
 2-242 . 
 2-243 . if (A != B)
 2-244 . {
 2-245 .    A = B + C;
 2-246 .    D = E + F;
 2-247 . }
 2-248 . 
 2-249 . 
 2-250 . if (A lt B)
 2-251 . {
 2-252 .    A = B + C;
 2-253 .    D = E + F;
 2-254 . }
 2-255 . 
 2-256 . 
 2-257 . if (A ge B)
 2-258 . {
 2-259 .    A = B + C;
 2-260 .    D = E + F;
 2-261 . }
 2-262 . 
 2-263 . 
 2-264 . if (A != B)
 2-265 . {
 2-266 .    A = B + C;
 2-267 .    D = E + F;
 2-268 . }
 2-269 . 
 2-270 . 
 2-271 . if (A < = B)
 2-272 . {
 2-273 .    A = B + C;
 2-274 .    D = E + F;
 2-275 . }
 2-276 . 
 2-277 . 
 2-278 . switch (msaw stuff)
 2-279 . {
 2-280 .    case one:
 2-281 .    {
 2-282 .       run_this; 
 2-283 .       break;
 2-284 .    }
 2-285 .    case two:
 2-286 .    {
 2-287 .       run_this;
 2-288 .       break;
 2-289 .    }
 2-290 .    default:
 2-291 .    {
 2-292 .        SwError;
 2-293 .    }
 2-294 . }
 2-295 . 
 2-296 . A = B/C;
 2-297 . 
 2-298 . if (A le B)
 2-299 . {
 2-300 .    A = B + C;
 2-301 .    D = E + F;
 2-302 . }
 2-303 . 
 2-304 . A = B*C;
 2-305 . A = B+C;
 2-306 . A = B-C;
 2-307 . A = B*C;
 2-308 . A = B-C;
 2-309 . A = B*C;
 2-310 . 
 2-311 . if (A gt B)
 2-312 . {
 2-313 .    A = B + C;
 2-314 .    D = E + F;
 2-315 . }
 2-316 . 
 2-317 . 
 2-318 . if (A lt B)
 2-319 . {
 2-320 .    A = B + C;
 2-321 .    D = E + F;
 2-322 . }
 2-323 . 
 2-324 . A = B/C;
 2-325 . A = B-C;
 2-326 . 
 2-327 . if (A <  B)
 2-328 . {
 2-329 .    A = B + C;
 2-330 .    D = E + F;
 2-331 . }
 2-332 . 
 2-333 . A = B-C;
 2-334 . 
 2-335 . if (A ge B)
 2-336 . {
 2-337 .    A = B + C;
 2-338 .    D = E + F;
 2-339 . }
 2-340 . 
 2-341 . A = B-C;
 2-342 . /* LE SV TOC-2208 this is a msaw-02.1.77 req to translate*/
 2-343 . 
 2-344 . if (A < = B)
 2-345 . {
 2-346 .    A = B + C;
 2-347 .    D = E + F;
 2-348 . }
 2-349 . 
 2-350 . free(FreePtr);
 2-351 . A = B-C;
 2-352 . A = B/C;
 2-353 . 
 2-354 . if (A > = B)
 2-355 . {
 2-356 .    A = B + C;
 2-357 .    D = E + F;
 2-358 . }
 2-359 . 
 2-360 . A = B*C;
 2-361 . A = B+C;
 2-362 . A = B*C;
 2-363 . 
 2-364 . if (A ge B)
 2-365 . {
 2-366 .    A = B + C;
 2-367 .    D = E + F;
 2-368 . }
 2-369 . 
 2-370 . A = B+C;
 2-371 . 
 2-372 . if (A != B)
 2-373 . {
 2-374 .    A = B + C;
 2-375 .    D = E + F;
 2-376 . }
 2-377 . 
 2-378 . A = B*C;
 2-379 . A = B/C;
 2-380 . A = B/C;
 2-381 . A = B/C;
 2-382 . A = B/C;
 2-383 . // max LOC 91
 2-384 . 
 2-385 . }
 2-386 . 
 2-387 . 
 2-388 . /*
 2-389 . -----------------------------------------------------------------------------
 2-390 . --| NAME:   msaw.2.2
 2-391 . --|
 2-392 . --| ABSTRACT:
 2-393 . --|   This function does msaw stuff.
 2-394 . --|
 2-395 . --| RETURNS:
 2-396 . --|   NONE.
 2-397 . --|
 2-398 . ----------------------------------------------------------------------------
 2-399 . */
 2-400 . static void msaw.2.2(void)
 2-401 . {
 2-402 . 
 2-403 . if (A >  B)
 2-404 . {
 2-405 .    A = B + C;
 2-406 .    D = E + F;
 2-407 . }
 2-408 . 
 2-409 . A = B+C;
 2-410 . A = B+C;
 2-411 . A = B*C;
 2-412 . send_buffer = (U16 *) malloc(size+1);
 2-413 . A = B+C;
 2-414 . A = B/C;
 2-415 . 
 2-416 . if (A le B)
 2-417 . {
 2-418 .    A = B + C;
 2-419 .    D = E + F;
 2-420 . }
 2-421 . 
 2-422 . A = B/C;
 2-423 . 
 2-424 . if (A != B)
 2-425 . {
 2-426 .    A = B + C;
 2-427 .    D = E + F;
 2-428 . }
 2-429 . 
 2-430 . 
 2-431 . if (A != B)
 2-432 . {
 2-433 .    A = B + C;
 2-434 .    D = E + F;
 2-435 . }
 2-436 . 
 2-437 . A = B-C;
 2-438 . 
 2-439 . if (A ge B)
 2-440 . {
 2-441 .    A = B + C;
 2-442 .    D = E + F;
 2-443 . }
 2-444 . 
 2-445 . A = B-C;
 2-446 . A = B/C;
 2-447 . A = B-C;
 2-448 . A = B*C;
 2-449 . A = B+C;
 2-450 . A = B*C;
 2-451 . 
 2-452 . if (A <  B)
 2-453 . {
 2-454 .    A = B + C;
 2-455 .    D = E + F;
 2-456 . }
 2-457 . 
 2-458 . 
 2-459 . if (A gt B)
 2-460 . {
 2-461 .    A = B + C;
 2-462 .    D = E + F;
 2-463 . }
 2-464 . 
 2-465 . 
 2-466 . if (A gt B)
 2-467 . {
 2-468 .    A = B + C;
 2-469 .    D = E + F;
 2-470 . }
 2-471 . 
 2-472 . 
 2-473 . if (A le B)
 2-474 . {
 2-475 .    A = B + C;
 2-476 .    D = E + F;
 2-477 . }
 2-478 . 
 2-479 . 
 2-480 . if (A gt B)
 2-481 . {
 2-482 .    A = B + C;
 2-483 .    D = E + F;
 2-484 . }
 2-485 . 
 2-486 . /* LE SV TOC-2209 this is a msaw-02.2.24 req to convert*/
 2-487 . 
 2-488 . switch (msaw stuff)
 2-489 . {
 2-490 .    case one:
 2-491 .    {
 2-492 .       run_this; 
 2-493 .       // missing break
 2-494 .    }
 2-495 .    case two:
 2-496 .    {
 2-497 .       run_this;
 2-498 .       break;
 2-499 .    }
 2-500 .    default:
 2-501 .    {
 2-502 .       SwError;
 2-503 .    }
 2-504 . }
 2-505 . 
 2-506 . A = B+C;
 2-507 . A = B*C;
 2-508 . A = B+C;
 2-509 . A = B-C;
 2-510 . 
 2-511 . if (A le B)
 2-512 . {
 2-513 .    A = B + C;
 2-514 .    D = E + F;
 2-515 . }
 2-516 . 
 2-517 . 
 2-518 . if (A < = B)
 2-519 . {
 2-520 .    A = B + C;
 2-521 .    D = E + F;
 2-522 . }
 2-523 . 
 2-524 . A = B/C;
 2-525 . 
 2-526 . switch (msaw stuff)
 2-527 . {
 2-528 .    case one:
 2-529 .    {
 2-530 .       run_this; 
 2-531 .       break;
 2-532 .    }
 2-533 .    case two:
 2-534 .    {
 2-535 .       run_this;
 2-536 .       break;
 2-537 .    }
 2-538 .    default:
 2-539 .    {
 2-540 .        SwError;
 2-541 .    }
 2-542 . }
 2-543 . 
 2-544 . A = B-C;
 2-545 . 
 2-546 . if (A le B)
 2-547 . {
 2-548 .    A = B + C;
 2-549 .    D = E + F;
 2-550 . }
 2-551 . 
 2-552 . A = B*C;
 2-553 . A = B+C;
 2-554 . A = B*C;
 2-555 . A = B-C;
 2-556 . A = B*C;
 2-557 . 
 2-558 . switch (msaw stuff)
 2-559 . {
 2-560 .    case one:
 2-561 .    {
 2-562 .       run_this; 
 2-563 .       // missing break
 2-564 .    }
 2-565 .    case two:
 2-566 .    {
 2-567 .       run_this;
 2-568 .       break;
 2-569 .    }
 2-570 .    default:
 2-571 .    {
 2-572 .       SwError;
 2-573 .    }
 2-574 . }
 2-575 . 
 2-576 . A = B*C;
 2-577 . A = B*C;
 2-578 . 
 2-579 . if (A gt B)
 2-580 . {
 2-581 .    A = B + C;
 2-582 .    D = E + F;
 2-583 . }
 2-584 . 
 2-585 . 
 2-586 . if (A == B)
 2-587 . {
 2-588 .    A = B + C;
 2-589 .    D = E + F;
 2-590 . }
 2-591 . 
 2-592 . A = B/C;
 2-593 . 
 2-594 . switch (msaw stuff)
 2-595 . {
 2-596 .    case one:
 2-597 .    {
 2-598 .       run_this; 
 2-599 .       // missing break
 2-600 .    }
 2-601 .    case two:
 2-602 .    {
 2-603 .       run_this;
 2-604 .       break;
 2-605 .    }
 2-606 .    default:
 2-607 .    {
 2-608 .       SwError;
 2-609 .    }
 2-610 . }
 2-611 . 
 2-612 . A = B*C;
 2-613 . A = B*C;
 2-614 . A = B*C;
 2-615 . A = B*C;
 2-616 . // max LOC 47
 2-617 . 
 2-618 . }
 2-619 . 

2 2 Result: result/source/pr-app/pr-app-MSAW123/msaw-02.c


3 3 Source: source/pr-app/pr-app-MSAW123/msaw-03.c
 3-0 . /*
 3-1 . ----------------------------------------------------------------------------
 3-2 . --| BEGIN PROLOGUE
 3-3 . --|
 3-4 . --| CLASSIFICATION: UNCLASSIFIED
 3-5 . --|
 3-6 . --| FILE NAME:      msaw-03.c
 3-7 . --|
 3-8 . --| ABSTRACT:
 3-9 . --|   This file contains the 12 functions that do file msaw stuff.
 3-10 . --|
 3-11 . --| HISTORY:
 3-12 . --|   CCCQ_NAME:
 3-13 . --|   CCCQ_VER: 
 3-14 . --|
 3-15 . --| END PROLOGUE
 3-16 . ----------------------------------------------------------------------------
 3-17 . */
 3-18 . 
 3-19 . double C;
 3-20 . #define C;
 3-21 . #define A;
 3-22 . 
 3-23 . 
 3-24 . 
 3-25 . /*
 3-26 . -----------------------------------------------------------------------------
 3-27 . --| NAME:   msaw.3.1
 3-28 . --|
 3-29 . --| ABSTRACT:
 3-30 . --|   This function does msaw stuff.
 3-31 . --|
 3-32 . --| RETURNS:
 3-33 . --|   NONE.
 3-34 . --|
 3-35 . ----------------------------------------------------------------------------
 3-36 . */
 3-37 . static void msaw.3.1(void)
 3-38 . {
 3-39 . 
 3-40 . if {
 3-41 .    X = Y + Z;
 3-42 . }
 3-43 . else {
 3-44 .    halt;
 3-45 . }
 3-46 . 
 3-47 . A = B+C;
 3-48 . A = B*C;
 3-49 . A = B/C;
 3-50 . 
 3-51 . if (A > = B)
 3-52 . {
 3-53 .    A = B + C;
 3-54 .    D = E + F;
 3-55 . }
 3-56 . 
 3-57 . A = B*C;
 3-58 . A = B*C;
 3-59 . A = B-C;
 3-60 . A = B-C;
 3-61 . 
 3-62 . if (A ge B)
 3-63 . {
 3-64 .    A = B + C;
 3-65 .    D = E + F;
 3-66 . }
 3-67 . 
 3-68 . A = B-C;
 3-69 . A = B+C;
 3-70 . 
 3-71 . if (A >  B)
 3-72 . {
 3-73 .    A = B + C;
 3-74 .    D = E + F;
 3-75 . }
 3-76 . 
 3-77 . A = B*C;
 3-78 . 
 3-79 . if (A != B)
 3-80 . {
 3-81 .    A = B + C;
 3-82 .    D = E + F;
 3-83 . }
 3-84 . 
 3-85 . A = B+C;
 3-86 . 
 3-87 . /* dead_code = B + C; 
 3-88 . dead_code = D + E; 
 3-89 . dead_code = F + G; */
 3-90 . 
 3-91 . 
 3-92 . if (A == B)
 3-93 . {
 3-94 .    A = B + C;
 3-95 .    D = E + F;
 3-96 . }
 3-97 . 
 3-98 . A = B*C;
 3-99 . 
 3-100 . if (A <  B)
 3-101 . {
 3-102 .    A = B + C;
 3-103 .    D = E + F;
 3-104 . }
 3-105 . 
 3-106 . A = B*C;
 3-107 . A = B+C;
 3-108 . A = B/C;
 3-109 . 
 3-110 . if (A >  B)
 3-111 . {
 3-112 .    A = B + C;
 3-113 .    D = E + F;
 3-114 . }
 3-115 . 
 3-116 . A = B/C;
 3-117 . A = B/C;
 3-118 . 
 3-119 . switch (msaw stuff)
 3-120 . {
 3-121 .    case one:
 3-122 .    {
 3-123 .       run_this; 
 3-124 .       break;
 3-125 .    }
 3-126 .    case two:
 3-127 .    {
 3-128 .       run_this;
 3-129 .       break;
 3-130 .    }
 3-131 .    default:
 3-132 .    {
 3-133 .        SwError;
 3-134 .    }
 3-135 . }
 3-136 . 
 3-137 . 
 3-138 . if (A == B)
 3-139 . {
 3-140 .    A = B + C;
 3-141 .    D = E + F;
 3-142 . }
 3-143 . 
 3-144 . /* LE SV TOC-2210 this is a msaw-03.1.27 req to verify*/
 3-145 . A = B+C;
 3-146 . A = B+C;
 3-147 . 
 3-148 . switch (msaw stuff)
 3-149 . {
 3-150 .    case one:
 3-151 .    {
 3-152 .       run_this; 
 3-153 .       break;
 3-154 .    }
 3-155 .    case two:
 3-156 .    {
 3-157 .       run_this;
 3-158 .       break;
 3-159 .    }
 3-160 .    default:
 3-161 .    {
 3-162 .        SwError;
 3-163 .    }
 3-164 . }
 3-165 . 
 3-166 . A = B*C;
 3-167 . A = B+C;
 3-168 . 
 3-169 . if (A eq B)
 3-170 . {
 3-171 .    A = B + C;
 3-172 .    D = E + F;
 3-173 . }
 3-174 . 
 3-175 . A = B+C;
 3-176 . A = B-C;
 3-177 . A = B/C;
 3-178 . A = 0x0003;
 3-179 . /* dead_code = A * B; */
 3-180 . A = B+C;
 3-181 . 
 3-182 . if (A < = B)
 3-183 . {
 3-184 .    A = B + C;
 3-185 .    D = E + F;
 3-186 . }
 3-187 . 
 3-188 . A = B/C;
 3-189 . 
 3-190 . if (A le B)
 3-191 . {
 3-192 .    A = B + C;
 3-193 .    D = E + F;
 3-194 . }
 3-195 . 
 3-196 . A = B/C;
 3-197 . A = B-C;
 3-198 . A = B/C;
 3-199 . A = B/C;
 3-200 . A = B+C;
 3-201 . A = B*C;
 3-202 . A = B+C;
 3-203 . A = B*C;
 3-204 . 
 3-205 . if (A != B)
 3-206 . {
 3-207 .    A = B + C;
 3-208 .    D = E + F;
 3-209 . }
 3-210 . 
 3-211 . 
 3-212 . if (A lt B)
 3-213 . {
 3-214 .    A = B + C;
 3-215 .    D = E + F;
 3-216 . }
 3-217 . 
 3-218 . A = B/C;
 3-219 . A = B-C;
 3-220 . A = B+C;
 3-221 . A = B*C;
 3-222 . A = B/C;
 3-223 . 
 3-224 . if (A le B)
 3-225 . {
 3-226 .    A = B + C;
 3-227 .    D = E + F;
 3-228 . }
 3-229 . 
 3-230 . A = B+C;
 3-231 . 
 3-232 . if (A <  B)
 3-233 . {
 3-234 .    A = B + C;
 3-235 .    D = E + F;
 3-236 . }
 3-237 . 
 3-238 . 
 3-239 . if (A <  B)
 3-240 . {
 3-241 .    A = B + C;
 3-242 .    D = E + F;
 3-243 . }
 3-244 . 
 3-245 . A = B+C;
 3-246 . /* LE SV TOC-2211 this is a msaw-03.1.60 req to compare*/
 3-247 . A = B*C;
 3-248 . 
 3-249 . switch (msaw stuff)
 3-250 . {
 3-251 .    case one:
 3-252 .    {
 3-253 .       run_this; 
 3-254 .       break;
 3-255 .    }
 3-256 .    case two:
 3-257 .    {
 3-258 .       run_this;
 3-259 .       break;
 3-260 .    }
 3-261 .    default:
 3-262 .    {
 3-263 .        SwError;
 3-264 .    }
 3-265 . }
 3-266 . 
 3-267 . 
 3-268 . if (A != B)
 3-269 . {
 3-270 .    A = B + C;
 3-271 .    D = E + F;
 3-272 . }
 3-273 . 
 3-274 . 
 3-275 . if (A lt B)
 3-276 . {
 3-277 .    A = B + C;
 3-278 .    D = E + F;
 3-279 . }
 3-280 . 
 3-281 . A = B*C;
 3-282 . 
 3-283 . if (A == B)
 3-284 . {
 3-285 .    A = B + C;
 3-286 .    D = E + F;
 3-287 . }
 3-288 . 
 3-289 . A = B-C;
 3-290 . 
 3-291 . if (A <  B)
 3-292 . {
 3-293 .    A = B + C;
 3-294 .    D = E + F;
 3-295 . }
 3-296 . 
 3-297 . 
 3-298 . if (A ne B)
 3-299 . {
 3-300 .    A = B + C;
 3-301 .    D = E + F;
 3-302 . }
 3-303 . 
 3-304 . A = B*C;
 3-305 . A = B/C;
 3-306 . 
 3-307 . if (A ne B)
 3-308 . {
 3-309 .    A = B + C;
 3-310 .    D = E + F;
 3-311 . }
 3-312 . 
 3-313 . 
 3-314 . if (A != B)
 3-315 . {
 3-316 .    A = B + C;
 3-317 .    D = E + F;
 3-318 . }
 3-319 . 
 3-320 . A = B-C;
 3-321 . A = B*C;
 3-322 . 
 3-323 . if (A ge B)
 3-324 . {
 3-325 .    A = B + C;
 3-326 .    D = E + F;
 3-327 . }
 3-328 . 
 3-329 . /* LE SV TOC-2212 this is a msaw-03.1.76 req to call isr*/
 3-330 . A = B+C;
 3-331 . A = B/C;
 3-332 . 
 3-333 . switch (msaw stuff)
 3-334 . {
 3-335 .    case one:
 3-336 .    {
 3-337 .       run_this; 
 3-338 .       // missing break
 3-339 .    }
 3-340 .    case two:
 3-341 .    {
 3-342 .       run_this;
 3-343 .       break;
 3-344 .    }
 3-345 .    default:
 3-346 .    {
 3-347 .       SwError;
 3-348 .    }
 3-349 . }
 3-350 . 
 3-351 . 
 3-352 . if (A == B)
 3-353 . {
 3-354 .    A = B + C;
 3-355 .    D = E + F;
 3-356 . }
 3-357 . 
 3-358 . 
 3-359 . if (A <  B)
 3-360 . {
 3-361 .    A = B + C;
 3-362 .    D = E + F;
 3-363 . }
 3-364 . 
 3-365 . A = B*C;
 3-366 . 
 3-367 . if (A != B)
 3-368 . {
 3-369 .    A = B + C;
 3-370 .    D = E + F;
 3-371 . }
 3-372 . 
 3-373 . A = B*C;
 3-374 . A = B-C;
 3-375 . // max LOC 83
 3-376 . 
 3-377 . }
 3-378 . 
 3-379 . 
 3-380 . /*
 3-381 . -----------------------------------------------------------------------------
 3-382 . --| NAME:   msaw.3.2
 3-383 . --|
 3-384 . --| ABSTRACT:
 3-385 . --|   This function does msaw stuff.
 3-386 . --|
 3-387 . --| RETURNS:
 3-388 . --|   NONE.
 3-389 . --|
 3-390 . ----------------------------------------------------------------------------
 3-391 . */
 3-392 . static void msaw.3.2(void)
 3-393 . {
 3-394 . A = B+C;
 3-395 . A = B+C;
 3-396 . A = B*C;
 3-397 . A = B/C;
 3-398 . A = B+C;
 3-399 . A = B*C;
 3-400 . 
 3-401 . if (A ge B)
 3-402 . {
 3-403 .    A = B + C;
 3-404 .    D = E + F;
 3-405 . }
 3-406 . 
 3-407 . A = B-C;
 3-408 . A = B*C;
 3-409 . /* LE SV TOC-2213 this is a msaw-03.2.10 req to convert*/
 3-410 . 
 3-411 . if (veg)
 3-412 .    // missing curly brace
 3-413 .    variable = orange;
 3-414 . 
 3-415 . A = B*C;
 3-416 . 
 3-417 . if (A ge B)
 3-418 . {
 3-419 .    A = B + C;
 3-420 .    D = E + F;
 3-421 . }
 3-422 . 
 3-423 . 
 3-424 . if (A lt B)
 3-425 . {
 3-426 .    A = B + C;
 3-427 .    D = E + F;
 3-428 . }
 3-429 . 
 3-430 . 
 3-431 . if (veg)
 3-432 .    // missing curly brace
 3-433 .    variable = orange;
 3-434 . 
 3-435 . A = B*C;
 3-436 . 
 3-437 . if (A ge B)
 3-438 . {
 3-439 .    A = B + C;
 3-440 .    D = E + F;
 3-441 . }
 3-442 . 
 3-443 . A = B*C;
 3-444 . 
 3-445 . if (A ge B)
 3-446 . {
 3-447 .    A = B + C;
 3-448 .    D = E + F;
 3-449 . }
 3-450 . 
 3-451 . A = B-C;
 3-452 . 
 3-453 . switch (msaw stuff)
 3-454 . {
 3-455 .    case one:
 3-456 .    {
 3-457 .       run_this; 
 3-458 .       break;
 3-459 .    }
 3-460 .    case two:
 3-461 .    {
 3-462 .       run_this;
 3-463 .       break;
 3-464 .    }
 3-465 .    default:
 3-466 .    {
 3-467 .        SwError;
 3-468 .    }
 3-469 . }
 3-470 . 
 3-471 . A = B+C;
 3-472 . A = B+C;
 3-473 . A = B*C;
 3-474 . 
 3-475 . if (A <  B)
 3-476 . {
 3-477 .    A = B + C;
 3-478 .    D = E + F;
 3-479 . }
 3-480 . 
 3-481 . A = B*C;
 3-482 . A = B+C;
 3-483 . A = B+C;
 3-484 . A = B-C;
 3-485 . A = B/C;
 3-486 . 
 3-487 . if (A gt B)
 3-488 . {
 3-489 .    A = B + C;
 3-490 .    D = E + F;
 3-491 . }
 3-492 . 
 3-493 . A = B-C;
 3-494 . A = B*C;
 3-495 . 
 3-496 . if (A le B)
 3-497 . {
 3-498 .    A = B + C;
 3-499 .    D = E + F;
 3-500 . }
 3-501 . 
 3-502 . A = B+C;
 3-503 . A = B/C;
 3-504 . A = B-C;
 3-505 . A = B-C;
 3-506 . 
 3-507 . if (A > = B)
 3-508 . {
 3-509 .    A = B + C;
 3-510 .    D = E + F;
 3-511 . }
 3-512 . 
 3-513 . 
 3-514 . if (A == B)
 3-515 . {
 3-516 .    A = B + C;
 3-517 .    D = E + F;
 3-518 . }
 3-519 . 
 3-520 . A = B/C;
 3-521 . A = B+C;
 3-522 . 
 3-523 . if (A ne B)
 3-524 . {
 3-525 .    A = B + C;
 3-526 .    D = E + F;
 3-527 . }
 3-528 . 
 3-529 . 
 3-530 . if (A ne B)
 3-531 . {
 3-532 .    A = B + C;
 3-533 .    D = E + F;
 3-534 . }
 3-535 . 
 3-536 . A = B+C;
 3-537 . goto error;
 3-538 . A = B-C;
 3-539 . A = B-C;
 3-540 . A = B-C;
 3-541 . A = B+C;
 3-542 . A = B/C;
 3-543 . /* LE SV TOC-2214 this is a msaw-03.2.48 req to store*/
 3-544 . A = B/C;
 3-545 . 
 3-546 . if (A eq B)
 3-547 . {
 3-548 .    A = B + C;
 3-549 .    D = E + F;
 3-550 . }
 3-551 . 
 3-552 . /* LE SV TOC-2215 this is a msaw-03.2.50 req to fail*/
 3-553 . A = B*C;
 3-554 . 
 3-555 . if (A > = B)
 3-556 . {
 3-557 .    A = B + C;
 3-558 .    D = E + F;
 3-559 . }
 3-560 . 
 3-561 . A = B-C;
 3-562 . 
 3-563 . if (A == B)
 3-564 . {
 3-565 .    A = B + C;
 3-566 .    D = E + F;
 3-567 . }
 3-568 . 
 3-569 . A = B*C;
 3-570 . A = B-C;
 3-571 . 
 3-572 . if (A eq B)
 3-573 . {
 3-574 .    A = B + C;
 3-575 .    D = E + F;
 3-576 . }
 3-577 . 
 3-578 . 
 3-579 . if (A < = B)
 3-580 . {
 3-581 .    A = B + C;
 3-582 .    D = E + F;
 3-583 . }
 3-584 . 
 3-585 . 
 3-586 . if (A ne B)
 3-587 . {
 3-588 .    A = B + C;
 3-589 .    D = E + F;
 3-590 . }
 3-591 . 
 3-592 . A = B-C;
 3-593 . A = B*C;
 3-594 . 
 3-595 . if (A != B)
 3-596 . {
 3-597 .    A = B + C;
 3-598 .    D = E + F;
 3-599 . }
 3-600 . 
 3-601 . A = B*C;
 3-602 . A = B/C;
 3-603 . A = B/C;
 3-604 . A = B-C;
 3-605 . A = B+C;
 3-606 . A = B-C;
 3-607 . 
 3-608 . if (A gt B)
 3-609 . {
 3-610 .    A = B + C;
 3-611 .    D = E + F;
 3-612 . }
 3-613 . 
 3-614 . A = B/C;
 3-615 . 
 3-616 . /* dead_code = B + C; 
 3-617 . dead_code = D + E; 
 3-618 . dead_code = F + G; */
 3-619 . 
 3-620 . A = B-C;
 3-621 . 
 3-622 . /* dead_block = C * D; 
 3-623 . dead_block = E * F; */
 3-624 . 
 3-625 . A = B*C;
 3-626 . 
 3-627 . if (A le B)
 3-628 . {
 3-629 .    A = B + C;
 3-630 .    D = E + F;
 3-631 . }
 3-632 . 
 3-633 . 
 3-634 . if (A >  B)
 3-635 . {
 3-636 .    A = B + C;
 3-637 .    D = E + F;
 3-638 . }
 3-639 . 
 3-640 . // max LOC 73
 3-641 . 
 3-642 . }
 3-643 . 
 3-644 . 
 3-645 . /*
 3-646 . -----------------------------------------------------------------------------
 3-647 . --| NAME:   msaw.3.3
 3-648 . --|
 3-649 . --| ABSTRACT:
 3-650 . --|   This function does msaw stuff.
 3-651 . --|
 3-652 . --| RETURNS:
 3-653 . --|   NONE.
 3-654 . --|
 3-655 . ----------------------------------------------------------------------------
 3-656 . */
 3-657 . static void msaw.3.3(void)
 3-658 . {
 3-659 . A = B*C;
 3-660 . A = B-C;
 3-661 . A = B*C;
 3-662 . A = B*C;
 3-663 . 
 3-664 . if (A lt B)
 3-665 . {
 3-666 .    A = B + C;
 3-667 .    D = E + F;
 3-668 . }
 3-669 . 
 3-670 . A = B/C;
 3-671 . A = B+C;
 3-672 . 
 3-673 . if (A gt B)
 3-674 . {
 3-675 .    A = B + C;
 3-676 .    D = E + F;
 3-677 . }
 3-678 . 
 3-679 . 
 3-680 . if (A gt B)
 3-681 . {
 3-682 .    A = B + C;
 3-683 .    D = E + F;
 3-684 . }
 3-685 . 
 3-686 . 
 3-687 . if (A <  B)
 3-688 . {
 3-689 .    A = B + C;
 3-690 .    D = E + F;
 3-691 . }
 3-692 . 
 3-693 . A = B-C;
 3-694 . 
 3-695 . if (A ge B)
 3-696 . {
 3-697 .    A = B + C;
 3-698 .    D = E + F;
 3-699 . }
 3-700 . 
 3-701 . A = B*C;
 3-702 . A = B+C;
 3-703 . A = B-C;
 3-704 . A = B/C;
 3-705 . 
 3-706 . switch (msaw stuff)
 3-707 . {
 3-708 .    case one:
 3-709 .    {
 3-710 .       switch (nested)
 3-711 .       {
 3-712 .          case:
 3-713 .             X = Y + Z;
 3-714 .          case:
 3-715 .             X = Y + Z;
 3-716 .          default:
 3-717 .             SwError;
 3-718 .       } 
 3-719 .    }
 3-720 .    case two:
 3-721 .    {
 3-722 .       run_this;
 3-723 .       break;
 3-724 .    }
 3-725 .    default:
 3-726 .    {
 3-727 .       SwError;
 3-728 .    }
 3-729 . }
 3-730 . 
 3-731 . A = B-C;
 3-732 . A = B+C;
 3-733 . A = B+C;
 3-734 . A = B-C;
 3-735 . A = B*C;
 3-736 . 
 3-737 . if (A lt B)
 3-738 . {
 3-739 .    A = B + C;
 3-740 .    D = E + F;
 3-741 . }
 3-742 . 
 3-743 . A = B/C;
 3-744 . A = B*C;
 3-745 . A = B/C;
 3-746 . A = B/C;
 3-747 . A = B+C;
 3-748 . A = B/C;
 3-749 . A = B+C;
 3-750 . A = B+C;
 3-751 . A = B+C;
 3-752 . 
 3-753 . if (A == B)
 3-754 . {
 3-755 .    A = B + C;
 3-756 .    D = E + F;
 3-757 . }
 3-758 . 
 3-759 . A = B+C;
 3-760 . 
 3-761 . if (A < = B)
 3-762 . {
 3-763 .    A = B + C;
 3-764 .    D = E + F;
 3-765 . }
 3-766 . 
 3-767 . A = B-C;
 3-768 . A = B/C;
 3-769 . 
 3-770 . if (A ge B)
 3-771 . {
 3-772 .    A = B + C;
 3-773 .    D = E + F;
 3-774 . }
 3-775 . 
 3-776 . /* LE SV TOC-2216 this is a msaw-03.3.38 req to call admin*/
 3-777 . A = B-C;
 3-778 . 
 3-779 . if (A == B)
 3-780 . {
 3-781 .    A = B + C;
 3-782 .    D = E + F;
 3-783 . }
 3-784 . 
 3-785 . 
 3-786 . if (A >  B)
 3-787 . {
 3-788 .    A = B + C;
 3-789 .    D = E + F;
 3-790 . }
 3-791 . 
 3-792 . A = B-C;
 3-793 . A = B+C;
 3-794 . 
 3-795 . if (A < = B)
 3-796 . {
 3-797 .    A = B + C;
 3-798 .    D = E + F;
 3-799 . }
 3-800 . 
 3-801 . A = 0x0001;
 3-802 . 
 3-803 . switch (msaw stuff)
 3-804 . {
 3-805 .    case one:
 3-806 .    {
 3-807 .       run_this; 
 3-808 .       break;
 3-809 .    }
 3-810 .    case two:
 3-811 .    {
 3-812 .       run_this;
 3-813 .       break;
 3-814 .    }
 3-815 .    default:
 3-816 .    {
 3-817 .        SwError;
 3-818 .    }
 3-819 . }
 3-820 . 
 3-821 . A = B/C;
 3-822 . 
 3-823 . if (A == B)
 3-824 . {
 3-825 .    A = B + C;
 3-826 .    D = E + F;
 3-827 . }
 3-828 . 
 3-829 . A = B/C;
 3-830 . 
 3-831 . if (A lt B)
 3-832 . {
 3-833 .    A = B + C;
 3-834 .    D = E + F;
 3-835 . }
 3-836 . 
 3-837 . A = B*C;
 3-838 . A = B/C;
 3-839 . A = B+C;
 3-840 . 
 3-841 . switch (msaw stuff)
 3-842 . {
 3-843 .    case one:
 3-844 .    {
 3-845 .       run_this;
 3-846 .       break;
 3-847 .    }
 3-848 .    case two:
 3-849 .    {
 3-850 .       run_this;
 3-851 .       break;
 3-852 .    }
 3-853 .    // missing default
 3-854 . }
 3-855 . 
 3-856 . 
 3-857 . if (A == B)
 3-858 . {
 3-859 .    A = B + C;
 3-860 .    D = E + F;
 3-861 . }
 3-862 . 
 3-863 . A = B*C;
 3-864 . A = B+C;
 3-865 . 
 3-866 . if (A <  B)
 3-867 . {
 3-868 .    A = B + C;
 3-869 .    D = E + F;
 3-870 . }
 3-871 . 
 3-872 . A = B*C;
 3-873 . A = B*C;
 3-874 . 
 3-875 . if (A ne B)
 3-876 . {
 3-877 .    A = B + C;
 3-878 .    D = E + F;
 3-879 . }
 3-880 . 
 3-881 . 
 3-882 . if (A gt B)
 3-883 . {
 3-884 .    A = B + C;
 3-885 .    D = E + F;
 3-886 . }
 3-887 . 
 3-888 . A = B-C;
 3-889 . A = B+C;
 3-890 . A = B/C;
 3-891 . // max LOC 62
 3-892 . 
 3-893 . }
 3-894 . 
 3-895 . 
 3-896 . /*
 3-897 . -----------------------------------------------------------------------------
 3-898 . --| NAME:   msaw.3.4
 3-899 . --|
 3-900 . --| ABSTRACT:
 3-901 . --|   This function does msaw stuff.
 3-902 . --|
 3-903 . --| RETURNS:
 3-904 . --|   NONE.
 3-905 . --|
 3-906 . ----------------------------------------------------------------------------
 3-907 . */
 3-908 . static void msaw.3.4(void)
 3-909 . {
 3-910 . A = B/C;
 3-911 . 
 3-912 . if (A lt B)
 3-913 . {
 3-914 .    A = B + C;
 3-915 .    D = E + F;
 3-916 . }
 3-917 . 
 3-918 . A = B-C;
 3-919 . A = B/C;
 3-920 . /* LE SV TOC-2217 this is a msaw-03.4.5 req to update*/
 3-921 . A = B*C;
 3-922 . A = B*C;
 3-923 . A = B/C;
 3-924 . A = B/C;
 3-925 . 
 3-926 . if (A != B)
 3-927 . {
 3-928 .    A = B + C;
 3-929 .    D = E + F;
 3-930 . }
 3-931 . 
 3-932 . A = B/C;
 3-933 . A = B+C;
 3-934 . A = B/C;
 3-935 . A = B+C;
 3-936 . A = B-C;
 3-937 . A = B-C;
 3-938 . 
 3-939 . if (A >  B)
 3-940 . {
 3-941 .    A = B + C;
 3-942 .    D = E + F;
 3-943 . }
 3-944 . 
 3-945 . A = B-C;
 3-946 . A = B/C;
 3-947 . A = B+C;
 3-948 . A = B*C;
 3-949 . A = B+C;
 3-950 . A = B+C;
 3-951 . A = B/C;
 3-952 . A = B/C;
 3-953 . 
 3-954 . if (A lt B)
 3-955 . {
 3-956 .    A = B + C;
 3-957 .    D = E + F;
 3-958 . }
 3-959 . 
 3-960 . A = B*C;
 3-961 . A = B+C;
 3-962 . 
 3-963 . if (A == B)
 3-964 . {
 3-965 .    A = B + C;
 3-966 .    D = E + F;
 3-967 . }
 3-968 . 
 3-969 . 
 3-970 . if (A < = B)
 3-971 . {
 3-972 .    A = B + C;
 3-973 .    D = E + F;
 3-974 . }
 3-975 . 
 3-976 . A = B-C;
 3-977 . A = B+C;
 3-978 . A = B-C;
 3-979 . A = B*C;
 3-980 . A = B-C;
 3-981 . A = B/C;
 3-982 . /* LE SV TOC-2218 this is a msaw-03.4.36 req to set RTC*/
 3-983 . A = B-C;
 3-984 . A = 0x0002;
 3-985 . 
 3-986 . if (A eq B)
 3-987 . {
 3-988 .    A = B + C;
 3-989 .    D = E + F;
 3-990 . }
 3-991 . 
 3-992 . A = B+C;
 3-993 . 
 3-994 . if (A ge B)
 3-995 . {
 3-996 .    A = B + C;
 3-997 .    D = E + F;
 3-998 . }
 3-999 . 
 3-1000 . A = B/C;
 3-1001 . A = B/C;
 3-1002 . A = B/C;
 3-1003 . 
 3-1004 . if (A eq B)
 3-1005 . {
 3-1006 .    A = B + C;
 3-1007 .    D = E + F;
 3-1008 . }
 3-1009 . 
 3-1010 . 
 3-1011 . if (A le B)
 3-1012 . {
 3-1013 .    A = B + C;
 3-1014 .    D = E + F;
 3-1015 . }
 3-1016 . 
 3-1017 . // max LOC 44
 3-1018 . 
 3-1019 . }
 3-1020 . 
 3-1021 . 
 3-1022 . /*
 3-1023 . -----------------------------------------------------------------------------
 3-1024 . --| NAME:   msaw.3.5
 3-1025 . --|
 3-1026 . --| ABSTRACT:
 3-1027 . --|   This function does msaw stuff.
 3-1028 . --|
 3-1029 . --| RETURNS:
 3-1030 . --|   NONE.
 3-1031 . --|
 3-1032 . ----------------------------------------------------------------------------
 3-1033 . */
 3-1034 . static void msaw.3.5(void)
 3-1035 . {
 3-1036 . A = B*C;
 3-1037 . A = B-C;
 3-1038 . A = B-C;
 3-1039 . /* LE SV TOC-2219 this is a msaw-03.5.4 req to store*/
 3-1040 . A = B/C;
 3-1041 . A = B*C;
 3-1042 . 
 3-1043 . if (A < = B)
 3-1044 . {
 3-1045 .    A = B + C;
 3-1046 .    D = E + F;
 3-1047 . }
 3-1048 . 
 3-1049 . A = B+C;
 3-1050 . 
 3-1051 . if (A eq B)
 3-1052 . {
 3-1053 .    A = B + C;
 3-1054 .    D = E + F;
 3-1055 . }
 3-1056 . 
 3-1057 . A = B*C;
 3-1058 . A = B/C;
 3-1059 . 
 3-1060 . if (A >  B)
 3-1061 . {
 3-1062 .    A = B + C;
 3-1063 .    D = E + F;
 3-1064 . }
 3-1065 . 
 3-1066 . 
 3-1067 . if (A lt B)
 3-1068 . {
 3-1069 .    A = B + C;
 3-1070 .    D = E + F;
 3-1071 . }
 3-1072 . 
 3-1073 . A = B+C;
 3-1074 . 
 3-1075 . if (A >  B)
 3-1076 . {
 3-1077 .    A = B + C;
 3-1078 .    D = E + F;
 3-1079 . }
 3-1080 . 
 3-1081 . A = B-C;
 3-1082 . 
 3-1083 . if (A <  B)
 3-1084 . {
 3-1085 .    A = B + C;
 3-1086 .    D = E + F;
 3-1087 . }
 3-1088 . 
 3-1089 . A = B+C;
 3-1090 . A = B-C;
 3-1091 . A = B-C;
 3-1092 . A = B-C;
 3-1093 . A = B-C;
 3-1094 . A = B-C;
 3-1095 . A = B*C;
 3-1096 . A = B+C;
 3-1097 . A = B+C;
 3-1098 . 
 3-1099 . if (A gt B)
 3-1100 . {
 3-1101 .    A = B + C;
 3-1102 .    D = E + F;
 3-1103 . }
 3-1104 . 
 3-1105 . A = B/C;
 3-1106 . A = B*C;
 3-1107 . A = B-C;
 3-1108 . A = B/C;
 3-1109 . // max LOC 30
 3-1110 . 
 3-1111 . }
 3-1112 . 
 3-1113 . 
 3-1114 . /*
 3-1115 . -----------------------------------------------------------------------------
 3-1116 . --| NAME:   msaw.3.6
 3-1117 . --|
 3-1118 . --| ABSTRACT:
 3-1119 . --|   This function does msaw stuff.
 3-1120 . --|
 3-1121 . --| RETURNS:
 3-1122 . --|   NONE.
 3-1123 . --|
 3-1124 . ----------------------------------------------------------------------------
 3-1125 . */
 3-1126 . static void msaw.3.6(void)
 3-1127 . {
 3-1128 . A = B/C;
 3-1129 . A = 0x0007;
 3-1130 . A = B+C;
 3-1131 . 
 3-1132 . if (A <  B)
 3-1133 . {
 3-1134 .    A = B + C;
 3-1135 .    D = E + F;
 3-1136 . }
 3-1137 . 
 3-1138 . 
 3-1139 . /*
 3-1140 . dead_block = C * D; 
 3-1141 . dead_block = E * F;
 3-1142 . */
 3-1143 . 
 3-1144 . 
 3-1145 . if (A != B)
 3-1146 . {
 3-1147 .    A = B + C;
 3-1148 .    D = E + F;
 3-1149 . }
 3-1150 . 
 3-1151 . A = B+C;
 3-1152 . A = B*C;
 3-1153 . A = 0x0006;
 3-1154 . A = B-C;
 3-1155 . 
 3-1156 . if (A le B)
 3-1157 . {
 3-1158 .    A = B + C;
 3-1159 .    D = E + F;
 3-1160 . }
 3-1161 . 
 3-1162 . 
 3-1163 . if (veg)
 3-1164 .    // missing curly brace
 3-1165 .    variable = orange;
 3-1166 . 
 3-1167 . A = B/C;
 3-1168 . 
 3-1169 . switch (msaw stuff)
 3-1170 . {
 3-1171 .    case:
 3-1172 .    case:
 3-1173 .    // stacked case statements but only if there is a new line in between
 3-1174 . 
 3-1175 .    case:
 3-1176 .    case:
 3-1177 .    case:
 3-1178 .    {
 3-1179 .       run_this;
 3-1180 .       break;
 3-1181 .    }
 3-1182 .    default:
 3-1183 .    {
 3-1184 .       halt;
 3-1185 .    }
 3-1186 . }
 3-1187 . 
 3-1188 . A = B/C;
 3-1189 . A = 0x0002;
 3-1190 . 
 3-1191 . if (A <  B)
 3-1192 . {
 3-1193 .    A = B + C;
 3-1194 .    D = E + F;
 3-1195 . }
 3-1196 . 
 3-1197 . A = B-C;
 3-1198 . A = B/C;
 3-1199 . 
 3-1200 . if (A ne B)
 3-1201 . {
 3-1202 .    A = B + C;
 3-1203 .    D = E + F;
 3-1204 . }
 3-1205 . 
 3-1206 . A = B-C;
 3-1207 . A = B/C;
 3-1208 . 
 3-1209 . if (A != B)
 3-1210 . {
 3-1211 .    A = B + C;
 3-1212 .    D = E + F;
 3-1213 . }
 3-1214 . 
 3-1215 . A = B-C;
 3-1216 . 
 3-1217 . if (A != B)
 3-1218 . {
 3-1219 .    A = B + C;
 3-1220 .    D = E + F;
 3-1221 . }
 3-1222 . 
 3-1223 . A = B/C;
 3-1224 . A = B+C;
 3-1225 . 
 3-1226 . if (A lt B)
 3-1227 . {
 3-1228 .    A = B + C;
 3-1229 .    D = E + F;
 3-1230 . }
 3-1231 . 
 3-1232 . A = B-C;
 3-1233 . A = B/C;
 3-1234 . A = B/C;
 3-1235 . 
 3-1236 . if (A eq B)
 3-1237 . {
 3-1238 .    A = B + C;
 3-1239 .    D = E + F;
 3-1240 . }
 3-1241 . 
 3-1242 . A = B-C;
 3-1243 . A = B+C;
 3-1244 . A = B-C;
 3-1245 . A = B*C;
 3-1246 . A = B/C;
 3-1247 . 
 3-1248 . if (A gt B)
 3-1249 . {
 3-1250 .    A = B + C;
 3-1251 .    D = E + F;
 3-1252 . }
 3-1253 . 
 3-1254 . 
 3-1255 . if (A < = B)
 3-1256 . {
 3-1257 .    A = B + C;
 3-1258 .    D = E + F;
 3-1259 . }
 3-1260 . 
 3-1261 . A = B*C;
 3-1262 . A = B*C;
 3-1263 . A = B+C;
 3-1264 . A = B+C;
 3-1265 . A = B*C;
 3-1266 . 
 3-1267 . if (A == B)
 3-1268 . {
 3-1269 .    A = B + C;
 3-1270 .    D = E + F;
 3-1271 . }
 3-1272 . 
 3-1273 . 
 3-1274 . if (A ne B)
 3-1275 . {
 3-1276 .    A = B + C;
 3-1277 .    D = E + F;
 3-1278 . }
 3-1279 . 
 3-1280 . A = B*C;
 3-1281 . A = B/C;
 3-1282 . A = B+C;
 3-1283 . 
 3-1284 . if ($msaw stuff >  $othermsaw stuff) 
 3-1285 . /* LE SV TOC-008 we really should log all error calls */
 3-1286 . {
 3-1287 .    A = B + C;
 3-1288 . }
 3-1289 . 
 3-1290 . 
 3-1291 . if (A >  B)
 3-1292 . {
 3-1293 .    A = B + C;
 3-1294 .    D = E + F;
 3-1295 . }
 3-1296 . 
 3-1297 . A = B-C;
 3-1298 . A = B+C;
 3-1299 . A = B/C;
 3-1300 . /* LE SV TOC-2220 this is a msaw-03.6.48 req to assign*/
 3-1301 . A = B+C;
 3-1302 . A = B-C;
 3-1303 . 
 3-1304 . switch (msaw stuff)
 3-1305 . {
 3-1306 .    case one:
 3-1307 .    {
 3-1308 .       run_this; 
 3-1309 .       break;
 3-1310 .    }
 3-1311 .    case two:
 3-1312 .    {
 3-1313 .       run_this;
 3-1314 .       break;
 3-1315 .    }
 3-1316 .    default:
 3-1317 .    {
 3-1318 .        SwError;
 3-1319 .    }
 3-1320 . }
 3-1321 . 
 3-1322 . /* LE SV TOC-2221 this is a msaw-03.6.51 req to detect error*/
 3-1323 . 
 3-1324 . if (A > = B)
 3-1325 . {
 3-1326 .    A = B + C;
 3-1327 .    D = E + F;
 3-1328 . }
 3-1329 . 
 3-1330 . /* LE SV TOC-2222 this is a msaw-03.6.52 req to call admin*/
 3-1331 . A = B*C;
 3-1332 . A = B-C;
 3-1333 . A = B-C;
 3-1334 . A = B+C;
 3-1335 . 
 3-1336 . switch (msaw stuff)
 3-1337 . {
 3-1338 .    case one:
 3-1339 .    {
 3-1340 .       run_this; 
 3-1341 .       break;
 3-1342 .    }
 3-1343 .    case two:
 3-1344 .    {
 3-1345 .       run_this;
 3-1346 .       break;
 3-1347 .    }
 3-1348 .    default:
 3-1349 .    {
 3-1350 .        SwError;
 3-1351 .    }
 3-1352 . }
 3-1353 . 
 3-1354 . A = B*C;
 3-1355 . // max LOC 57
 3-1356 . 
 3-1357 . }
 3-1358 . 
 3-1359 . 
 3-1360 . /*
 3-1361 . -----------------------------------------------------------------------------
 3-1362 . --| NAME:   msaw.3.7
 3-1363 . --|
 3-1364 . --| ABSTRACT:
 3-1365 . --|   This function does msaw stuff.
 3-1366 . --|
 3-1367 . --| RETURNS:
 3-1368 . --|   NONE.
 3-1369 . --|
 3-1370 . ----------------------------------------------------------------------------
 3-1371 . */
 3-1372 . static void msaw.3.7(void)
 3-1373 . {
 3-1374 . A = B+C;
 3-1375 . A = B-C;
 3-1376 . 
 3-1377 . if (A ne B)
 3-1378 . {
 3-1379 .    A = B + C;
 3-1380 .    D = E + F;
 3-1381 . }
 3-1382 . 
 3-1383 . A = B+C;
 3-1384 . A = 0x0008;
 3-1385 . A = B/C;
 3-1386 . A = B-C;
 3-1387 . 
 3-1388 . if (veg)
 3-1389 .    // missing curly brace
 3-1390 .    variable = orange;
 3-1391 . 
 3-1392 . 
 3-1393 . if (A ge B)
 3-1394 . {
 3-1395 .    A = B + C;
 3-1396 .    D = E + F;
 3-1397 . }
 3-1398 . 
 3-1399 . A = B/C;
 3-1400 . /* LE SV TOC-2223 this is a msaw-03.7.9 req to audit*/
 3-1401 . A = B-C;
 3-1402 . A = B+C;
 3-1403 . A = B*C;
 3-1404 . A = B+C;
 3-1405 . A = B+C;
 3-1406 . A = B*C;
 3-1407 . /* LE SV TOC-2224 this is a msaw-03.7.15 req to reject*/
 3-1408 . A = B/C;
 3-1409 . A = B*C;
 3-1410 . A = B-C;
 3-1411 . 
 3-1412 . if (A eq B)
 3-1413 . {
 3-1414 .    A = B + C;
 3-1415 .    D = E + F;
 3-1416 . }
 3-1417 . 
 3-1418 . A = B*C;
 3-1419 . 
 3-1420 . if (A ne B)
 3-1421 . {
 3-1422 .    A = B + C;
 3-1423 .    D = E + F;
 3-1424 . }
 3-1425 . 
 3-1426 . A = B/C;
 3-1427 . 
 3-1428 . switch (msaw stuff)
 3-1429 . {
 3-1430 .    case one:
 3-1431 .    {
 3-1432 .       run_this; 
 3-1433 .       break;
 3-1434 .    }
 3-1435 .    case two:
 3-1436 .    {
 3-1437 .       run_this;
 3-1438 .       break;
 3-1439 .    }
 3-1440 .    default:
 3-1441 .    {
 3-1442 .        SwError;
 3-1443 .    }
 3-1444 . }
 3-1445 . 
 3-1446 . A = B/C;
 3-1447 . A = B+C;
 3-1448 . 
 3-1449 . if (A gt B)
 3-1450 . {
 3-1451 .    A = B + C;
 3-1452 .    D = E + F;
 3-1453 . }
 3-1454 . 
 3-1455 . 
 3-1456 . switch (msaw stuff)
 3-1457 . {
 3-1458 .    case one:
 3-1459 .    {
 3-1460 .       run_this; 
 3-1461 .       break;
 3-1462 .    }
 3-1463 .    case two:
 3-1464 .    {
 3-1465 .       run_this;
 3-1466 .       break;
 3-1467 .    }
 3-1468 .    default:
 3-1469 .    {
 3-1470 .        SwError;
 3-1471 .    }
 3-1472 . }
 3-1473 . 
 3-1474 . A = B+C;
 3-1475 . A = B*C;
 3-1476 . 
 3-1477 . if (A > = B)
 3-1478 . {
 3-1479 .    A = B + C;
 3-1480 .    D = E + F;
 3-1481 . }
 3-1482 . 
 3-1483 . A = B+C;
 3-1484 . 
 3-1485 . if (A eq B)
 3-1486 . {
 3-1487 .    A = B + C;
 3-1488 .    D = E + F;
 3-1489 . }
 3-1490 . 
 3-1491 . A = B/C;
 3-1492 . A = B/C;
 3-1493 . 
 3-1494 . if (A ne B)
 3-1495 . {
 3-1496 .    A = B + C;
 3-1497 .    D = E + F;
 3-1498 . }
 3-1499 . 
 3-1500 . A = B*C;
 3-1501 . A = B-C;
 3-1502 . A = B*C;
 3-1503 . A = (int)B + C;
 3-1504 . 
 3-1505 . switch (msaw stuff)
 3-1506 . {
 3-1507 .    case one:
 3-1508 .    {
 3-1509 .       run_this; 
 3-1510 .       break;
 3-1511 .    }
 3-1512 .    case two:
 3-1513 .    {
 3-1514 .       run_this;
 3-1515 .       break;
 3-1516 .    }
 3-1517 .    default:
 3-1518 .    {
 3-1519 .        SwError;
 3-1520 .    }
 3-1521 . }
 3-1522 . 
 3-1523 . A = B+C;
 3-1524 . A = B/C;
 3-1525 . A = B/C;
 3-1526 . A = B-C;
 3-1527 . /* LE SV TOC-2225 this is a msaw-03.7.43 req to record*/
 3-1528 . A = B/C;
 3-1529 . A = B-C;
 3-1530 . A = B*C;
 3-1531 . A = B-C;
 3-1532 . 
 3-1533 . if (A == B)
 3-1534 . {
 3-1535 .    A = B + C;
 3-1536 .    D = E + F;
 3-1537 . }
 3-1538 . 
 3-1539 . 
 3-1540 . if (A > = B)
 3-1541 . {
 3-1542 .    A = B + C;
 3-1543 .    D = E + F;
 3-1544 . }
 3-1545 . 
 3-1546 . A = B/C;
 3-1547 . 
 3-1548 . switch (msaw stuff)
 3-1549 . {
 3-1550 .    case one:
 3-1551 .    {
 3-1552 .       run_this;
 3-1553 .       break;
 3-1554 .    }
 3-1555 .    case two:
 3-1556 .    {
 3-1557 .       run_this;
 3-1558 .       break;
 3-1559 .    }
 3-1560 .    // missing default
 3-1561 . }
 3-1562 . 
 3-1563 . 
 3-1564 . if (A ne B)
 3-1565 . {
 3-1566 .    A = B + C;
 3-1567 .    D = E + F;
 3-1568 . }
 3-1569 . 
 3-1570 . A = B+C;
 3-1571 . A = B/C;
 3-1572 . 
 3-1573 . if (A le B)
 3-1574 . {
 3-1575 .    A = B + C;
 3-1576 .    D = E + F;
 3-1577 . }
 3-1578 . 
 3-1579 . 
 3-1580 . if (A le B)
 3-1581 . {
 3-1582 .    A = B + C;
 3-1583 .    D = E + F;
 3-1584 . }
 3-1585 . 
 3-1586 . 
 3-1587 . if (A ge B)
 3-1588 . {
 3-1589 .    A = B + C;
 3-1590 .    D = E + F;
 3-1591 . }
 3-1592 . 
 3-1593 . 
 3-1594 . switch (msaw stuff)
 3-1595 . {
 3-1596 .    case one:
 3-1597 .    {
 3-1598 .       run_this; 
 3-1599 .       break;
 3-1600 .    }
 3-1601 .    case two:
 3-1602 .    {
 3-1603 .       run_this;
 3-1604 .       break;
 3-1605 .    }
 3-1606 .    default:
 3-1607 .    {
 3-1608 .        SwError;
 3-1609 .    }
 3-1610 . }
 3-1611 . 
 3-1612 . A = B-C;
 3-1613 . A = B-C;
 3-1614 . A = 0x0009;
 3-1615 . A = B*C;
 3-1616 . 
 3-1617 . if {
 3-1618 .    X = Y + Z;
 3-1619 . }
 3-1620 . else {
 3-1621 .    halt;
 3-1622 . }
 3-1623 . 
 3-1624 . A = B+C;
 3-1625 . 
 3-1626 . if (A gt B)
 3-1627 . {
 3-1628 .    A = B + C;
 3-1629 .    D = E + F;
 3-1630 . }
 3-1631 . 
 3-1632 . A = B*C;
 3-1633 . 
 3-1634 . if (A ne B)
 3-1635 . {
 3-1636 .    A = B + C;
 3-1637 .    D = E + F;
 3-1638 . }
 3-1639 . 
 3-1640 . 
 3-1641 . if (A ge B)
 3-1642 . {
 3-1643 .    A = B + C;
 3-1644 .    D = E + F;
 3-1645 . }
 3-1646 . 
 3-1647 . 
 3-1648 . if (A >  B)
 3-1649 . {
 3-1650 .    A = B + C;
 3-1651 .    D = E + F;
 3-1652 . }
 3-1653 . 
 3-1654 . /* LE SV TOC-2226 this is a msaw-03.7.66 req to translate*/
 3-1655 . 
 3-1656 . if (A le B)
 3-1657 . {
 3-1658 .    A = B + C;
 3-1659 .    D = E + F;
 3-1660 . }
 3-1661 . 
 3-1662 . A = B*C;
 3-1663 . 
 3-1664 . if (A eq B)
 3-1665 . {
 3-1666 .    A = B + C;
 3-1667 .    D = E + F;
 3-1668 . }
 3-1669 . 
 3-1670 . A = B+C;
 3-1671 . 
 3-1672 . if (A > = B)
 3-1673 . {
 3-1674 .    A = B + C;
 3-1675 .    D = E + F;
 3-1676 . }
 3-1677 . 
 3-1678 . A = B+C;
 3-1679 . 
 3-1680 . switch (msaw stuff)
 3-1681 . {
 3-1682 .    case one:
 3-1683 .    {
 3-1684 .       run_this; 
 3-1685 .       break;
 3-1686 .    }
 3-1687 .    case two:
 3-1688 .    {
 3-1689 .       run_this;
 3-1690 .       break;
 3-1691 .    }
 3-1692 .    default:
 3-1693 .    {
 3-1694 .        SwError;
 3-1695 .    }
 3-1696 . }
 3-1697 . 
 3-1698 . A = B-C;
 3-1699 . // max LOC 73
 3-1700 . 
 3-1701 . }
 3-1702 . 
 3-1703 . 
 3-1704 . /*
 3-1705 . -----------------------------------------------------------------------------
 3-1706 . --| NAME:   msaw.3.8
 3-1707 . --|
 3-1708 . --| ABSTRACT:
 3-1709 . --|   This function does msaw stuff.
 3-1710 . --|
 3-1711 . --| RETURNS:
 3-1712 . --|   NONE.
 3-1713 . --|
 3-1714 . ----------------------------------------------------------------------------
 3-1715 . */
 3-1716 . static void msaw.3.8(void)
 3-1717 . {
 3-1718 . A = B*C;
 3-1719 . A = B*C;
 3-1720 . 
 3-1721 . if (A >  B)
 3-1722 . {
 3-1723 .    A = B + C;
 3-1724 .    D = E + F;
 3-1725 . }
 3-1726 . 
 3-1727 . 
 3-1728 . if (A != B)
 3-1729 . {
 3-1730 .    A = B + C;
 3-1731 .    D = E + F;
 3-1732 . }
 3-1733 . 
 3-1734 . /* LE SV TOC-2227 this is a msaw-03.8.5 req to reject*/
 3-1735 . A = B+C;
 3-1736 . A = B/C;
 3-1737 . A = B*C;
 3-1738 . A = B+C;
 3-1739 . 
 3-1740 . if (A le B)
 3-1741 . {
 3-1742 .    A = B + C;
 3-1743 .    D = E + F;
 3-1744 . }
 3-1745 . 
 3-1746 . A = B/C;
 3-1747 . A = B-C;
 3-1748 . 
 3-1749 . if (A gt B)
 3-1750 . {
 3-1751 .    A = B + C;
 3-1752 .    D = E + F;
 3-1753 . }
 3-1754 . 
 3-1755 . A = B/C;
 3-1756 . A = B/C;
 3-1757 . A = B/C;
 3-1758 . A = B/C;
 3-1759 . 
 3-1760 . switch (msaw stuff)
 3-1761 . {
 3-1762 .    case one:
 3-1763 .    {
 3-1764 .       run_this; 
 3-1765 .       break;
 3-1766 .    }
 3-1767 .    case two:
 3-1768 .    {
 3-1769 .       run_this;
 3-1770 .       break;
 3-1771 .    }
 3-1772 .    default:
 3-1773 .    {
 3-1774 .        SwError;
 3-1775 .    }
 3-1776 . }
 3-1777 . 
 3-1778 . A = B-C;
 3-1779 . A = 0x0004;
 3-1780 . 
 3-1781 . switch (msaw stuff)
 3-1782 . {
 3-1783 .    case one:
 3-1784 .    {
 3-1785 .       run_this; 
 3-1786 .       break;
 3-1787 .    }
 3-1788 .    case two:
 3-1789 .    {
 3-1790 .       run_this;
 3-1791 .       break;
 3-1792 .    }
 3-1793 .    default:
 3-1794 .    {
 3-1795 .        SwError;
 3-1796 .    }
 3-1797 . }
 3-1798 . 
 3-1799 . 
 3-1800 . if (A ne B)
 3-1801 . {
 3-1802 .    A = B + C;
 3-1803 .    D = E + F;
 3-1804 . }
 3-1805 . 
 3-1806 . A = B-C;
 3-1807 . A = B-C;
 3-1808 . A = B+C;
 3-1809 . /* LE SV TOC-2228 this is a msaw-03.8.24 req to halt*/
 3-1810 . 
 3-1811 . if (A >  B)
 3-1812 . {
 3-1813 .    A = B + C;
 3-1814 .    D = E + F;
 3-1815 . }
 3-1816 . 
 3-1817 . 
 3-1818 . if (A < = B)
 3-1819 . {
 3-1820 .    A = B + C;
 3-1821 .    D = E + F;
 3-1822 . }
 3-1823 . 
 3-1824 . 
 3-1825 . if (A eq B)
 3-1826 . {
 3-1827 .    A = B + C;
 3-1828 .    D = E + F;
 3-1829 . }
 3-1830 . 
 3-1831 . 
 3-1832 . if (A ge B)
 3-1833 . {
 3-1834 .    A = B + C;
 3-1835 .    D = E + F;
 3-1836 . }
 3-1837 . 
 3-1838 . /* LE SV TOC-2229 this is a msaw-03.8.28 req to assign*/
 3-1839 . A = B*C;
 3-1840 . A = B*C;
 3-1841 . A = B/C;
 3-1842 . // max LOC 30
 3-1843 . 
 3-1844 . }
 3-1845 . 
 3-1846 . 
 3-1847 . /*
 3-1848 . -----------------------------------------------------------------------------
 3-1849 . --| NAME:   msaw.3.9
 3-1850 . --|
 3-1851 . --| ABSTRACT:
 3-1852 . --|   This function does msaw stuff.
 3-1853 . --|
 3-1854 . --| RETURNS:
 3-1855 . --|   NONE.
 3-1856 . --|
 3-1857 . ----------------------------------------------------------------------------
 3-1858 . */
 3-1859 . static void msaw.3.9(void)
 3-1860 . {
 3-1861 . A = B/C;
 3-1862 . A = B-C;
 3-1863 . A = B+C;
 3-1864 . 
 3-1865 . if (A le B)
 3-1866 . {
 3-1867 .    A = B + C;
 3-1868 .    D = E + F;
 3-1869 . }
 3-1870 . 
 3-1871 . A = B+C;
 3-1872 . A = B+C;
 3-1873 . A = B-C;
 3-1874 . A = B-C;
 3-1875 . A = B-C;
 3-1876 . A = B+C;
 3-1877 . 
 3-1878 . if (A eq B)
 3-1879 . {
 3-1880 .    A = B + C;
 3-1881 .    D = E + F;
 3-1882 . }
 3-1883 . 
 3-1884 . A = B-C;
 3-1885 . A = B*C;
 3-1886 . 
 3-1887 . switch (msaw stuff)
 3-1888 . {
 3-1889 .    case one:
 3-1890 .    {
 3-1891 .       run_this; 
 3-1892 .       break;
 3-1893 .    }
 3-1894 .    case two:
 3-1895 .    {
 3-1896 .       run_this;
 3-1897 .       break;
 3-1898 .    }
 3-1899 .    default:
 3-1900 .    {
 3-1901 .        SwError;
 3-1902 .    }
 3-1903 . }
 3-1904 . 
 3-1905 . A = B*C;
 3-1906 . // max LOC 15
 3-1907 . 
 3-1908 . }
 3-1909 . 
 3-1910 . 
 3-1911 . /*
 3-1912 . -----------------------------------------------------------------------------
 3-1913 . --| NAME:   msaw.3.10
 3-1914 . --|
 3-1915 . --| ABSTRACT:
 3-1916 . --|   This function does msaw stuff.
 3-1917 . --|
 3-1918 . --| RETURNS:
 3-1919 . --|   NONE.
 3-1920 . --|
 3-1921 . ----------------------------------------------------------------------------
 3-1922 . */
 3-1923 . static void msaw.3.10(void)
 3-1924 . {
 3-1925 . A = B+C;
 3-1926 . A = B+C;
 3-1927 . A = B-C;
 3-1928 . A = B/C;
 3-1929 . 
 3-1930 . if (A le B)
 3-1931 . {
 3-1932 .    A = B + C;
 3-1933 .    D = E + F;
 3-1934 . }
 3-1935 . 
 3-1936 . 
 3-1937 . if (A ge B)
 3-1938 . {
 3-1939 .    A = B + C;
 3-1940 .    D = E + F;
 3-1941 . }
 3-1942 . 
 3-1943 . A = B*C;
 3-1944 . A = B*C;
 3-1945 . 
 3-1946 . if (A == B)
 3-1947 . {
 3-1948 .    A = B + C;
 3-1949 .    D = E + F;
 3-1950 . }
 3-1951 . 
 3-1952 . A = B/C;
 3-1953 . /* LE SV TOC-2230 this is a msaw-03.10.11 req to validate*/
 3-1954 . A = B*C;
 3-1955 . A = B-C;
 3-1956 . 
 3-1957 . if (A ge B)
 3-1958 . {
 3-1959 .    A = B + C;
 3-1960 .    D = E + F;
 3-1961 . }
 3-1962 . 
 3-1963 . A = B-C;
 3-1964 . A = B+C;
 3-1965 . A = B-C;
 3-1966 . A = B*C;
 3-1967 . 
 3-1968 . if (A < = B)
 3-1969 . {
 3-1970 .    A = B + C;
 3-1971 .    D = E + F;
 3-1972 . }
 3-1973 . 
 3-1974 . A = B/C;
 3-1975 . 
 3-1976 . if (A ge B)
 3-1977 . {
 3-1978 .    A = B + C;
 3-1979 .    D = E + F;
 3-1980 . }
 3-1981 . 
 3-1982 . A = B*C;
 3-1983 . A = B/C;
 3-1984 . A = B*C;
 3-1985 . A = B/C;
 3-1986 . A = B/C;
 3-1987 . 
 3-1988 . if (A ge B)
 3-1989 . {
 3-1990 .    A = B + C;
 3-1991 .    D = E + F;
 3-1992 . }
 3-1993 . 
 3-1994 . A = B/C;
 3-1995 . 
 3-1996 . /*
 3-1997 . dead_block = C * D; 
 3-1998 . dead_block = E * F;
 3-1999 . */
 3-2000 . 
 3-2001 . A = B*C;
 3-2002 . A = B*C;
 3-2003 . 
 3-2004 . if (A > = B)
 3-2005 . {
 3-2006 .    A = B + C;
 3-2007 .    D = E + F;
 3-2008 . }
 3-2009 . 
 3-2010 . 
 3-2011 . if (veg)
 3-2012 .    // missing curly brace
 3-2013 .    variable = orange;
 3-2014 . 
 3-2015 . A = B-C;
 3-2016 . A = B+C;
 3-2017 . A = B/C;
 3-2018 . 
 3-2019 . if (A ne B)
 3-2020 . {
 3-2021 .    A = B + C;
 3-2022 .    D = E + F;
 3-2023 . }
 3-2024 . 
 3-2025 . A = B*C;
 3-2026 . // max LOC 35
 3-2027 . 
 3-2028 . }
 3-2029 . 
 3-2030 . 
 3-2031 . /*
 3-2032 . -----------------------------------------------------------------------------
 3-2033 . --| NAME:   msaw.3.11
 3-2034 . --|
 3-2035 . --| ABSTRACT:
 3-2036 . --|   This function does msaw stuff.
 3-2037 . --|
 3-2038 . --| RETURNS:
 3-2039 . --|   NONE.
 3-2040 . --|
 3-2041 . ----------------------------------------------------------------------------
 3-2042 . */
 3-2043 . static void msaw.3.11(void)
 3-2044 . {
 3-2045 . 
 3-2046 . if (A le B)
 3-2047 . {
 3-2048 .    A = B + C;
 3-2049 .    D = E + F;
 3-2050 . }
 3-2051 . 
 3-2052 . 
 3-2053 . switch (msaw stuff)
 3-2054 . {
 3-2055 .    case one:
 3-2056 .    {
 3-2057 .       run_this; 
 3-2058 .       break;
 3-2059 .    }
 3-2060 .    case two:
 3-2061 .    {
 3-2062 .       run_this;
 3-2063 .       break;
 3-2064 .    }
 3-2065 .    default:
 3-2066 .    {
 3-2067 .        SwError;
 3-2068 .    }
 3-2069 . }
 3-2070 . 
 3-2071 . A = B+C;
 3-2072 . 
 3-2073 . if (A le B)
 3-2074 . {
 3-2075 .    A = B + C;
 3-2076 .    D = E + F;
 3-2077 . }
 3-2078 . 
 3-2079 . A = B*C;
 3-2080 . A = B+C;
 3-2081 . A = B/C;
 3-2082 . 
 3-2083 . if (A <  B)
 3-2084 . {
 3-2085 .    A = B + C;
 3-2086 .    D = E + F;
 3-2087 . }
 3-2088 . 
 3-2089 . A = B*C;
 3-2090 . A = B-C;
 3-2091 . 
 3-2092 . if (A ne B)
 3-2093 . {
 3-2094 .    A = B + C;
 3-2095 .    D = E + F;
 3-2096 . }
 3-2097 . 
 3-2098 . A = B*C;
 3-2099 . 
 3-2100 . if (A > = B)
 3-2101 . {
 3-2102 .    A = B + C;
 3-2103 .    D = E + F;
 3-2104 . }
 3-2105 . 
 3-2106 . 
 3-2107 . if (A gt B)
 3-2108 . {
 3-2109 .    A = B + C;
 3-2110 .    D = E + F;
 3-2111 . }
 3-2112 . 
 3-2113 . A = B/C;
 3-2114 . A = B*C;
 3-2115 . 
 3-2116 . if (A != B)
 3-2117 . {
 3-2118 .    A = B + C;
 3-2119 .    D = E + F;
 3-2120 . }
 3-2121 . 
 3-2122 . 
 3-2123 . if (A == B)
 3-2124 . {
 3-2125 .    A = B + C;
 3-2126 .    D = E + F;
 3-2127 . }
 3-2128 . 
 3-2129 . A = B-C;
 3-2130 . A = B/C;
 3-2131 . FreePtr = HmiStringPtr;
 3-2132 . A = B*C;
 3-2133 . A = B+C;
 3-2134 . 
 3-2135 . if (A <  B)
 3-2136 . {
 3-2137 .    A = B + C;
 3-2138 .    D = E + F;
 3-2139 . }
 3-2140 . 
 3-2141 . A = B-C;
 3-2142 . A = B/C;
 3-2143 . A = B/C;
 3-2144 . /* LE SV TOC-2231 this is a msaw-03.11.27 req to check unix*/
 3-2145 . 
 3-2146 . if (A == B)
 3-2147 . {
 3-2148 .    A = B + C;
 3-2149 .    D = E + F;
 3-2150 . }
 3-2151 . 
 3-2152 . /* LE SV TOC-2232 this is a msaw-03.11.28 req to increment*/
 3-2153 . 
 3-2154 . if (A < = B)
 3-2155 . {
 3-2156 .    A = B + C;
 3-2157 .    D = E + F;
 3-2158 . }
 3-2159 . 
 3-2160 . A = B-C;
 3-2161 . A = B*C;
 3-2162 . A = B-C;
 3-2163 . A = B*C;
 3-2164 . A = B*C;
 3-2165 . A = B/C;
 3-2166 . A = B*C;
 3-2167 . 
 3-2168 . if (A le B)
 3-2169 . {
 3-2170 .    A = B + C;
 3-2171 .    D = E + F;
 3-2172 . }
 3-2173 . 
 3-2174 . A = B-C;
 3-2175 . 
 3-2176 . if (A lt B)
 3-2177 . {
 3-2178 .    A = B + C;
 3-2179 .    D = E + F;
 3-2180 . }
 3-2181 . 
 3-2182 . /* LE SV TOC-2233 this is a msaw-03.11.39 req to call isr*/
 3-2183 . 
 3-2184 . switch (msaw stuff)
 3-2185 . {
 3-2186 .    case one:
 3-2187 .    {
 3-2188 .       switch (nested)
 3-2189 .       {
 3-2190 .          case:
 3-2191 .             X = Y + Z;
 3-2192 .          case:
 3-2193 .             X = Y + Z;
 3-2194 .          default:
 3-2195 .             SwError;
 3-2196 .       } 
 3-2197 .    }
 3-2198 .    case two:
 3-2199 .    {
 3-2200 .       run_this;
 3-2201 .       break;
 3-2202 .    }
 3-2203 .    default:
 3-2204 .    {
 3-2205 .       SwError;
 3-2206 .    }
 3-2207 . }
 3-2208 . 
 3-2209 . A = B*C;
 3-2210 . 
 3-2211 . if (A <  B)
 3-2212 . {
 3-2213 .    A = B + C;
 3-2214 .    D = E + F;
 3-2215 . }
 3-2216 . 
 3-2217 . // TBD - what do I do now
 3-2218 . A = B-C;
 3-2219 . 
 3-2220 . if (A > = B)
 3-2221 . {
 3-2222 .    A = B + C;
 3-2223 .    D = E + F;
 3-2224 . }
 3-2225 . 
 3-2226 . /* LE SV TOC-2234 this is a msaw-03.11.43 req to set RTC*/
 3-2227 . A = B*C;
 3-2228 . A = B/C;
 3-2229 . 
 3-2230 . if (A != B)
 3-2231 . {
 3-2232 .    A = B + C;
 3-2233 .    D = E + F;
 3-2234 . }
 3-2235 . 
 3-2236 . A = B*C;
 3-2237 . A = B*C;
 3-2238 . A = B+C;
 3-2239 . A = B+C;
 3-2240 . // max LOC 49
 3-2241 . 
 3-2242 . }
 3-2243 . 
 3-2244 . 
 3-2245 . /*
 3-2246 . -----------------------------------------------------------------------------
 3-2247 . --| NAME:   msaw.3.12
 3-2248 . --|
 3-2249 . --| ABSTRACT:
 3-2250 . --|   This function does msaw stuff.
 3-2251 . --|
 3-2252 . --| RETURNS:
 3-2253 . --|   NONE.
 3-2254 . --|
 3-2255 . ----------------------------------------------------------------------------
 3-2256 . */
 3-2257 . static void msaw.3.12(void)
 3-2258 . {
 3-2259 . 
 3-2260 . if (A != B)
 3-2261 . {
 3-2262 .    A = B + C;
 3-2263 .    D = E + F;
 3-2264 . }
 3-2265 . 
 3-2266 . 
 3-2267 . if (A > = B)
 3-2268 . {
 3-2269 .    A = B + C;
 3-2270 .    D = E + F;
 3-2271 . }
 3-2272 . 
 3-2273 . A = B*C;
 3-2274 . A = B/C;
 3-2275 . A = B-C;
 3-2276 . 
 3-2277 . if (A < = B)
 3-2278 . {
 3-2279 .    A = B + C;
 3-2280 .    D = E + F;
 3-2281 . }
 3-2282 . 
 3-2283 . 
 3-2284 . if (A eq B)
 3-2285 . {
 3-2286 .    A = B + C;
 3-2287 .    D = E + F;
 3-2288 . }
 3-2289 . 
 3-2290 . /* dead_code = A * B; */
 3-2291 . A = B*C;
 3-2292 . 
 3-2293 . if (A le B)
 3-2294 . {
 3-2295 .    A = B + C;
 3-2296 .    D = E + F;
 3-2297 . }
 3-2298 . 
 3-2299 . 
 3-2300 . if (A < = B)
 3-2301 . {
 3-2302 .    A = B + C;
 3-2303 .    D = E + F;
 3-2304 . }
 3-2305 . 
 3-2306 . A = B*C;
 3-2307 . /* LE SV TOC-2235 this is a msaw-03.12.12 req to halt*/
 3-2308 . 
 3-2309 . if (A le B)
 3-2310 . {
 3-2311 .    A = B + C;
 3-2312 .    D = E + F;
 3-2313 . }
 3-2314 . 
 3-2315 . A = B-C;
 3-2316 . A = B/C;
 3-2317 . A = B+C;
 3-2318 . 
 3-2319 . if (A >  B)
 3-2320 . {
 3-2321 .    A = B + C;
 3-2322 .    D = E + F;
 3-2323 . }
 3-2324 . 
 3-2325 . 
 3-2326 . if (A le B)
 3-2327 . {
 3-2328 .    A = B + C;
 3-2329 .    D = E + F;
 3-2330 . }
 3-2331 . 
 3-2332 . A = B-C;
 3-2333 . 
 3-2334 . if (A == B)
 3-2335 . {
 3-2336 .    A = B + C;
 3-2337 .    D = E + F;
 3-2338 . }
 3-2339 . 
 3-2340 . 
 3-2341 . if (A > = B)
 3-2342 . {
 3-2343 .    A = B + C;
 3-2344 .    D = E + F;
 3-2345 . }
 3-2346 . 
 3-2347 . 
 3-2348 . /* 
 3-2349 . dead_code = B - C; 
 3-2350 . dead_code = D - E; 
 3-2351 . dead_code = F - G;
 3-2352 . */
 3-2353 . 
 3-2354 . 
 3-2355 . if (A > = B)
 3-2356 . {
 3-2357 .    A = B + C;
 3-2358 .    D = E + F;
 3-2359 . }
 3-2360 . 
 3-2361 . A = B*C;
 3-2362 . 
 3-2363 . if (A gt B)
 3-2364 . {
 3-2365 .    A = B + C;
 3-2366 .    D = E + F;
 3-2367 . }
 3-2368 . 
 3-2369 . A = B-C;
 3-2370 . 
 3-2371 . if (A < = B)
 3-2372 . {
 3-2373 .    A = B + C;
 3-2374 .    D = E + F;
 3-2375 . }
 3-2376 . 
 3-2377 . A = B/C;
 3-2378 . 
 3-2379 . if (A ne B)
 3-2380 . {
 3-2381 .    A = B + C;
 3-2382 .    D = E + F;
 3-2383 . }
 3-2384 . 
 3-2385 . A = B+C;
 3-2386 . A = B*C;
 3-2387 . A = B+C;
 3-2388 . A = B*C;
 3-2389 . 
 3-2390 . if (A ne B)
 3-2391 . {
 3-2392 .    A = B + C;
 3-2393 .    D = E + F;
 3-2394 . }
 3-2395 . 
 3-2396 . /* LE SV TOC-2236 this is a msaw-03.12.33 req to recover*/
 3-2397 . A = B/C;
 3-2398 . // max LOC 33
 3-2399 . 
 3-2400 . }
 3-2401 . 

3 3 Result: result/source/pr-app/pr-app-MSAW123/msaw-03.c


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

4 4 Result: result/source/pr-app/pr-app-MSAW123/msaw-04.c

Settings

Hide Controls Show Checked Summary Checked Details Not Checked All

done
12/08/2003 16:09:41 start
12/08/2003 16:09:43 end