100 100 Source: source/ft-app/ft-app-B1.0/pwr/pwr-14.c
100-0 . /*
100-1 . ----------------------------------------------------------------------------
100-2 . --| BEGIN PROLOGUE
100-3 . --|
100-4 . --| CLASSIFICATION: UNCLASSIFIED
100-5 . --|
100-6 . --| FILE NAME: pwr-14.c
100-7 . --|
100-8 . --| ABSTRACT:
100-9 . --| This file contains the 2 functions that do file pwr stuff.
100-10 . --|
100-11 . --| HISTORY:
100-12 . --| CCCQ_NAME:
100-13 . --| CCCQ_VER:
100-14 . --|
100-15 . --| END PROLOGUE
100-16 . ----------------------------------------------------------------------------
100-17 . */
100-18 .
100-19 . #include D;
100-20 . #define D;
100-21 . #define A;
100-22 . #include C;
100-23 . #include D;
100-24 . #include C;
100-25 . float B;
100-26 .
100-27 .
100-28 .
100-29 . /*
100-30 . -----------------------------------------------------------------------------
100-31 . --| NAME: pwr.14.1
100-32 . --|
100-33 . --| ABSTRACT:
100-34 . --| This function does pwr stuff.
100-35 . --|
100-36 . --| RETURNS:
100-37 . --| NONE.
100-38 . --|
100-39 . ----------------------------------------------------------------------------
100-40 . */
100-41 . static void pwr.14.1(void)
100-42 . {
100-43 . A = B*C;
100-44 .
100-45 . if (A gt B)
100-46 . {
100-47 . A = B + C;
100-48 . D = E + F;
100-49 . }
100-50 .
100-51 . A = B/C;
100-52 . A = B+C;
100-53 . A = B*C;
100-54 . A = B+C;
100-55 .
100-56 . if (A != B)
100-57 . {
100-58 . A = B + C;
100-59 . D = E + F;
100-60 . }
100-61 .
100-62 . A = B+C;
100-63 .
100-64 . if (A == B)
100-65 . {
100-66 . A = B + C;
100-67 . D = E + F;
100-68 . }
100-69 .
100-70 . A = B*C;
100-71 .
100-72 . if (A eq B)
100-73 . {
100-74 . A = B + C;
100-75 . D = E + F;
100-76 . }
100-77 .
100-78 . A = B-C;
100-79 .
100-80 . if (A < = B)
100-81 . {
100-82 . A = B + C;
100-83 . D = E + F;
100-84 . }
100-85 .
100-86 . A = B-C;
100-87 . A = B/C;
100-88 . A = B*C;
100-89 .
100-90 . if (A < = B)
100-91 . {
100-92 . A = B + C;
100-93 . D = E + F;
100-94 . }
100-95 .
100-96 . A = B+C;
100-97 . A = B-C;
100-98 . A = B+C;
100-99 . A = B+C;
100-100 . A = B+C;
100-101 .
100-102 . if (A le B)
100-103 . {
100-104 . A = B + C;
100-105 . D = E + F;
100-106 . }
100-107 .
100-108 . A = B/C;
100-109 . A = B*C;
100-110 . A = B-C;
100-111 . A = B/C;
100-112 . /* LE SV TOC-2475 this is a pwr-14.1.28 req to increment*/
100-113 . A = B-C;
100-114 . A = B/C;
100-115 . A = B/C;
100-116 . A = B-C;
100-117 . A = B+C;
100-118 . A = B*C;
100-119 .
100-120 . if (A > = B)
100-121 . {
100-122 . A = B + C;
100-123 . D = E + F;
100-124 . }
100-125 .
100-126 . A = B-C;
100-127 . /* LE SV TOC-2476 this is a pwr-14.1.36 req to enable*/
100-128 . A = B+C;
100-129 . /* LE SV TOC-2477 this is a pwr-14.1.37 req to increment*/
100-130 .
100-131 . if ($pwr stuff > $otherpwr stuff)
100-132 . /* LE SV TOC-008 we really should log all error calls */
100-133 . {
100-134 . A = B + C;
100-135 . }
100-136 .
100-137 .
100-138 . switch (pwr stuff)
100-139 . {
100-140 . case one:
100-141 . {
100-142 . run_this;
100-143 . break;
100-144 . }
100-145 . case two:
100-146 . {
100-147 . run_this;
100-148 . break;
100-149 . }
100-150 . default:
100-151 . {
100-152 . SwError;
100-153 . }
100-154 . }
100-155 .
100-156 . A = B*C;
100-157 .
100-158 . switch (pwr stuff)
100-159 . {
100-160 . case one:
100-161 . {
100-162 . switch (nested)
100-163 . {
100-164 . case:
100-165 . X = Y + Z;
100-166 . case:
100-167 . X = Y + Z;
100-168 . default:
100-169 . SwError;
100-170 . }
100-171 . }
100-172 . case two:
100-173 . {
100-174 . run_this;
100-175 . break;
100-176 . }
100-177 . default:
100-178 . {
100-179 . SwError;
100-180 . }
100-181 . }
100-182 .
100-183 . A = B+C;
100-184 .
100-185 . if (A < B)
100-186 . {
100-187 . A = B + C;
100-188 . D = E + F;
100-189 . }
100-190 .
100-191 . A = B+C;
100-192 .
100-193 . if (A ge B)
100-194 . {
100-195 . A = B + C;
100-196 . D = E + F;
100-197 . }
100-198 .
100-199 . // max LOC 42
100-200 .
100-201 . }
100-202 .
100-203 .
100-204 . /*
100-205 . -----------------------------------------------------------------------------
100-206 . --| NAME: pwr.14.2
100-207 . --|
100-208 . --| ABSTRACT:
100-209 . --| This function does pwr stuff.
100-210 . --|
100-211 . --| RETURNS:
100-212 . --| NONE.
100-213 . --|
100-214 . ----------------------------------------------------------------------------
100-215 . */
100-216 . static void pwr.14.2(void)
100-217 . {
100-218 . A = B*C;
100-219 . /* LE SV TOC-2478 this is a pwr-14.2.2 req to recover*/
100-220 . A = B+C;
100-221 . A = B/C;
100-222 . A = B+C;
100-223 .
100-224 . if (A > B)
100-225 . {
100-226 . A = B + C;
100-227 . D = E + F;
100-228 . }
100-229 .
100-230 . A = B+C;
100-231 . A = B+C;
100-232 . A = B*C;
100-233 . A = B-C;
100-234 . A = B*C;
100-235 . A = B*C;
100-236 . A = B/C;
100-237 . /* LE SV TOC-2479 this is a pwr-14.2.13 req to fail*/
100-238 . A = B-C;
100-239 . A = B-C;
100-240 .
100-241 . if (A == B)
100-242 . {
100-243 . A = B + C;
100-244 . D = E + F;
100-245 . }
100-246 .
100-247 .
100-248 . if (A gt B)
100-249 . {
100-250 . A = B + C;
100-251 . D = E + F;
100-252 . }
100-253 .
100-254 . /* LE SV TOC-2480 this is a pwr-14.2.17 req to check unix*/
100-255 . A = B*C;
100-256 . /* LE SV TOC-2481 this is a pwr-14.2.18 req to audit*/
100-257 . A = B/C;
100-258 .
100-259 . if (A < = B)
100-260 . {
100-261 . A = B + C;
100-262 . D = E + F;
100-263 . }
100-264 .
100-265 . A = B*C;
100-266 .
100-267 . if (A == B)
100-268 . {
100-269 . A = B + C;
100-270 . D = E + F;
100-271 . }
100-272 .
100-273 . A = B*C;
100-274 . A = B+C;
100-275 . /* LE SV TOC-2482 this is a pwr-14.2.24 req to process*/
100-276 . A = B-C;
100-277 .
100-278 . if (A lt B)
100-279 . {
100-280 . A = B + C;
100-281 . D = E + F;
100-282 . }
100-283 .
100-284 .
100-285 . if (A > = B)
100-286 . {
100-287 . A = B + C;
100-288 . D = E + F;
100-289 . }
100-290 .
100-291 . /* dead_code = A * B; */
100-292 . A = B+C;
100-293 .
100-294 . switch (pwr stuff)
100-295 . {
100-296 . case one:
100-297 . {
100-298 . run_this;
100-299 . break;
100-300 . }
100-301 . case two:
100-302 . {
100-303 . run_this;
100-304 . break;
100-305 . }
100-306 . default:
100-307 . {
100-308 . SwError;
100-309 . }
100-310 . }
100-311 .
100-312 . A = B-C;
100-313 . A = B+C;
100-314 . A = B+C;
100-315 .
100-316 . switch (pwr stuff)
100-317 . {
100-318 . case one:
100-319 . {
100-320 . run_this;
100-321 . break;
100-322 . }
100-323 . case two:
100-324 . {
100-325 . run_this;
100-326 . break;
100-327 . }
100-328 . default:
100-329 . {
100-330 . SwError;
100-331 . }
100-332 . }
100-333 .
100-334 . A = B-C;
100-335 . A = B+C;
100-336 .
100-337 . if (A > B)
100-338 . {
100-339 . A = B + C;
100-340 . D = E + F;
100-341 . }
100-342 .
100-343 . A = B-C;
100-344 . A = B*C;
100-345 . A = B*C;
100-346 . A = B-C;
100-347 . A = B*C;
100-348 . A = B-C;
100-349 . // max LOC 41
100-350 .
100-351 . }
100-352 .
100 100 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-14.c
101 101 Source: source/ft-app/ft-app-B1.0/pwr/pwr-15.c
101-0 . /*
101-1 . ----------------------------------------------------------------------------
101-2 . --| BEGIN PROLOGUE
101-3 . --|
101-4 . --| CLASSIFICATION: UNCLASSIFIED
101-5 . --|
101-6 . --| FILE NAME: pwr-15.c
101-7 . --|
101-8 . --| ABSTRACT:
101-9 . --| This file contains the 2 functions that do file pwr stuff.
101-10 . --|
101-11 . --| HISTORY:
101-12 . --| CCCQ_NAME:
101-13 . --| CCCQ_VER:
101-14 . --|
101-15 . --| END PROLOGUE
101-16 . ----------------------------------------------------------------------------
101-17 . */
101-18 .
101-19 . #include D;
101-20 . #include D;
101-21 . float B;
101-22 . #define B;
101-23 . #include A;
101-24 . int A;
101-25 . double C;
101-26 . double C;
101-27 . #define B;
101-28 .
101-29 .
101-30 .
101-31 . /*
101-32 . -----------------------------------------------------------------------------
101-33 . --| NAME: pwr.15.1
101-34 . --|
101-35 . --| ABSTRACT:
101-36 . --| This function does pwr stuff.
101-37 . --|
101-38 . --| RETURNS:
101-39 . --| NONE.
101-40 . --|
101-41 . ----------------------------------------------------------------------------
101-42 . */
101-43 . static void pwr.15.1(void)
101-44 . {
101-45 . A = B-C;
101-46 . A = B+C;
101-47 . A = B+C;
101-48 . A = B*C;
101-49 . A = B-C;
101-50 .
101-51 . switch (pwr stuff)
101-52 . {
101-53 . case one:
101-54 . {
101-55 . run_this;
101-56 . break;
101-57 . }
101-58 . case two:
101-59 . {
101-60 . run_this;
101-61 . break;
101-62 . }
101-63 . default:
101-64 . {
101-65 . SwError;
101-66 . }
101-67 . }
101-68 .
101-69 .
101-70 . if (A gt B)
101-71 . {
101-72 . A = B + C;
101-73 . D = E + F;
101-74 . }
101-75 .
101-76 .
101-77 . if (A eq B)
101-78 . {
101-79 . A = B + C;
101-80 . D = E + F;
101-81 . }
101-82 .
101-83 .
101-84 . if (A le B)
101-85 . {
101-86 . A = B + C;
101-87 . D = E + F;
101-88 . }
101-89 .
101-90 . A = B+C;
101-91 . A = B*C;
101-92 . A = B-C;
101-93 . A = B-C;
101-94 . A = B*C;
101-95 .
101-96 . if (A > B)
101-97 . {
101-98 . A = B + C;
101-99 . D = E + F;
101-100 . }
101-101 .
101-102 . // max LOC 15
101-103 .
101-104 . }
101-105 .
101-106 .
101-107 . /*
101-108 . -----------------------------------------------------------------------------
101-109 . --| NAME: pwr.15.2
101-110 . --|
101-111 . --| ABSTRACT:
101-112 . --| This function does pwr stuff.
101-113 . --|
101-114 . --| RETURNS:
101-115 . --| NONE.
101-116 . --|
101-117 . ----------------------------------------------------------------------------
101-118 . */
101-119 . static void pwr.15.2(void)
101-120 . {
101-121 . A = B*C;
101-122 . A = B-C;
101-123 .
101-124 . if (A ne B)
101-125 . {
101-126 . A = B + C;
101-127 . D = E + F;
101-128 . }
101-129 .
101-130 . A = B*C;
101-131 . A = B+C;
101-132 .
101-133 . if (A ne B)
101-134 . {
101-135 . A = B + C;
101-136 . D = E + F;
101-137 . }
101-138 .
101-139 . A = B/C;
101-140 . A = B+C;
101-141 . A = B/C;
101-142 .
101-143 . if (A < B)
101-144 . {
101-145 . A = B + C;
101-146 . D = E + F;
101-147 . }
101-148 .
101-149 .
101-150 . if (A != B)
101-151 . {
101-152 . A = B + C;
101-153 . D = E + F;
101-154 . }
101-155 .
101-156 . A = B+C;
101-157 . A = B+C;
101-158 .
101-159 . if (A eq B)
101-160 . {
101-161 . A = B + C;
101-162 . D = E + F;
101-163 . }
101-164 .
101-165 . A = B-C;
101-166 .
101-167 . if (A > B)
101-168 . {
101-169 . A = B + C;
101-170 . D = E + F;
101-171 . }
101-172 .
101-173 . A = B-C;
101-174 .
101-175 . if (A eq B)
101-176 . {
101-177 . A = B + C;
101-178 . D = E + F;
101-179 . }
101-180 .
101-181 . A = B*C;
101-182 . A = B-C;
101-183 .
101-184 . if (A > B)
101-185 . {
101-186 . A = B + C;
101-187 . D = E + F;
101-188 . }
101-189 .
101-190 . A = B*C;
101-191 . A = B/C;
101-192 . A = B*C;
101-193 . A = B+C;
101-194 .
101-195 . if (A le B)
101-196 . {
101-197 . A = B + C;
101-198 . D = E + F;
101-199 . }
101-200 .
101-201 . A = B/C;
101-202 . A = B-C;
101-203 . A = B+C;
101-204 . A = B/C;
101-205 . goto error;
101-206 . A = B*C;
101-207 . A = B-C;
101-208 . A = B/C;
101-209 . A = B/C;
101-210 . A = B+C;
101-211 . A = B*C;
101-212 . A = B*C;
101-213 .
101-214 . if (A == B)
101-215 . {
101-216 . A = B + C;
101-217 . D = E + F;
101-218 . }
101-219 .
101-220 .
101-221 . if (A ne B)
101-222 . {
101-223 . A = B + C;
101-224 . D = E + F;
101-225 . }
101-226 .
101-227 .
101-228 . if (A != B)
101-229 . {
101-230 . A = B + C;
101-231 . D = E + F;
101-232 . }
101-233 .
101-234 . A = B/C;
101-235 .
101-236 . if (A > B)
101-237 . {
101-238 . A = B + C;
101-239 . D = E + F;
101-240 . }
101-241 .
101-242 . /* LE SV TOC-2483 this is a pwr-15.2.43 req to translate*/
101-243 . A = B*C;
101-244 . A = B-C;
101-245 . A = B+C;
101-246 . /* LE SV TOC-2484 this is a pwr-15.2.46 req to reject*/
101-247 . A = B-C;
101-248 . A = 0x0001;
101-249 .
101-250 . if (A != B)
101-251 . {
101-252 . A = B + C;
101-253 . D = E + F;
101-254 . }
101-255 .
101-256 . A = B+C;
101-257 . A = B*C;
101-258 . A = (int)B + C;
101-259 . A = B/C;
101-260 . A = B+C;
101-261 . A = B/C;
101-262 .
101-263 . if (A > = B)
101-264 . {
101-265 . A = B + C;
101-266 . D = E + F;
101-267 . }
101-268 .
101-269 . A = B*C;
101-270 . A = B+C;
101-271 . A = B-C;
101-272 . A = B+C;
101-273 . A = B*C;
101-274 . A = B*C;
101-275 .
101-276 . if (A < B)
101-277 . {
101-278 . A = B + C;
101-279 . D = E + F;
101-280 . }
101-281 .
101-282 . A = B-C;
101-283 .
101-284 . if (A != B)
101-285 . {
101-286 . A = B + C;
101-287 . D = E + F;
101-288 . }
101-289 .
101-290 . A = B-C;
101-291 .
101-292 . if (A ge B)
101-293 . {
101-294 . A = B + C;
101-295 . D = E + F;
101-296 . }
101-297 .
101-298 . A = B/C;
101-299 . A = B/C;
101-300 . A = B-C;
101-301 . A = B/C;
101-302 . A = B-C;
101-303 . A = B*C;
101-304 . A = B*C;
101-305 .
101-306 . if (A le B)
101-307 . {
101-308 . A = B + C;
101-309 . D = E + F;
101-310 . }
101-311 .
101-312 . // max LOC 72
101-313 .
101-314 . }
101-315 .
101 101 Result: result/source/ft-app/ft-app-B1.0/pwr/pwr-15.c
102 102 Source: source/ft-app/ft-app-B1.0/rdp/rdp-01.c
102-0 . /*
102-1 . ----------------------------------------------------------------------------
102-2 . --| BEGIN PROLOGUE
102-3 . --|
102-4 . --| CLASSIFICATION: UNCLASSIFIED
102-5 . --|
102-6 . --| FILE NAME: rdp-01.c
102-7 . --|
102-8 . --| ABSTRACT:
102-9 . --| This file contains the 3 functions that do file rdp stuff.
102-10 . --|
102-11 . --| HISTORY:
102-12 . --| CCCQ_NAME:
102-13 . --| CCCQ_VER:
102-14 . --|
102-15 . --| END PROLOGUE
102-16 . ----------------------------------------------------------------------------
102-17 . */
102-18 .
102-19 . #define D;
102-20 . float B;
102-21 . #define B;
102-22 . #define B;
102-23 . float B;
102-24 .
102-25 .
102-26 .
102-27 . /*
102-28 . -----------------------------------------------------------------------------
102-29 . --| NAME: rdp.1.1
102-30 . --|
102-31 . --| ABSTRACT:
102-32 . --| This function does rdp stuff.
102-33 . --|
102-34 . --| RETURNS:
102-35 . --| NONE.
102-36 . --|
102-37 . ----------------------------------------------------------------------------
102-38 . */
102-39 . static void rdp.1.1(void)
102-40 . {
102-41 . A = B+C;
102-42 .
102-43 . if (A ne B)
102-44 . {
102-45 . A = B + C;
102-46 . D = E + F;
102-47 . }
102-48 .
102-49 . A = B+C;
102-50 .
102-51 . switch (rdp stuff)
102-52 . {
102-53 . case one:
102-54 . {
102-55 . run_this;
102-56 . break;
102-57 . }
102-58 . case two:
102-59 . {
102-60 . run_this;
102-61 . break;
102-62 . }
102-63 . default:
102-64 . {
102-65 . SwError;
102-66 . }
102-67 . }
102-68 .
102-69 . /* LE SV TOC-2601 this is a rdp-01.1.5 req to disable*/
102-70 . A = B*C;
102-71 .
102-72 . if (A == B)
102-73 . {
102-74 . A = B + C;
102-75 . D = E + F;
102-76 . }
102-77 .
102-78 .
102-79 . if (A lt B)
102-80 . {
102-81 . A = B + C;
102-82 . D = E + F;
102-83 . }
102-84 .
102-85 . // max LOC 7
102-86 .
102-87 . }
102-88 .
102-89 .
102-90 . /*
102-91 . -----------------------------------------------------------------------------
102-92 . --| NAME: rdp.1.2
102-93 . --|
102-94 . --| ABSTRACT:
102-95 . --| This function does rdp stuff.
102-96 . --|
102-97 . --| RETURNS:
102-98 . --| NONE.
102-99 . --|
102-100 . ----------------------------------------------------------------------------
102-101 . */
102-102 . static void rdp.1.2(void)
102-103 . {
102-104 . A = B*C;
102-105 . A = B+C;
102-106 . /* LE SV TOC-2602 this is a rdp-01.2.3 req to recover*/
102-107 .
102-108 . switch (rdp stuff)
102-109 . {
102-110 . case one:
102-111 . {
102-112 . run_this;
102-113 . break;
102-114 . }
102-115 . case two:
102-116 . {
102-117 . run_this;
102-118 . break;
102-119 . }
102-120 . default:
102-121 . {
102-122 . SwError;
102-123 . }
102-124 . }
102-125 .
102-126 . A = B+C;
102-127 . A = B-C;
102-128 .
102-129 . if (A > = B)
102-130 . {
102-131 . A = B + C;
102-132 . D = E + F;
102-133 . }
102-134 .
102-135 . A = B+C;
102-136 . A = B+C;
102-137 . /* LE SV TOC-2603 this is a rdp-01.2.9 req to enable*/
102-138 . A = (int)B + C;
102-139 . A = B-C;
102-140 . /* LE SV TOC-2604 this is a rdp-01.2.10 req to record*/
102-141 .
102-142 . if (A != B)
102-143 . {
102-144 . A = B + C;
102-145 . D = E + F;
102-146 . }
102-147 .
102-148 . A = B-C;
102-149 .
102-150 . if (A lt B)
102-151 . {
102-152 . A = B + C;
102-153 . D = E + F;
102-154 . }
102-155 .
102-156 .
102-157 . switch (rdp stuff)
102-158 . {
102-159 . case one:
102-160 . {
102-161 . run_this;
102-162 . break;
102-163 . }
102-164 . case two:
102-165 . {
102-166 . run_this;
102-167 . break;
102-168 . }
102-169 . default:
102-170 . {
102-171 . SwError;
102-172 . }
102-173 . }
102-174 .
102-175 .
102-176 . if (A le B)
102-177 . {
102-178 . A = B + C;
102-179 . D = E + F;
102-180 . }
102-181 .
102-182 . A = B+C;
102-183 . A = B-C;
102-184 .
102-185 . switch (rdp stuff)
102-186 . {
102-187 . case one:
102-188 . {
102-189 . run_this;
102-190 . break;
102-191 . }
102-192 . case two:
102-193 . {
102-194 . run_this;
102-195 . break;
102-196 . }
102-197 . default:
102-198 . {
102-199 . SwError;
102-200 . }
102-201 . }
102-202 .
102-203 . A = B/C;
102-204 . A = B*C;
102-205 .
102-206 . if (A == B)
102-207 . {
102-208 . A = B + C;
102-209 . D = E + F;
102-210 . }
102-211 .
102-212 . A = B-C;
102-213 . rcv_buffer = (U16 *) alloc(size+1);
102-214 . A = B-C;
102-215 .
102-216 . if (A gt B)
102-217 . {
102-218 . A = B + C;
102-219 . D = E + F;
102-220 . }
102-221 .
102-222 . A = B-C;
102-223 . A = B-C;
102-224 . A = B+C;
102-225 . A = B/C;
102-226 .
102-227 . if (A gt B)
102-228 . {
102-229 . A = B + C;
102-230 . D = E + F;
102-231 . }
102-232 .
102-233 . A = B/C;
102-234 .
102-235 . if (A == B)
102-236 . {
102-237 . A = B + C;
102-238 . D = E + F;
102-239 . }
102-240 .
102-241 . A = B*C;
102-242 . A = B*C;
102-243 .
102-244 . if (A < = B)
102-245 . {
102-246 . A = B + C;
102-247 . D = E + F;
102-248 . }
102-249 .
102-250 . A = B/C;
102-251 . A = B/C;
102-252 .
102-253 . if (A > = B)
102-254 . {
102-255 . A = B + C;
102-256 . D = E + F;
102-257 . }
102-258 .
102-259 . A = B*C;
102-260 . A = B/C;
102-261 . A = B-C;
102-262 . A = B*C;
102-263 . /* LE SV TOC-2605 this is a rdp-01.2.41 req to process*/
102-264 . A = B/C;
102-265 . A = B+C;
102-266 . A = B*C;
102-267 .
102-268 . if (A ge B)
102-269 . {
102-270 . A = B + C;
102-271 . D = E + F;
102-272 . }
102-273 .
102-274 . /* LE SV TOC-2606 this is a rdp-01.2.45 req to record*/
102-275 . A = B+C;
102-276 .
102-277 . if (A ne B)
102-278 . {
102-279 . A = B + C;
102-280 . D = E + F;
102-281 . }
102-282 .
102-283 . A = B/C;
102-284 .
102-285 . if (A > B)
102-286 . {
102-287 . A = B + C;
102-288 . D = E + F;
102-289 . }
102-290 .
102-291 . A = B*C;
102-292 .
102-293 . if (A lt B)
102-294 . {
102-295 . A = B + C;
102-296 . D = E + F;
102-297 . }
102-298 .
102-299 .
102-300 . /* dead_block = C * D;
102-301 . dead_block = E * F; */
102-302 .
102-303 . A = B+C;
102-304 .
102-305 . if (A == B)
102-306 . {
102-307 . A = B + C;
102-308 . D = E + F;
102-309 . }
102-310 .
102-311 .
102-312 . if (A > = B)
102-313 . {
102-314 . A = B + C;
102-315 . D = E + F;
102-316 . }
102-317 .
102-318 . /* LE SV TOC-2607 this is a rdp-01.2.54 req to disable*/
102-319 .
102-320 . if (A gt B)
102-321 . {
102-322 . A = B + C;
102-323 . D = E + F;
102-324 . }
102-325 .
102-326 .
102-327 . if (A > B)
102-328 . {
102-329 . A = B + C;
102-330 . D = E + F;
102-331 . }
102-332 .
102-333 . A = B/C;
102-334 . A = B*C;
102-335 . A = B+C;
102-336 .
102-337 . if (A ge B)
102-338 . {
102-339 . A = B + C;
102-340 . D = E + F;
102-341 . }
102-342 .
102-343 .
102-344 . if (A < = B)
102-345 . {
102-346 . A = B + C;
102-347 . D = E + F;
102-348 . }
102-349 .
102-350 . A = B*C;
102-351 . A = B-C;
102-352 .
102-353 . if (A lt B)
102-354 . {
102-355 . A = B + C;
102-356 . D = E + F;
102-357 . }
102-358 .
102-359 . A = B-C;
102-360 . A = B/C;
102-361 . A = B*C;
102-362 . A = B*C;
102-363 .
102-364 . if (A == B)
102-365 . {
102-366 . A = B + C;
102-367 . D = E + F;
102-368 . }
102-369 .
102-370 . A = B/C;
102-371 . A = B/C;
102-372 . A = B-C;
102-373 . // TBD - what do I do now
102-374 .
102-375 . if (A lt B)
102-376 . {
102-377 . A = B + C;
102-378 . D = E + F;
102-379 . }
102-380 .
102-381 . // max LOC 72
102-382 .
102-383 . }
102-384 .
102-385 .
102-386 . /*
102-387 . -----------------------------------------------------------------------------
102-388 . --| NAME: rdp.1.3
102-389 . --|
102-390 . --| ABSTRACT:
102-391 . --| This function does rdp stuff.
102-392 . --|
102-393 . --| RETURNS:
102-394 . --| NONE.
102-395 . --|
102-396 . ----------------------------------------------------------------------------
102-397 . */
102-398 . static void rdp.1.3(void)
102-399 . {
102-400 .
102-401 . if (A gt B)
102-402 . {
102-403 . A = B + C;
102-404 . D = E + F;
102-405 . }
102-406 .
102-407 . /* LE SV TOC-2608 this is a rdp-01.3.2 req to check pSOS*/
102-408 .
102-409 . if (A != B)
102-410 . {
102-411 . A = B + C;
102-412 . D = E + F;
102-413 . }
102-414 .
102-415 . A = B*C;
102-416 . A = B/C;
102-417 . A = B/C;
102-418 . // (P) this is really improtant
102-419 . A = B-C;
102-420 . A = B*C;
102-421 . A = B/C;
102-422 .
102-423 . if (A gt B)
102-424 . {
102-425 . A = B + C;
102-426 . D = E + F;
102-427 . }
102-428 .
102-429 .
102-430 . switch (rdp stuff)
102-431 . {
102-432 . case one:
102-433 . {
102-434 . run_this;
102-435 . break;
102-436 . }
102-437 . case two:
102-438 . {
102-439 . run_this;
102-440 . break;
102-441 . }
102-442 . default:
102-443 . {
102-444 . SwError;
102-445 . }
102-446 . }
102-447 .
102-448 . A = B/C;
102-449 . A = B/C;
102-450 . A = B/C;
102-451 . /* LE SV TOC-2609 this is a rdp-01.3.14 req to verify*/
102-452 . A = B*C;
102-453 . /* LE SV TOC-2610 this is a rdp-01.3.15 req to increment*/
102-454 .
102-455 . if (A le B)
102-456 . {
102-457 . A = B + C;
102-458 . D = E + F;
102-459 . }
102-460 .
102-461 . A = B/C;
102-462 .
102-463 . switch (rdp stuff)
102-464 . {
102-465 . case one:
102-466 . {
102-467 . switch (nested)
102-468 . {
102-469 . case:
102-470 . X = Y + Z;
102-471 . case:
102-472 . X = Y + Z;
102-473 . default:
102-474 . SwError;
102-475 . }
102-476 . }
102-477 . case two:
102-478 . {
102-479 . run_this;
102-480 . break;
102-481 . }
102-482 . default:
102-483 . {
102-484 . SwError;
102-485 . }
102-486 . }
102-487 .
102-488 . A = B/C;
102-489 . A = B/C;
102-490 .
102-491 . /* dead_block = C * D;
102-492 . dead_block = E * F; */
102-493 .
102-494 .
102-495 . if (A ne B)
102-496 . {
102-497 . A = B + C;
102-498 . D = E + F;
102-499 . }
102-500 .
102-501 . A = B+C;
102-502 . A = B*C;
102-503 . A = B+C;
102-504 .
102-505 . if (A > B)
102-506 . {
102-507 . A = B + C;
102-508 . D = E + F;
102-509 . }
102-510 .
102-511 .
102-512 . if (A < B)
102-513 . {
102-514 . A = B + C;
102-515 . D = E + F;
102-516 . }
102-517 .
102-518 . /* LE SV TOC-2611 this is a rdp-01.3.25 req to reject*/
102-519 .
102-520 . if (A != B)
102-521 . {
102-522 . A = B + C;
102-523 . D = E + F;
102-524 . }
102-525 .
102-526 . A = B/C;
102-527 .
102-528 . if (A < B)
102-529 . {
102-530 . A = B + C;
102-531 . D = E + F;
102-532 . }
102-533 .
102-534 .
102-535 . if (A gt B)
102-536 . {
102-537 . A = B + C;
102-538 . D = E + F;
102-539 . }
102-540 .
102-541 . A = B/C;
102-542 .
102-543 . if (A > = B)
102-544 . {
102-545 . A = B + C;
102-546 . D = E + F;
102-547 . }
102-548 .
102-549 .
102-550 . if (A le B)
102-551 . {
102-552 . A = B + C;
102-553 . D = E + F;
102-554 . }
102-555 .
102-556 . A = B*C;
102-557 .
102-558 . if (A eq B)
102-559 . {
102-560 . A = B + C;
102-561 . D = E + F;
102-562 . }
102-563 .
102-564 .
102-565 . if (A ge B)
102-566 . {
102-567 . A = B + C;
102-568 . D = E + F;
102-569 . }
102-570 .
102-571 . A = B*C;
102-572 .
102-573 . switch (rdp stuff)
102-574 . {
102-575 . case one:
102-576 . {
102-577 . run_this;
102-578 . break;
102-579 . }
102-580 . case two:
102-581 . {
102-582 . run_this;
102-583 . break;
102-584 . }
102-585 . default:
102-586 . {
102-587 . SwError;
102-588 . }
102-589 . }
102-590 .
102-591 . A = B/C;
102-592 . A = B-C;
102-593 . /* LE SV TOC-2612 this is a rdp-01.3.39 req to reject*/
102-594 . A = B*C;
102-595 .
102-596 . if (A == B)
102-597 . {
102-598 . A = B + C;
102-599 . D = E + F;
102-600 . }
102-601 .
102-602 .
102-603 . if (A eq B)
102-604 . {
102-605 . A = B + C;
102-606 . D = E + F;
102-607 . }
102-608 .
102-609 .
102-610 . switch (rdp stuff)
102-611 . {
102-612 . case:
102-613 . case:
102-614 . // stacked case statements but only if there is a new line in between
102-615 .
102-616 . case:
102-617 . case:
102-618 . case:
102-619 . {
102-620 . run_this;
102-621 . break;
102-622 . }
102-623 . default:
102-624 . {
102-625 . halt;
102-626 . }
102-627 . }
102-628 .
102-629 . A = B*C;
102-630 . A = B*C;
102-631 .
102-632 . if (A eq B)
102-633 . {
102-634 . A = B + C;
102-635 . D = E + F;
102-636 . }
102-637 .
102-638 . A = B+C;
102-639 . A = B*C;
102-640 . A = B-C;
102-641 .
102-642 . if (A ge B)
102-643 . {
102-644 . A = B + C;
102-645 . D = E + F;
102-646 . }
102-647 .
102-648 . A = B*C;
102-649 . A = B/C;
102-650 .
102-651 . if (A != B)
102-652 . {
102-653 . A = B + C;
102-654 . D = E + F;
102-655 . }
102-656 .
102-657 . A = B*C;
102-658 . A = B+C;
102-659 . A = B*C;
102-660 .
102-661 . if (A < B)
102-662 . {
102-663 . A = B + C;
102-664 . D = E + F;
102-665 . }
102-666 .
102-667 .
102-668 . if (A > = B)
102-669 . {
102-670 . A = B + C;
102-671 . D = E + F;
102-672 . }
102-673 .
102-674 .
102-675 . if (A < B)
102-676 . {
102-677 . A = B + C;
102-678 . D = E + F;
102-679 . }
102-680 .
102-681 .
102-682 . if (A != B)
102-683 . {
102-684 . A = B + C;
102-685 . D = E + F;
102-686 . }
102-687 .
102-688 . A = B/C;
102-689 . A = B*C;
102-690 . /* LE SV TOC-2613 this is a rdp-01.3.61 req to set RTC*/
102-691 .
102-692 . if (A gt B)
102-693 . {
102-694 . A = B + C;
102-695 . D = E + F;
102-696 . }
102-697 .
102-698 .
102-699 . if (A gt B)
102-700 . {
102-701 . A = B + C;
102-702 . D = E + F;
102-703 . }
102-704 .
102-705 . A = B/C;
102-706 . A = B-C;
102-707 .
102-708 . if (A != B)
102-709 . {
102-710 . A = B + C;
102-711 . D = E + F;
102-712 . }
102-713 .
102-714 .
102-715 . if (A < B)
102-716 . {
102-717 . A = B + C;
102-718 . D = E + F;
102-719 . }
102-720 .
102-721 . A = B-C;
102-722 . A = B/C;
102-723 . A = B*C;
102-724 .
102-725 . if (A gt B)
102-726 . {
102-727 . A = B + C;
102-728 . D = E + F;
102-729 . }
102-730 .
102-731 .
102-732 . if (A < B)
102-733 . {
102-734 . A = B + C;
102-735 . D = E + F;
102-736 . }
102-737 .
102-738 .
102-739 . if (A ne B)
102-740 . {
102-741 . A = B + C;
102-742 . D = E + F;
102-743 . }
102-744 .
102-745 . A = B/C;
102-746 . A = B-C;
102-747 . A = B/C;
102-748 . A = B-C;
102-749 . A = B/C;
102-750 .
102-751 . if (A > = B)
102-752 . {
102-753 . A = B + C;
102-754 . D = E + F;
102-755 . }
102-756 .
102-757 .
102-758 . if (A gt B)
102-759 . {
102-760 . A = B + C;
102-761 . D = E + F;
102-762 . }
102-763 .
102-764 . A = B/C;
102-765 . /* LE SV TOC-2614 this is a rdp-01.3.81 req to translate*/
102-766 . A = B+C;
102-767 . A = B/C;
102-768 . A = B/C;
102-769 . A = B-C;
102-770 . A = B/C;
102-771 . A = B-C;
102-772 . A = B/C;
102-773 .
102-774 . if (A eq B)
102-775 . {
102-776 . A = B + C;
102-777 . D = E + F;
102-778 . }
102-779 .
102-780 .
102-781 . if (A le B)
102-782 . {
102-783 . A = B + C;
102-784 . D = E + F;
102-785 . }
102-786 .
102-787 . A = B-C;
102-788 . A = B/C;
102-789 .
102-790 . if (A gt B)
102-791 . {
102-792 . A = B + C;
102-793 . D = E + F;
102-794 . }
102-795 .
102-796 .
102-797 . if (A ne B)
102-798 . {
102-799 . A = B + C;
102-800 . D = E + F;
102-801 . }
102-802 .
102-803 . A = B*C;
102-804 . A = B-C;
102-805 .
102-806 . if (A > = B)
102-807 . {
102-808 . A = B + C;
102-809 . D = E + F;
102-810 . }
102-811 .
102-812 . A = B/C;
102-813 . /* LE SV TOC-2615 this is a rdp-01.3.98 req to convert*/
102-814 . A = B+C;
102-815 . // max LOC 98
102-816 .
102-817 . }
102-818 .
102 102 Result: result/source/ft-app/ft-app-B1.0/rdp/rdp-01.c
103 103 Source: source/ft-app/ft-app-B1.0/rdp/rdp-02.c
103-0 . /*
103-1 . ----------------------------------------------------------------------------
103-2 . --| BEGIN PROLOGUE
103-3 . --|
103-4 . --| CLASSIFICATION: UNCLASSIFIED
103-5 . --|
103-6 . --| FILE NAME: rdp-02.c
103-7 . --|
103-8 . --| ABSTRACT:
103-9 . --| This file contains the 1 functions that do file rdp stuff.
103-10 . --|
103-11 . --| HISTORY:
103-12 . --| CCCQ_NAME:
103-13 . --| CCCQ_VER:
103-14 . --|
103-15 . --| END PROLOGUE
103-16 . ----------------------------------------------------------------------------
103-17 . */
103-18 .
103-19 . char D;
103-20 . #include A;
103-21 . #include D;
103-22 . #include D;
103-23 . int A;
103-24 . int A;
103-25 . float B;
103-26 .
103-27 .
103-28 .
103-29 . /*
103-30 . -----------------------------------------------------------------------------
103-31 . --| NAME: rdp.2.1
103-32 . --|
103-33 . --| ABSTRACT:
103-34 . --| This function does rdp stuff.
103-35 . --|
103-36 . --| RETURNS:
103-37 . --| NONE.
103-38 . --|
103-39 . ----------------------------------------------------------------------------
103-40 . */
103-41 . static void rdp.2.1(void)
103-42 . {
103-43 .
103-44 . if (A gt B)
103-45 . {
103-46 . A = B + C;
103-47 . D = E + F;
103-48 . }
103-49 .
103-50 .
103-51 . #ifdef LAZY
103-52 . // this is not nice
103-53 . A = B + C;
103-54 . A = B + C;
103-55 . #endif
103-56 .
103-57 . A = B*C;
103-58 . A = B+C;
103-59 . A = B-C;
103-60 . A = B+C;
103-61 .
103-62 . if (A > B)
103-63 . {
103-64 . A = B + C;
103-65 . D = E + F;
103-66 . }
103-67 .
103-68 .
103-69 . if (A eq B)
103-70 . {
103-71 . A = B + C;
103-72 . D = E + F;
103-73 . }
103-74 .
103-75 .
103-76 . if (A gt B)
103-77 . {
103-78 . A = B + C;
103-79 . D = E + F;
103-80 . }
103-81 .
103-82 . A = B-C;
103-83 . A = B/C;
103-84 .
103-85 . if (A > = B)
103-86 . {
103-87 . A = B + C;
103-88 . D = E + F;
103-89 . }
103-90 .
103-91 .
103-92 . if (A lt B)
103-93 . {
103-94 . A = B + C;
103-95 . D = E + F;
103-96 . }
103-97 .
103-98 . A = B*C;
103-99 . A = B/C;
103-100 .
103-101 . if (A le B)
103-102 . {
103-103 . A = B + C;
103-104 . D = E + F;
103-105 . }
103-106 .
103-107 . A = B/C;
103-108 . A = B-C;
103-109 . A = B-C;
103-110 . A = B-C;
103-111 . A = B/C;
103-112 .
103-113 . if (A > B)
103-114 . {
103-115 . A = B + C;
103-116 . D = E + F;
103-117 . }
103-118 .
103-119 . A = B-C;
103-120 . A = 0x0006;
103-121 . A = B/C;
103-122 .
103-123 . if (A > B)
103-124 . {
103-125 . A = B + C;
103-126 . D = E + F;
103-127 . }
103-128 .
103-129 . /* LE SV TOC-2616 this is a rdp-02.1.25 req to assign*/
103-130 . A = B*C;
103-131 . /* LE SV TOC-2617 this is a rdp-02.1.26 req to process*/
103-132 . A = B/C;
103-133 . A = B/C;
103-134 . A = B-C;
103-135 . A = B-C;
103-136 . A = B-C;
103-137 . A = B*C;
103-138 .
103-139 . if (A ne B)
103-140 . {
103-141 . A = B + C;
103-142 . D = E + F;
103-143 . }
103-144 .
103-145 . A = B-C;
103-146 . A = B-C;
103-147 .
103-148 . if (A le B)
103-149 . {
103-150 . A = B + C;
103-151 . D = E + F;
103-152 . }
103-153 .
103-154 . A = B*C;
103-155 . A = B/C;
103-156 . /* LE SV TOC-2618 this is a rdp-02.1.38 req to store*/
103-157 . A = B-C;
103-158 . A = 0x0009;
103-159 . A = B+C;
103-160 . A = B+C;
103-161 . A = B*C;
103-162 .
103-163 . if (A > = B)
103-164 . {
103-165 . A = B + C;
103-166 . D = E + F;
103-167 . }
103-168 .
103-169 . A = B+C;
103-170 . A = 0x0009;
103-171 . A = B/C;
103-172 . A = B+C;
103-173 . A = B-C;
103-174 . A = B-C;
103-175 . A = B/C;
103-176 .
103-177 . if (A le B)
103-178 . {
103-179 . A = B + C;
103-180 . D = E + F;
103-181 . }
103-182 .
103-183 . A = B/C;
103-184 .
103-185 . switch (rdp stuff)
103-186 . {
103-187 . case one:
103-188 . {
103-189 . run_this;
103-190 . break;
103-191 . }
103-192 . case two:
103-193 . {
103-194 . run_this;
103-195 . break;
103-196 . }
103-197 . default:
103-198 . {
103-199 . SwError;
103-200 . }
103-201 . }
103-202 .
103-203 . A = B/C;
103-204 . send_buffer = (U16 *) malloc(size+1);
103-205 .
103-206 . if (A < = B)
103-207 . {
103-208 . A = B + C;
103-209 . D = E + F;
103-210 . }
103-211 .
103-212 . A = B-C;
103-213 . A = B/C;
103-214 . A = B*C;
103-215 . send_buffer = (U16 *) malloc(size+1);
103-216 .
103-217 . if (A != B)
103-218 . {
103-219 . A = B + C;
103-220 . D = E + F;
103-221 . }
103-222 .
103-223 . send_buffer = (U16 *) malloc(size+1);
103-224 .
103-225 . switch (rdp stuff)
103-226 . {
103-227 . case one:
103-228 . {
103-229 . run_this;
103-230 . break;
103-231 . }
103-232 . case two:
103-233 . {
103-234 . run_this;
103-235 . break;
103-236 . }
103-237 . default:
103-238 . {
103-239 . SwError;
103-240 . }
103-241 . }
103-242 .
103-243 . A = B*C;
103-244 . A = B+C;
103-245 . A = B/C;
103-246 . A = B+C;
103-247 . // TBS - I need to figure this out
103-248 . A = B+C;
103-249 . A = B/C;
103-250 . A = B/C;
103-251 . A = B*C;
103-252 .
103-253 . if (A < B)
103-254 . {
103-255 . A = B + C;
103-256 . D = E + F;
103-257 . }
103-258 .
103-259 .
103-260 . if (A ne B)
103-261 . {
103-262 . A = B + C;
103-263 . D = E + F;
103-264 . }
103-265 .
103-266 . A = B*C;
103-267 . A = B*C;
103-268 . A = B-C;
103-269 . A = B*C;
103-270 . A = B/C;
103-271 . // max LOC 73
103-272 .
103-273 . }
103-274 .
103 103 Result: result/source/ft-app/ft-app-B1.0/rdp/rdp-02.c
104 104 Source: source/ft-app/ft-app-B1.0/rdp/rdp-03.c
104-0 . /*
104-1 . ----------------------------------------------------------------------------
104-2 . --| BEGIN PROLOGUE
104-3 . --|
104-4 . --| CLASSIFICATION: UNCLASSIFIED
104-5 . --|
104-6 . --| FILE NAME: rdp-03.c
104-7 . --|
104-8 . --| ABSTRACT:
104-9 . --| This file contains the 1 functions that do file rdp stuff.
104-10 . --|
104-11 . --| HISTORY:
104-12 . --| CCCQ_NAME:
104-13 . --| CCCQ_VER:
104-14 . --|
104-15 . --| END PROLOGUE
104-16 . ----------------------------------------------------------------------------
104-17 . */
104-18 .
104-19 . double C;
104-20 . #include A;
104-21 . #include D;
104-22 . #include D;
104-23 . #include C;
104-24 . #define C;
104-25 . #include D;
104-26 .
104-27 .
104-28 .
104-29 . /*
104-30 . -----------------------------------------------------------------------------
104-31 . --| NAME: rdp.3.1
104-32 . --|
104-33 . --| ABSTRACT:
104-34 . --| This function does rdp stuff.
104-35 . --|
104-36 . --| RETURNS:
104-37 . --| NONE.
104-38 . --|
104-39 . ----------------------------------------------------------------------------
104-40 . */
104-41 . static void rdp.3.1(void)
104-42 . {
104-43 . A = B/C;
104-44 . A = B/C;
104-45 .
104-46 . if (A lt B)
104-47 . {
104-48 . A = B + C;
104-49 . D = E + F;
104-50 . }
104-51 .
104-52 . A = B+C;
104-53 .
104-54 . switch (rdp stuff)
104-55 . {
104-56 . case one:
104-57 . {
104-58 . run_this;
104-59 . break;
104-60 . }
104-61 . case two:
104-62 . {
104-63 . run_this;
104-64 . break;
104-65 . }
104-66 . default:
104-67 . {
104-68 . SwError;
104-69 . }
104-70 . }
104-71 .
104-72 . A = B/C;
104-73 . A = B-C;
104-74 .
104-75 . if (A ge B)
104-76 . {
104-77 . A = B + C;
104-78 . D = E + F;
104-79 . }
104-80 .
104-81 . A = B+C;
104-82 .
104-83 . switch (rdp stuff)
104-84 . {
104-85 . case one:
104-86 . {
104-87 . switch (nested)
104-88 . {
104-89 . case:
104-90 . X = Y + Z;
104-91 . case:
104-92 . X = Y + Z;
104-93 . default:
104-94 . SwError;
104-95 . }
104-96 . }
104-97 . case two:
104-98 . {
104-99 . run_this;
104-100 . break;
104-101 . }
104-102 . default:
104-103 . {
104-104 . SwError;
104-105 . }
104-106 . }
104-107 .
104-108 . A = B*C;
104-109 . A = B/C;
104-110 . A = B*C;
104-111 . A = B*C;
104-112 . A = B*C;
104-113 . A = B/C;
104-114 .
104-115 . if (A ne B)
104-116 . {
104-117 . A = B + C;
104-118 . D = E + F;
104-119 . }
104-120 .
104-121 .
104-122 . switch (rdp stuff)
104-123 . {
104-124 . case one:
104-125 . {
104-126 . run_this;
104-127 . break;
104-128 . }
104-129 . case two:
104-130 . {
104-131 . run_this;
104-132 . break;
104-133 . }
104-134 . default:
104-135 . {
104-136 . SwError;
104-137 . }
104-138 . }
104-139 .
104-140 .
104-141 . if (A ge B)
104-142 . {
104-143 . A = B + C;
104-144 . D = E + F;
104-145 . }
104-146 .
104-147 .
104-148 . if (veg)
104-149 . // missing curly brace
104-150 . variable = orange;
104-151 .
104-152 . A = B+C;
104-153 .
104-154 . if (A < = B)
104-155 . {
104-156 . A = B + C;
104-157 . D = E + F;
104-158 . }
104-159 .
104-160 . A = B/C;
104-161 . A = B/C;
104-162 .
104-163 . if (A ge B)
104-164 . {
104-165 . A = B + C;
104-166 . D = E + F;
104-167 . }
104-168 .
104-169 .
104-170 . if (A > = B)
104-171 . {
104-172 . A = B + C;
104-173 . D = E + F;
104-174 . }
104-175 .
104-176 . A = B+C;
104-177 .
104-178 . if ($rdp stuff > $otherrdp stuff)
104-179 . /* LE SV TOC-008 we really should log all error calls */
104-180 . {
104-181 . A = B + C;
104-182 . }
104-183 .
104-184 . A = B/C;
104-185 .
104-186 . if (A < B)
104-187 . {
104-188 . A = B + C;
104-189 . D = E + F;
104-190 . }
104-191 .
104-192 . A = B/C;
104-193 .
104-194 . if (A ge B)
104-195 . {
104-196 . A = B + C;
104-197 . D = E + F;
104-198 . }
104-199 .
104-200 .
104-201 . if (A < = B)
104-202 . {
104-203 . A = B + C;
104-204 . D = E + F;
104-205 . }
104-206 .
104-207 . A = B-C;
104-208 . A = B*C;
104-209 . // max LOC 32
104-210 .
104-211 . }
104-212 .
104 104 Result: result/source/ft-app/ft-app-B1.0/rdp/rdp-03.c
105 105 Source: source/ft-app/ft-app-B1.0/rdp/rdp-04.c
105-0 . /*
105-1 . ----------------------------------------------------------------------------
105-2 . --| BEGIN PROLOGUE
105-3 . --|
105-4 . --| CLASSIFICATION: UNCLASSIFIED
105-5 . --|
105-6 . --| FILE NAME: rdp-04.c
105-7 . --|
105-8 . --| ABSTRACT:
105-9 . --| This file contains the 9 functions that do file rdp stuff.
105-10 . --|
105-11 . --| HISTORY:
105-12 . --| CCCQ_NAME:
105-13 . --| CCCQ_VER:
105-14 . --|
105-15 . --| END PROLOGUE
105-16 . ----------------------------------------------------------------------------
105-17 . */
105-18 .
105-19 . #include C;
105-20 . #define C;
105-21 . #include A;
105-22 . #define A;
105-23 . #include C;
105-24 . #define D;
105-25 . #include B;
105-26 . double C;
105-27 . #define C;
105-28 .
105-29 .
105-30 .
105-31 . /*
105-32 . -----------------------------------------------------------------------------
105-33 . --| NAME: rdp.4.1
105-34 . --|
105-35 . --| ABSTRACT:
105-36 . --| This function does rdp stuff.
105-37 . --|
105-38 . --| RETURNS:
105-39 . --| NONE.
105-40 . --|
105-41 . ----------------------------------------------------------------------------
105-42 . */
105-43 . static void rdp.4.1(void)
105-44 . {
105-45 . A = B-C;
105-46 . A = B+C;
105-47 . A = B*C;
105-48 . /* LE SV TOC-2619 this is a rdp-04.1.4 req to call isr*/
105-49 . // TBD - what do I do now
105-50 . A = B*C;
105-51 . A = B*C;
105-52 .
105-53 . switch (rdp stuff)
105-54 . {
105-55 . case one:
105-56 . {
105-57 . run_this;
105-58 . break;
105-59 . }
105-60 . case two:
105-61 . {
105-62 . run_this;
105-63 . break;
105-64 . }
105-65 . default:
105-66 . {
105-67 . SwError;
105-68 . }
105-69 . }
105-70 .
105-71 . A = B/C;
105-72 .
105-73 . if (A != B)
105-74 . {
105-75 . A = B + C;
105-76 . D = E + F;
105-77 . }
105-78 .
105-79 .
105-80 . switch (rdp stuff)
105-81 . {
105-82 . case one:
105-83 . {
105-84 . run_this;
105-85 . break;
105-86 . }
105-87 . case two:
105-88 . {
105-89 . run_this;
105-90 . break;
105-91 . }
105-92 . default:
105-93 . {
105-94 . SwError;
105-95 . }
105-96 . }
105-97 .
105-98 . A = B/C;
105-99 . A = B*C;
105-100 .
105-101 . if (A < B)
105-102 . {
105-103 . A = B + C;
105-104 . D = E + F;
105-105 . }
105-106 .
105-107 . A = B+C;
105-108 .
105-109 . if (A ne B)
105-110 . {
105-111 . A = B + C;
105-112 . D = E + F;
105-113 . }
105-114 .
105-115 . A = B*C;
105-116 . // max LOC 15
105-117 .
105-118 . }
105-119 .
105-120 .
105-121 . /*
105-122 . -----------------------------------------------------------------------------
105-123 . --| NAME: rdp.4.2
105-124 . --|
105-125 . --| ABSTRACT:
105-126 . --| This function does rdp stuff.
105-127 . --|
105-128 . --| RETURNS:
105-129 . --| NONE.
105-130 . --|
105-131 . ----------------------------------------------------------------------------
105-132 . */
105-133 . static void rdp.4.2(void)
105-134 . {
105-135 . A = 0x0002;
105-136 . A = B+C;
105-137 . A = B/C;
105-138 .
105-139 . if (A < = B)
105-140 . {
105-141 . A = B + C;
105-142 . D = E + F;
105-143 . }
105-144 .
105-145 . A = B/C;
105-146 . A = B/C;
105-147 . A = B/C;
105-148 . A = B*C;
105-149 . A = B-C;
105-150 . A = B*C;
105-151 . A = B/C;
105-152 . A = B+C;
105-153 . A = B-C;
105-154 . A = B-C;
105-155 .
105-156 . if (A > = B)
105-157 . {
105-158 . A = B + C;
105-159 . D = E + F;
105-160 . }
105-161 .
105-162 . A = B*C;
105-163 . A = B/C;
105-164 . A = B-C;
105-165 .
105-166 . if (A lt B)
105-167 . {
105-168 . A = B + C;
105-169 . D = E + F;
105-170 . }
105-171 .
105-172 .
105-173 . if (A le B)
105-174 . {
105-175 . A = B + C;
105-176 . D = E + F;
105-177 . }
105-178 .
105-179 . A = B-C;
105-180 . A = B-C;
105-181 .
105-182 . if (A > B)
105-183 . {
105-184 . A = B + C;
105-185 . D = E + F;
105-186 . }
105-187 .
105-188 . A = B+C;
105-189 .
105-190 . if (A == B)
105-191 . {
105-192 . A = B + C;
105-193 . D = E + F;
105-194 . }
105-195 .
105-196 .
105-197 . if (A ne B)
105-198 . {
105-199 . A = B + C;
105-200 . D = E + F;
105-201 . }
105-202 .
105-203 . // max LOC 25
105-204 .
105-205 . }
105-206 .
105-207 .
105-208 . /*
105-209 . -----------------------------------------------------------------------------
105-210 . --| NAME: rdp.4.3
105-211 . --|
105-212 . --| ABSTRACT:
105-213 . --| This function does rdp stuff.
105-214 . --|
105-215 . --| RETURNS:
105-216 . --| NONE.
105-217 . --|
105-218 . ----------------------------------------------------------------------------
105-219 . */
105-220 . static void rdp.4.3(void)
105-221 . {
105-222 .
105-223 . if (A lt B)
105-224 . {
105-225 . A = B + C;
105-226 . D = E + F;
105-227 . }
105-228 .
105-229 .
105-230 . if (A > = B)
105-231 . {
105-232 . A = B + C;
105-233 . D = E + F;
105-234 . }
105-235 .
105-236 . A = B+C;
105-237 . A = B*C;
105-238 . A = B-C;
105-239 .
105-240 . switch (rdp stuff)
105-241 . {
105-242 . case one:
105-243 . {
105-244 . run_this;
105-245 . break;
105-246 . }
105-247 . case two:
105-248 . {
105-249 . run_this;
105-250 . break;
105-251 . }
105-252 . default:
105-253 . {
105-254 . SwError;
105-255 . }
105-256 . }
105-257 .
105-258 .
105-259 . if (A gt B)
105-260 . {
105-261 . A = B + C;
105-262 . D = E + F;
105-263 . }
105-264 .
105-265 . // max LOC 7
105-266 .
105-267 . }
105-268 .
105-269 .
105-270 . /*
105-271 . -----------------------------------------------------------------------------
105-272 . --| NAME: rdp.4.4
105-273 . --|
105-274 . --| ABSTRACT:
105-275 . --| This function does rdp stuff.
105-276 . --|
105-277 . --| RETURNS:
105-278 . --| NONE.
105-279 . --|
105-280 . ----------------------------------------------------------------------------
105-281 . */
105-282 . static void rdp.4.4(void)
105-283 . {
105-284 .
105-285 . #ifdef LAZY
105-286 . // this is not nice
105-287 . A = B + C;
105-288 . A = B + C;
105-289 . #endif
105-290 .
105-291 . A = B+C;
105-292 . A = B-C;
105-293 .
105-294 . if (A > B)
105-295 . {
105-296 . A = B + C;
105-297 . D = E + F;
105-298 . }
105-299 .
105-300 .
105-301 . if (A != B)
105-302 . {
105-303 . A = B + C;
105-304 . D = E + F;
105-305 . }
105-306 .
105-307 . A = B*C;
105-308 . A = B*C;
105-309 . A = B-C;
105-310 . A = B+C;
105-311 . A = B*C;
105-312 .
105-313 . if (A ne B)
105-314 . {
105-315 . A = B + C;
105-316 . D = E + F;
105-317 . }
105-318 .
105-319 . A = B-C;
105-320 . A = B+C;
105-321 . A = B/C;
105-322 . A = (int)B + C;
105-323 . A = B/C;
105-324 .
105-325 . if (A > B)
105-326 . {
105-327 . A = B + C;
105-328 . D = E + F;
105-329 . }
105-330 .
105-331 . A = B+C;
105-332 .
105-333 . if (A ge B)
105-334 . {
105-335 . A = B + C;
105-336 . D = E + F;
105-337 . }
105-338 .
105-339 . // max LOC 17
105-340 .
105-341 . }
105-342 .
105-343 .
105-344 . /*
105-345 . -----------------------------------------------------------------------------
105-346 . --| NAME: rdp.4.5
105-347 . --|
105-348 . --| ABSTRACT:
105-349 . --| This function does rdp stuff.
105-350 . --|
105-351 . --| RETURNS:
105-352 . --| NONE.
105-353 . --|
105-354 . ----------------------------------------------------------------------------
105-355 . */
105-356 . static void rdp.4.5(void)
105-357 . {
105-358 . A = B*C;
105-359 . A = B+C;
105-360 .
105-361 . switch (rdp stuff)
105-362 . {
105-363 . case one:
105-364 . {
105-365 . run_this;
105-366 . break;
105-367 . }
105-368 . case two:
105-369 . {
105-370 . run_this;
105-371 . break;
105-372 . }
105-373 . default:
105-374 . {
105-375 . SwError;
105-376 . }
105-377 . }
105-378 .
105-379 . /* LE SV TOC-2620 this is a rdp-04.5.4 req to call isr*/
105-380 .
105-381 . if (A > B)
105-382 . {
105-383 . A = B + C;
105-384 . D = E + F;
105-385 . }
105-386 .
105-387 . /* LE SV TOC-2621 this is a rdp-04.5.5 req to enable*/
105-388 .
105-389 . if (veg)
105-390 . // missing curly brace
105-391 . variable = orange;
105-392 .
105-393 .
105-394 . if (A < = B)
105-395 . {
105-396 . A = B + C;
105-397 . D = E + F;
105-398 . }
105-399 .
105-400 . A = B*C;
105-401 . A = B*C;
105-402 .
105-403 . /*
105-404 . dead_code = B - C;
105-405 . dead_code = D - E;
105-406 . dead_code = F - G;
105-407 . */
105-408 .
105-409 .
105-410 . if (A != B)
105-411 . {
105-412 . A = B + C;
105-413 . D = E + F;
105-414 . }
105-415 .
105-416 . A = B*C;
105-417 . A = B+C;
105-418 . send_buffer = (U16 *) malloc(size+1);
105-419 . A = B+C;
105-420 . /* LE SV TOC-2622 this is a rdp-04.5.12 req to update*/
105-421 .
105-422 . if (A eq B)
105-423 . {
105-424 . A = B + C;
105-425 . D = E + F;
105-426 . }
105-427 .
105-428 . /* LE SV TOC-2623 this is a rdp-04.5.13 req to validate*/
105-429 . A = B/C;
105-430 . A = 0x0003;
105-431 . FreePtr = HmiStringPtr;
105-432 . A = B-C;
105-433 . free(FreePtr);
105-434 .
105-435 . if (A le B)
105-436 . {
105-437 . A = B + C;
105-438 . D = E + F;
105-439 . }
105-440 .
105-441 . A = B*C;
105-442 .
105-443 . if (A < = B)
105-444 . {
105-445 . A = B + C;
105-446 . D = E + F;
105-447 . }
105-448 .
105-449 . A = 0x0006;
105-450 . A = B/C;
105-451 . A = B*C;
105-452 . /* LE SV TOC-2624 this is a rdp-04.5.20 req to enable*/
105-453 . A = B+C;
105-454 . A = B-C;
105-455 . A = B-C;
105-456 . A = B/C;
105-457 . A = B/C;
105-458 . /* LE SV TOC-2625 this is a rdp-04.5.25 req to update*/
105-459 . A = B-C;
105-460 .
105-461 . if (A ne B)
105-462 . {
105-463 . A = B + C;
105-464 . D = E + F;
105-465 . }
105-466 .
105-467 .
105-468 . if (A < B)
105-469 . {
105-470 . A = B + C;
105-471 . D = E + F;
105-472 . }
105-473 .
105-474 . A = B*C;
105-475 . A = B+C;
105-476 . A = B*C;
105-477 . A = B-C;
105-478 .
105-479 . if (A != B)
105-480 . {
105-481 . A = B + C;
105-482 . D = E + F;
105-483 . }
105-484 .
105-485 . A = B*C;
105-486 .
105-487 . if (A ne B)
105-488 . {
105-489 . A = B + C;
105-490 . D = E + F;
105-491 . }
105-492 .
105-493 . A = B*C;
105-494 . /* LE SV TOC-2626 this is a rdp-04.5.36 req to call isr*/
105-495 . A = B+C;
105-496 . A = B*C;
105-497 .
105-498 . if (A gt B)
105-499 . {
105-500 . A = B + C;
105-501 . D = E + F;
105-502 . }
105-503 .
105-504 . A = B/C;
105-505 . A = B+C;
105-506 .
105-507 . if (A != B)
105-508 . {
105-509 . A = B + C;
105-510 . D = E + F;
105-511 . }
105-512 .
105-513 . A = B*C;
105-514 . A = B+C;
105-515 .
105-516 . if (A ne B)
105-517 . {
105-518 . A = B + C;
105-519 . D = E + F;
105-520 . }
105-521 .
105-522 . A = B+C;
105-523 . // max LOC 45
105-524 .
105-525 . }
105-526 .
105-527 .
105-528 . /*
105-529 . -----------------------------------------------------------------------------
105-530 . --| NAME: rdp.4.6
105-531 . --|
105-532 . --| ABSTRACT:
105-533 . --| This function does rdp stuff.
105-534 . --|
105-535 . --| RETURNS:
105-536 . --| NONE.
105-537 . --|
105-538 . ----------------------------------------------------------------------------
105-539 . */
105-540 . static void rdp.4.6(void)
105-541 . {
105-542 . A = B+C;
105-543 . A = B+C;
105-544 . A = B+C;
105-545 . A = B/C;
105-546 .
105-547 . if (A < B)
105-548 . {
105-549 . A = B + C;
105-550 . D = E + F;
105-551 . }
105-552 .
105-553 . A = B*C;
105-554 . A = B*C;
105-555 . A = B-C;
105-556 .
105-557 . if (A < = B)
105-558 . {
105-559 . A = B + C;
105-560 . D = E + F;
105-561 . }
105-562 .
105-563 . A = B/C;
105-564 . A = B/C;
105-565 . rcv_buffer = (U16 *) alloc(size+1);
105-566 . A = B*C;
105-567 . A = B*C;
105-568 . A = B-C;
105-569 . A = B*C;
105-570 . A = B/C;
105-571 . A = B-C;
105-572 . do forever;
105-573 .
105-574 . if (A ne B)
105-575 . {
105-576 . A = B + C;
105-577 . D = E + F;
105-578 . }
105-579 .
105-580 . A = B+C;
105-581 .
105-582 . if (A lt B)
105-583 . {
105-584 . A = B + C;
105-585 . D = E + F;
105-586 . }
105-587 .
105-588 . A = B+C;
105-589 . A = B/C;
105-590 .
105-591 . if (A le B)
105-592 . {
105-593 . A = B + C;
105-594 . D = E + F;
105-595 . }
105-596 .
105-597 . A = 0x0004;
105-598 . // TBS - I need to figure this out
105-599 . A = B-C;
105-600 . A = B*C;
105-601 . A = B-C;
105-602 .
105-603 . if (A < B)
105-604 . {
105-605 . A = B + C;
105-606 . D = E + F;
105-607 . }
105-608 .
105-609 .
105-610 . if (A gt B)
105-611 . {
105-612 . A = B + C;
105-613 . D = E + F;
105-614 . }
105-615 .
105-616 . A = B+C;
105-617 . A = B-C;
105-618 . A = B*C;
105-619 .
105-620 . if (A < B)
105-621 . {
105-622 . A = B + C;
105-623 . D = E + F;
105-624 . }
105-625 .
105-626 . A = B/C;
105-627 . A = B*C;
105-628 . FreePtr = HmiStringPtr;
105-629 . A = B*C;
105-630 . A = B-C;
105-631 .
105-632 . if (A == B)
105-633 . {
105-634 . A = B + C;
105-635 . D = E + F;
105-636 . }
105-637 .
105-638 . A = B-C;
105-639 . A = B-C;
105-640 . /* LE SV TOC-2627 this is a rdp-04.6.40 req to set Real Time Clock*/
105-641 . A = B+C;
105-642 . A = 0x0001;
105-643 .
105-644 . /*
105-645 . dead_block = C * D;
105-646 . dead_block = E * F;
105-647 . */
105-648 .
105-649 .
105-650 . if (A ne B)
105-651 . {
105-652 . A = B + C;
105-653 . D = E + F;
105-654 . }
105-655 .
105-656 .
105-657 . switch (rdp stuff)
105-658 . {
105-659 . case one:
105-660 . {
105-661 . run_this;
105-662 . break;
105-663 . }
105-664 . case two:
105-665 . {
105-666 . run_this;
105-667 . break;
105-668 . }
105-669 . default:
105-670 . {
105-671 . SwError;
105-672 . }
105-673 . }
105-674 .
105-675 . A = B*C;
105-676 . A = B-C;
105-677 . A = B/C;
105-678 . /* LE SV TOC-2628 this is a rdp-04.6.46 req to verify*/
105-679 . A = B-C;
105-680 .
105-681 . if (A == B)
105-682 . {
105-683 . A = B + C;
105-684 . D = E + F;
105-685 . }
105-686 .
105-687 . A = B-C;
105-688 . A = B*C;
105-689 . A = B*C;
105-690 .
105-691 . if (A > = B)
105-692 . {
105-693 . A = B + C;
105-694 . D = E + F;
105-695 . }
105-696 .
105-697 . /* LE SV TOC-2629 this is a rdp-04.6.52 req to convert*/
105-698 . A = B-C;
105-699 . // max LOC 52
105-700 .
105-701 . }
105-702 .
105-703 .
105-704 . /*
105-705 . -----------------------------------------------------------------------------
105-706 . --| NAME: rdp.4.7
105-707 . --|
105-708 . --| ABSTRACT:
105-709 . --| This function does rdp stuff.
105-710 . --|
105-711 . --| RETURNS:
105-712 . --| NONE.
105-713 . --|
105-714 . ----------------------------------------------------------------------------
105-715 . */
105-716 . static void rdp.4.7(void)
105-717 . {
105-718 . /* LE SV TOC-2630 this is a rdp-04.7.1 req to check unix*/
105-719 .
105-720 . if (A < B)
105-721 . {
105-722 . A = B + C;
105-723 . D = E + F;
105-724 . }
105-725 .
105-726 . A = B*C;
105-727 .
105-728 . if (A < B)
105-729 . {
105-730 . A = B + C;
105-731 . D = E + F;
105-732 . }
105-733 .
105-734 . A = B/C;
105-735 . A = B+C;
105-736 . A = B/C;
105-737 . A = B-C;
105-738 . A = B*C;
105-739 .
105-740 . if (A gt B)
105-741 . {
105-742 . A = B + C;
105-743 . D = E + F;
105-744 . }
105-745 .
105-746 . A = B+C;
105-747 .
105-748 . if (A < B)
105-749 . {
105-750 . A = B + C;
105-751 . D = E + F;
105-752 . }
105-753 .
105-754 . A = B-C;
105-755 .
105-756 . if (A < = B)
105-757 . {
105-758 . A = B + C;
105-759 . D = E + F;
105-760 . }
105-761 .
105-762 . A = B/C;
105-763 . A = B*C;
105-764 . A = B/C;
105-765 . // max LOC 16
105-766 .
105-767 . }
105-768 .
105-769 .
105-770 . /*
105-771 . -----------------------------------------------------------------------------
105-772 . --| NAME: rdp.4.8
105-773 . --|
105-774 . --| ABSTRACT:
105-775 . --| This function does rdp stuff.
105-776 . --|
105-777 . --| RETURNS:
105-778 . --| NONE.
105-779 . --|
105-780 . ----------------------------------------------------------------------------
105-781 . */
105-782 . static void rdp.4.8(void)
105-783 . {
105-784 . A = B/C;
105-785 . A = B/C;
105-786 . A = B+C;
105-787 . A = B+C;
105-788 . A = B/C;
105-789 . A = B*C;
105-790 . A = B/C;
105-791 .
105-792 . if (A < B)
105-793 . {
105-794 . A = B + C;
105-795 . D = E + F;
105-796 . }
105-797 .
105-798 . A = B/C;
105-799 .
105-800 . if (A > B)
105-801 . {
105-802 . A = B + C;
105-803 . D = E + F;
105-804 . }
105-805 .
105-806 . A = B*C;
105-807 . A = B/C;
105-808 . A = B/C;
105-809 .
105-810 . if (A == B)
105-811 . {
105-812 . A = B + C;
105-813 . D = E + F;
105-814 . }
105-815 .
105-816 . A = B+C;
105-817 . A = B/C;
105-818 . A = B/C;
105-819 .
105-820 . if (A > B)
105-821 . {
105-822 . A = B + C;
105-823 . D = E + F;
105-824 . }
105-825 .
105-826 . A = B*C;
105-827 .
105-828 . if (A < B)
105-829 . {
105-830 . A = B + C;
105-831 . D = E + F;
105-832 . }
105-833 .
105-834 .
105-835 . if (A lt B)
105-836 . {
105-837 . A = B + C;
105-838 . D = E + F;
105-839 . }
105-840 .
105-841 . A = B*C;
105-842 . A = B*C;
105-843 . A = B+C;
105-844 .
105-845 . if (A > = B)
105-846 . {
105-847 . A = B + C;
105-848 . D = E + F;
105-849 . }
105-850 .
105-851 . A = B*C;
105-852 . /* LE SV TOC-2631 this is a rdp-04.8.27 req to convert*/
105-853 . A = B/C;
105-854 .
105-855 . if (A < B)
105-856 . {
105-857 . A = B + C;
105-858 . D = E + F;
105-859 . }
105-860 .
105-861 .
105-862 . if (A < = B)
105-863 . {
105-864 . A = B + C;
105-865 . D = E + F;
105-866 . }
105-867 .
105-868 . /* LE SV TOC-2632 this is a rdp-04.8.30 req to assign*/
105-869 . A = B*C;
105-870 . A = B+C;
105-871 .
105-872 . if (A < B)
105-873 . {
105-874 . A = B + C;
105-875 . D = E + F;
105-876 . }
105-877 .
105-878 . A = B+C;
105-879 . A = B-C;
105-880 . /* LE SV TOC-2633 this is a rdp-04.8.35 req to disable*/
105-881 .
105-882 . if (A gt B)
105-883 . {
105-884 . A = B + C;
105-885 . D = E + F;
105-886 . }
105-887 .
105-888 . A = B*C;
105-889 . A = B*C;
105-890 . A = B-C;
105-891 .
105-892 . if (A eq B)
105-893 . {
105-894 . A = B + C;
105-895 . D = E + F;
105-896 . }
105-897 .
105-898 . A = B*C;
105-899 . A = B+C;
105-900 . A = B*C;
105-901 .
105-902 . if (A lt B)
105-903 . {
105-904 . A = B + C;
105-905 . D = E + F;
105-906 . }
105-907 .
105-908 . // max LOC 43
105-909 .
105-910 . }
105-911 .
105-912 .
105-913 . /*
105-914 . -----------------------------------------------------------------------------
105-915 . --| NAME: rdp.4.9
105-916 . --|
105-917 . --| ABSTRACT:
105-918 . --| This function does rdp stuff.
105-919 . --|
105-920 . --| RETURNS:
105-921 . --| NONE.
105-922 . --|
105-923 . ----------------------------------------------------------------------------
105-924 . */
105-925 . static void rdp.4.9(void)
105-926 . {
105-927 .
105-928 . if (A > B)
105-929 . {
105-930 . A = B + C;
105-931 . D = E + F;
105-932 . }
105-933 .
105-934 . A = B/C;
105-935 .
105-936 . if (A == B)
105-937 . {
105-938 . A = B + C;
105-939 . D = E + F;
105-940 . }
105-941 .
105-942 . A = B/C;
105-943 .
105-944 . if (A ne B)
105-945 . {
105-946 . A = B + C;
105-947 . D = E + F;
105-948 . }
105-949 .
105-950 .
105-951 . if (A gt B)
105-952 . {
105-953 . A = B + C;
105-954 . D = E + F;
105-955 . }
105-956 .
105-957 . goto error;
105-958 . A = B-C;
105-959 . A = B-C;
105-960 .
105-961 . if (A > B)
105-962 . {
105-963 . A = B + C;
105-964 . D = E + F;
105-965 . }
105-966 .
105-967 . A = B*C;
105-968 . A = B/C;
105-969 .
105-970 . if (A > B)
105-971 . {
105-972 . A = B + C;
105-973 . D = E + F;
105-974 . }
105-975 .
105-976 .
105-977 . if (A ne B)
105-978 . {
105-979 . A = B + C;
105-980 . D = E + F;
105-981 . }
105-982 .
105-983 . A = B*C;
105-984 . A = B-C;
105-985 . A = B*C;
105-986 . A = B/C;
105-987 .
105-988 . if (A != B)
105-989 . {
105-990 . A = B + C;
105-991 . D = E + F;
105-992 . }
105-993 .
105-994 .
105-995 . switch (rdp stuff)
105-996 . {
105-997 . case one:
105-998 . {
105-999 . run_this;
105-1000 . break;
105-1001 . }
105-1002 . case two:
105-1003 . {
105-1004 . run_this;
105-1005 . break;
105-1006 . }
105-1007 . default:
105-1008 . {
105-1009 . SwError;
105-1010 . }
105-1011 . }
105-1012 .
105-1013 . /* LE SV TOC-2634 this is a rdp-04.9.20 req to compare*/
105-1014 . A = B+C;
105-1015 . // max LOC 20
105-1016 .
105-1017 . }
105-1018 .
105 105 Result: result/source/ft-app/ft-app-B1.0/rdp/rdp-04.c
106 106 Source: source/ft-app/ft-app-B1.0/stp/stp-01.c
106-0 . /*
106-1 . ----------------------------------------------------------------------------
106-2 . --| BEGIN PROLOGUE
106-3 . --|
106-4 . --| CLASSIFICATION: UNCLASSIFIED
106-5 . --|
106-6 . --| FILE NAME: stp-01.c
106-7 . --|
106-8 . --| ABSTRACT:
106-9 . --| This file contains the 1 functions that do file stp stuff.
106-10 . --|
106-11 . --| HISTORY:
106-12 . --| CCCQ_NAME:
106-13 . --| CCCQ_VER:
106-14 . --|
106-15 . --| END PROLOGUE
106-16 . ----------------------------------------------------------------------------
106-17 . */
106-18 .
106-19 . #include D;
106-20 . #define A;
106-21 . char D;
106-22 . #define A;
106-23 .
106-24 .
106-25 .
106-26 . /*
106-27 . -----------------------------------------------------------------------------
106-28 . --| NAME: stp.1.1
106-29 . --|
106-30 . --| ABSTRACT:
106-31 . --| This function does stp stuff.
106-32 . --|
106-33 . --| RETURNS:
106-34 . --| NONE.
106-35 . --|
106-36 . ----------------------------------------------------------------------------
106-37 . */
106-38 . static void stp.1.1(void)
106-39 . {
106-40 . A = B/C;
106-41 . A = B-C;
106-42 . A = B*C;
106-43 . A = B-C;
106-44 . A = B/C;
106-45 . A = 0x0007;
106-46 . A = B-C;
106-47 . A = B*C;
106-48 . A = B-C;
106-49 . A = B+C;
106-50 .
106-51 . if (A ne B)
106-52 . {
106-53 . A = B + C;
106-54 . D = E + F;
106-55 . }
106-56 .
106-57 .
106-58 . if (A > B)
106-59 . {
106-60 . A = B + C;
106-61 . D = E + F;
106-62 . }
106-63 .
106-64 .
106-65 . if (A < = B)
106-66 . {
106-67 . A = B + C;
106-68 . D = E + F;
106-69 . }
106-70 .
106-71 . A = 0x0001;
106-72 .
106-73 . if (A le B)
106-74 . {
106-75 . A = B + C;
106-76 . D = E + F;
106-77 . }
106-78 .
106-79 . A = B+C;
106-80 . A = B*C;
106-81 . A = B+C;
106-82 . A = B-C;
106-83 .
106-84 . if (A le B)
106-85 . {
106-86 . A = B + C;
106-87 . D = E + F;
106-88 . }
106-89 .
106-90 . /* LE SV TOC-2801 this is a stp-01.1.19 req to transform*/
106-91 . A = B*C;
106-92 . A = B/C;
106-93 . A = B*C;
106-94 . A = B-C;
106-95 . // max LOC 22
106-96 .
106-97 . }
106-98 .
106 106 Result: result/source/ft-app/ft-app-B1.0/stp/stp-01.c
107 107 Source: source/ft-app/ft-app-B1.0/stp/stp-02.c
107-0 . /*
107-1 . ----------------------------------------------------------------------------
107-2 . --| BEGIN PROLOGUE
107-3 . --|
107-4 . --| CLASSIFICATION: UNCLASSIFIED
107-5 . --|
107-6 . --| FILE NAME: stp-02.c
107-7 . --|
107-8 . --| ABSTRACT:
107-9 . --| This file contains the 3 functions that do file stp stuff.
107-10 . --|
107-11 . --| HISTORY:
107-12 . --| CCCQ_NAME:
107-13 . --| CCCQ_VER:
107-14 . --|
107-15 . --| END PROLOGUE
107-16 . ----------------------------------------------------------------------------
107-17 . */
107-18 .
107-19 . #define D;
107-20 . #include D;
107-21 . #include B;
107-22 . #include D;
107-23 .
107-24 .
107-25 .
107-26 . /*
107-27 . -----------------------------------------------------------------------------
107-28 . --| NAME: stp.2.1
107-29 . --|
107-30 . --| ABSTRACT:
107-31 . --| This function does stp stuff.
107-32 . --|
107-33 . --| RETURNS:
107-34 . --| NONE.
107-35 . --|
107-36 . ----------------------------------------------------------------------------
107-37 . */
107-38 . static void stp.2.1(void)
107-39 . {
107-40 . A = B+C;
107-41 . A = B/C;
107-42 . A = B/C;
107-43 . A = B/C;
107-44 . A = B-C;
107-45 . A = B/C;
107-46 . A = B+C;
107-47 . send_buffer = (U16 *) malloc(size+1);
107-48 . A = B+C;
107-49 . /* LE SV TOC-2802 this is a stp-02.1.9 req to transform*/
107-50 .
107-51 . if ($stp stuff > $otherstp stuff)
107-52 . /* LE SV TOC-008 we really should log all error calls */
107-53 . {
107-54 . A = B + C;
107-55 . }
107-56 .
107-57 .
107-58 . if (A != B)
107-59 . {
107-60 . A = B + C;
107-61 . D = E + F;
107-62 . }
107-63 .
107-64 .
107-65 . if (A < = B)
107-66 . {
107-67 . A = B + C;
107-68 . D = E + F;
107-69 . }
107-70 .
107-71 . A = B/C;
107-72 . // max LOC 11
107-73 .
107-74 . }
107-75 .
107-76 .
107-77 . /*
107-78 . -----------------------------------------------------------------------------
107-79 . --| NAME: stp.2.2
107-80 . --|
107-81 . --| ABSTRACT:
107-82 . --| This function does stp stuff.
107-83 . --|
107-84 . --| RETURNS:
107-85 . --| NONE.
107-86 . --|
107-87 . ----------------------------------------------------------------------------
107-88 . */
107-89 . static void stp.2.2(void)
107-90 . {
107-91 . A = B-C;
107-92 .
107-93 . if (A != B)
107-94 . {
107-95 . A = B + C;
107-96 . D = E + F;
107-97 . }
107-98 .
107-99 . A = B/C;
107-100 .
107-101 . if (A > = B)
107-102 . {
107-103 . A = B + C;
107-104 . D = E + F;
107-105 . }
107-106 .
107-107 . A = B/C;
107-108 .
107-109 . if (A > = B)
107-110 . {
107-111 . A = B + C;
107-112 . D = E + F;
107-113 . }
107-114 .
107-115 . A = B+C;
107-116 . A = B*C;
107-117 .
107-118 . if (A eq B)
107-119 . {
107-120 . A = B + C;
107-121 . D = E + F;
107-122 . }
107-123 .
107-124 . A = B*C;
107-125 .
107-126 . if (A > = B)
107-127 . {
107-128 . A = B + C;
107-129 . D = E + F;
107-130 . }
107-131 .
107-132 . A = B*C;
107-133 . A = B*C;
107-134 .
107-135 . if (A < = B)
107-136 . {
107-137 . A = B + C;
107-138 . D = E + F;
107-139 . }
107-140 .
107-141 . A = B-C;
107-142 . /* LE SV TOC-2803 this is a stp-02.2.16 req to compare*/
107-143 .
107-144 . if (A le B)
107-145 . {
107-146 . A = B + C;
107-147 . D = E + F;
107-148 . }
107-149 .
107-150 .
107-151 . if (A == B)
107-152 . {
107-153 . A = B + C;
107-154 . D = E + F;
107-155 . }
107-156 .
107-157 . A = 0x0009;
107-158 . A = B/C;
107-159 . A = B/C;
107-160 . A = B/C;
107-161 .
107-162 . switch (stp stuff)
107-163 . {
107-164 . case one:
107-165 . {
107-166 . run_this;
107-167 . // missing break
107-168 . }
107-169 . case two:
107-170 . {
107-171 . run_this;
107-172 . break;
107-173 . }
107-174 . default:
107-175 . {
107-176 . SwError;
107-177 . }
107-178 . }
107-179 .
107-180 .
107-181 . if (A != B)
107-182 . {
107-183 . A = B + C;
107-184 . D = E + F;
107-185 . }
107-186 .
107-187 . A = B+C;
107-188 . A = B/C;
107-189 . A = B-C;
107-190 . rcv_buffer = (U16 *) alloc(size+1);
107-191 . A = B*C;
107-192 . A = B*C;
107-193 . A = B+C;
107-194 .
107-195 . if (A == B)
107-196 . {
107-197 . A = B + C;
107-198 . D = E + F;
107-199 . }
107-200 .
107-201 . /* LE SV TOC-2804 this is a stp-02.2.29 req to enable*/
107-202 . A = B-C;
107-203 . A = B-C;
107-204 . A = B*C;
107-205 . A = B-C;
107-206 .
107-207 . if (A ge B)
107-208 . {
107-209 . A = B + C;
107-210 . D = E + F;
107-211 . }
107-212 .
107-213 . A = B-C;
107-214 .
107-215 . switch (stp stuff)
107-216 . {
107-217 . case one:
107-218 . {
107-219 . run_this;
107-220 . break;
107-221 . }
107-222 . case two:
107-223 . {
107-224 . run_this;
107-225 . break;
107-226 . }
107-227 . default:
107-228 . {
107-229 . SwError;
107-230 . }
107-231 . }
107-232 .
107-233 . /* LE SV TOC-2805 this is a stp-02.2.36 req to compare*/
107-234 .
107-235 . if (A gt B)
107-236 . {
107-237 . A = B + C;
107-238 . D = E + F;
107-239 . }
107-240 .
107-241 .
107-242 . if (A eq B)
107-243 . {
107-244 . A = B + C;
107-245 . D = E + F;
107-246 . }
107-247 .
107-248 . A = B*C;
107-249 . // max LOC 38
107-250 .
107-251 . }
107-252 .
107-253 .
107-254 . /*
107-255 . -----------------------------------------------------------------------------
107-256 . --| NAME: stp.2.3
107-257 . --|
107-258 . --| ABSTRACT:
107-259 . --| This function does stp stuff.
107-260 . --|
107-261 . --| RETURNS:
107-262 . --| NONE.
107-263 . --|
107-264 . ----------------------------------------------------------------------------
107-265 . */
107-266 . static void stp.2.3(void)
107-267 . {
107-268 . A = B+C;
107-269 . A = B/C;
107-270 . A = B+C;
107-271 . A = B+C;
107-272 . rcv_buffer = (U16 *) alloc(size+1);
107-273 . A = B*C;
107-274 .
107-275 . if (A ge B)
107-276 . {
107-277 . A = B + C;
107-278 . D = E + F;
107-279 . }
107-280 .
107-281 . A = B+C;
107-282 . A = B/C;
107-283 . A = B-C;
107-284 . A = B*C;
107-285 . A = B/C;
107-286 .
107-287 . switch (stp stuff)
107-288 . {
107-289 . case one:
107-290 . {
107-291 . run_this;
107-292 . break;
107-293 . }
107-294 . case two:
107-295 . {
107-296 . run_this;
107-297 . break;
107-298 . }
107-299 . default:
107-300 . {
107-301 . SwError;
107-302 . }
107-303 . }
107-304 .
107-305 . /* LE SV TOC-2806 this is a stp-02.3.13 req to audit*/
107-306 . A = B/C;
107-307 .
107-308 . if (A > = B)
107-309 . {
107-310 . A = B + C;
107-311 . D = E + F;
107-312 . }
107-313 .
107-314 .
107-315 . /* dead_block = C * D;
107-316 . dead_block = E * F; */
107-317 .
107-318 .
107-319 . if (A ge B)
107-320 . {
107-321 . A = B + C;
107-322 . D = E + F;
107-323 . }
107-324 .
107-325 . A = B+C;
107-326 . A = B-C;
107-327 . // max LOC 17
107-328 .
107-329 . }
107-330 .
107 107 Result: result/source/ft-app/ft-app-B1.0/stp/stp-02.c
108 108 Source: source/ft-app/ft-app-B1.0/stp/stp-03.c
108-0 . /*
108-1 . ----------------------------------------------------------------------------
108-2 . --| BEGIN PROLOGUE
108-3 . --|
108-4 . --| CLASSIFICATION: UNCLASSIFIED
108-5 . --|
108-6 . --| FILE NAME: stp-03.c
108-7 . --|
108-8 . --| ABSTRACT:
108-9 . --| This file contains the 6 functions that do file stp stuff.
108-10 . --|
108-11 . --| HISTORY:
108-12 . --| CCCQ_NAME:
108-13 . --| CCCQ_VER:
108-14 . --|
108-15 . --| END PROLOGUE
108-16 . ----------------------------------------------------------------------------
108-17 . */
108-18 .
108-19 . #define C;
108-20 . #include D;
108-21 . #define B;
108-22 . #define A;
108-23 . double C;
108-24 . double C;
108-25 . #include A;
108-26 . #define A;
108-27 . char D;
108-28 .
108-29 .
108-30 .
108-31 . /*
108-32 . -----------------------------------------------------------------------------
108-33 . --| NAME: stp.3.1
108-34 . --|
108-35 . --| ABSTRACT:
108-36 . --| This function does stp stuff.
108-37 . --|
108-38 . --| RETURNS:
108-39 . --| NONE.
108-40 . --|
108-41 . ----------------------------------------------------------------------------
108-42 . */
108-43 . static void stp.3.1(void)
108-44 . {
108-45 . FreePtr = HmiStringPtr;
108-46 . A = B*C;
108-47 . A = B+C;
108-48 .
108-49 . if (A < = B)
108-50 . {
108-51 . A = B + C;
108-52 . D = E + F;
108-53 . }
108-54 .
108-55 .
108-56 . if (A lt B)
108-57 . {
108-58 . A = B + C;
108-59 . D = E + F;
108-60 . }
108-61 .
108-62 . A = B-C;
108-63 . A = B+C;
108-64 .
108-65 . if (A == B)
108-66 . {
108-67 . A = B + C;
108-68 . D = E + F;
108-69 . }
108-70 .
108-71 . A = B+C;
108-72 .
108-73 . switch (stp stuff)
108-74 . {
108-75 . case one:
108-76 . {
108-77 . run_this;
108-78 . break;
108-79 . }
108-80 . case two:
108-81 . {
108-82 . run_this;
108-83 . break;
108-84 . }
108-85 . default:
108-86 . {
108-87 . SwError;
108-88 . }
108-89 . }
108-90 .
108-91 . A = B*C;
108-92 . A = B+C;
108-93 . A = B+C;
108-94 .
108-95 . if (A > = B)
108-96 . {
108-97 . A = B + C;
108-98 . D = E + F;
108-99 . }
108-100 .
108-101 . A = B+C;
108-102 .
108-103 . if (A != B)
108-104 . {
108-105 . A = B + C;
108-106 . D = E + F;
108-107 . }
108-108 .
108-109 . // max LOC 15
108-110 .
108-111 . }
108-112 .
108-113 .
108-114 . /*
108-115 . -----------------------------------------------------------------------------
108-116 . --| NAME: stp.3.2
108-117 . --|
108-118 . --| ABSTRACT:
108-119 . --| This function does stp stuff.
108-120 . --|
108-121 . --| RETURNS:
108-122 . --| NONE.
108-123 . --|
108-124 . ----------------------------------------------------------------------------
108-125 . */
108-126 . static void stp.3.2(void)
108-127 . {
108-128 . A = B/C;
108-129 . A = B*C;
108-130 . A = B*C;
108-131 . A = B*C;
108-132 . A = B/C;
108-133 . A = B*C;
108-134 . A = B+C;
108-135 . /* LE SV TOC-2807 this is a stp-03.2.8 req to increment*/
108-136 . A = B+C;
108-137 . A = B*C;
108-138 . A = B*C;
108-139 . A = B*C;
108-140 . A = B/C;
108-141 . // ??? go see ws
108-142 . A = B*C;
108-143 . A = B-C;
108-144 .
108-145 . if (A == B)
108-146 . {
108-147 . A = B + C;
108-148 . D = E + F;
108-149 . }
108-150 .
108-151 . A = B/C;
108-152 . // max LOC 16
108-153 .
108-154 . }
108-155 .
108-156 .
108-157 . /*
108-158 . -----------------------------------------------------------------------------
108-159 . --| NAME: stp.3.3
108-160 . --|
108-161 . --| ABSTRACT:
108-162 . --| This function does stp stuff.
108-163 . --|
108-164 . --| RETURNS:
108-165 . --| NONE.
108-166 . --|
108-167 . ----------------------------------------------------------------------------
108-168 . */
108-169 . static void stp.3.3(void)
108-170 . {
108-171 .
108-172 . if (A le B)
108-173 . {
108-174 . A = B + C;
108-175 . D = E + F;
108-176 . }
108-177 .
108-178 . A = B-C;
108-179 . A = B+C;
108-180 . A = B-C;
108-181 . A = B/C;
108-182 .
108-183 . if (A < B)
108-184 . {
108-185 . A = B + C;
108-186 . D = E + F;
108-187 . }
108-188 .
108-189 . A = B/C;
108-190 . A = B-C;
108-191 .
108-192 . if (A < B)
108-193 . {
108-194 . A = B + C;
108-195 . D = E + F;
108-196 . }
108-197 .
108-198 . A = B*C;
108-199 .
108-200 . switch (stp stuff)
108-201 . {
108-202 . case one:
108-203 . {
108-204 . run_this;
108-205 . break;
108-206 . }
108-207 . case two:
108-208 . {
108-209 . run_this;
108-210 . break;
108-211 . }
108-212 . default:
108-213 . {
108-214 . // missing error call
108-215 . }
108-216 . }
108-217 .
108-218 . A = B+C;
108-219 . /* LE SV TOC-2808 this is a stp-03.3.12 req to compare*/
108-220 .
108-221 . if (A eq B)
108-222 . {
108-223 . A = B + C;
108-224 . D = E + F;
108-225 . }
108-226 .
108-227 . A = B*C;
108-228 . A = B*C;
108-229 .
108-230 . if (A le B)
108-231 . {
108-232 . A = B + C;
108-233 . D = E + F;
108-234 . }
108-235 .
108-236 . /* LE SV TOC-2809 this is a stp-03.3.16 req to enable*/
108-237 . A = B+C;
108-238 .
108-239 . if (A ne B)
108-240 . {
108-241 . A = B + C;
108-242 . D = E + F;
108-243 . }
108-244 .
108-245 . A = B+C;
108-246 . A = 0x0009;
108-247 . A = B+C;
108-248 . A = B+C;
108-249 . /* LE SV TOC-2810 this is a stp-03.3.21 req to call admin*/
108-250 . A = B*C;
108-251 . A = B/C;
108-252 . A = B-C;
108-253 .
108-254 . if (A lt B)
108-255 . {
108-256 . A = B + C;
108-257 . D = E + F;
108-258 . }
108-259 .
108-260 .
108-261 . if (A != B)
108-262 . {
108-263 . A = B + C;
108-264 . D = E + F;
108-265 . }
108-266 .
108-267 .
108-268 . if (A > = B)
108-269 . {
108-270 . A = B + C;
108-271 . D = E + F;
108-272 . }
108-273 .
108-274 . A = B*C;
108-275 . A = B*C;
108-276 . A = B-C;
108-277 . A = B/C;
108-278 . /* LE SV TOC-2811 this is a stp-03.3.31 req to validate*/
108-279 . A = B/C;
108-280 . A = B+C;
108-281 .
108-282 . if (A != B)
108-283 . {
108-284 . A = B + C;
108-285 . D = E + F;
108-286 . }
108-287 .
108-288 . A = B*C;
108-289 .
108-290 . if (A ge B)
108-291 . {
108-292 . A = B + C;
108-293 . D = E + F;
108-294 . }
108-295 .
108-296 . A = B/C;
108-297 . A = B/C;
108-298 . A = B/C;
108-299 .
108-300 . if (A < B)
108-301 . {
108-302 . A = B + C;
108-303 . D = E + F;
108-304 . }
108-305 .
108-306 . A = B-C;
108-307 .
108-308 . if (A lt B)
108-309 . {
108-310 . A = B + C;
108-311 . D = E + F;
108-312 . }
108-313 .
108-314 . A = B/C;
108-315 . /* LE SV TOC-2812 this is a stp-03.3.43 req to inhibit*/
108-316 .
108-317 . if (A < B)
108-318 . {
108-319 . A = B + C;
108-320 . D = E + F;
108-321 . }
108-322 .
108-323 . A = B*C;
108-324 .
108-325 . if (A le B)
108-326 . {
108-327 . A = B + C;
108-328 . D = E + F;
108-329 . }
108-330 .
108-331 . A = B+C;
108-332 . A = B-C;
108-333 . A = B*C;
108-334 . A = B/C;
108-335 .
108-336 . if (A lt B)
108-337 . {
108-338 . A = B + C;
108-339 . D = E + F;
108-340 . }
108-341 .
108-342 . A = B-C;
108-343 .
108-344 . /* dead_code = B + C;
108-345 . dead_code = D + E;
108-346 . dead_code = F + G; */
108-347 .
108-348 . A = B/C;
108-349 . /* LE SV TOC-2813 this is a stp-03.3.53 req to validate*/
108-350 .
108-351 . switch (stp stuff)
108-352 . {
108-353 . case one:
108-354 . {
108-355 . switch (nested)
108-356 . {
108-357 . case:
108-358 . X = Y + Z;
108-359 . case:
108-360 . X = Y + Z;
108-361 . default:
108-362 . SwError;
108-363 . }
108-364 . }
108-365 . case two:
108-366 . {
108-367 . run_this;
108-368 . break;
108-369 . }
108-370 . default:
108-371 . {
108-372 . SwError;
108-373 . }
108-374 . }
108-375 .
108-376 . A = B/C;
108-377 . A = B*C;
108-378 . A = B/C;
108-379 . A = B+C;
108-380 .
108-381 . if (A != B)
108-382 . {
108-383 . A = B + C;
108-384 . D = E + F;
108-385 . }
108-386 .
108-387 . /* LE SV TOC-2814 this is a stp-03.3.58 req to compare*/
108-388 . A = B*C;
108-389 . A = B-C;
108-390 . A = B-C;
108-391 . A = B+C;
108-392 . A = B+C;
108-393 . /* LE SV TOC-2815 this is a stp-03.3.63 req to set RTC*/
108-394 . A = B-C;
108-395 . A = B-C;
108-396 . A = B+C;
108-397 . A = B-C;
108-398 . A = B*C;
108-399 .
108-400 . if (A < = B)
108-401 . {
108-402 . A = B + C;
108-403 . D = E + F;
108-404 . }
108-405 .
108-406 . // max LOC 68
108-407 .
108-408 . }
108-409 .
108-410 .
108-411 . /*
108-412 . -----------------------------------------------------------------------------
108-413 . --| NAME: stp.3.4
108-414 . --|
108-415 . --| ABSTRACT:
108-416 . --| This function does stp stuff.
108-417 . --|
108-418 . --| RETURNS:
108-419 . --| NONE.
108-420 . --|
108-421 . ----------------------------------------------------------------------------
108-422 . */
108-423 . static void stp.3.4(void)
108-424 . {
108-425 . A = B*C;
108-426 . A = B*C;
108-427 . A = B-C;
108-428 .
108-429 . if (A le B)
108-430 . {
108-431 . A = B + C;
108-432 . D = E + F;
108-433 . }
108-434 .
108-435 . A = B*C;
108-436 . A = B/C;
108-437 . // max LOC 6
108-438 .
108-439 . }
108-440 .
108-441 .
108-442 . /*
108-443 . -----------------------------------------------------------------------------
108-444 . --| NAME: stp.3.5
108-445 . --|
108-446 . --| ABSTRACT:
108-447 . --| This function does stp stuff.
108-448 . --|
108-449 . --| RETURNS:
108-450 . --| NONE.
108-451 . --|
108-452 . ----------------------------------------------------------------------------
108-453 . */
108-454 . static void stp.3.5(void)
108-455 . {
108-456 . A = B/C;
108-457 . A = B/C;
108-458 .
108-459 . if (A != B)
108-460 . {
108-461 . A = B + C;
108-462 . D = E + F;
108-463 . }
108-464 .
108-465 .
108-466 . if (A < B)
108-467 . {
108-468 . A = B + C;
108-469 . D = E + F;
108-470 . }
108-471 .
108-472 . A = B-C;
108-473 .
108-474 . if (A ne B)
108-475 . {
108-476 . A = B + C;
108-477 . D = E + F;
108-478 . }
108-479 .
108-480 . A = B/C;
108-481 . A = B/C;
108-482 . A = B+C;
108-483 . A = B-C;
108-484 .
108-485 . switch (stp stuff)
108-486 . {
108-487 . case one:
108-488 . {
108-489 . run_this;
108-490 . break;
108-491 . }
108-492 . case two:
108-493 . {
108-494 . run_this;
108-495 . break;
108-496 . }
108-497 . default:
108-498 . {
108-499 . // missing error call
108-500 . }
108-501 . }
108-502 .
108-503 .
108-504 . if (A le B)
108-505 . {
108-506 . A = B + C;
108-507 . D = E + F;
108-508 . }
108-509 .
108-510 . /* LE SV TOC-2816 this is a stp-03.5.12 req to transform*/
108-511 . A = B/C;
108-512 . A = B+C;
108-513 . /* LE SV TOC-2817 this is a stp-03.5.14 req to enable*/
108-514 . A = B/C;
108-515 . A = B-C;
108-516 . /* LE SV TOC-2818 this is a stp-03.5.16 req to inhibit*/
108-517 .
108-518 . if (A ne B)
108-519 . {
108-520 . A = B + C;
108-521 . D = E + F;
108-522 . }
108-523 .
108-524 . A = B*C;
108-525 . A = B+C;
108-526 . A = B*C;
108-527 . A = B-C;
108-528 .
108-529 . if (A le B)
108-530 . {
108-531 . A = B + C;
108-532 . D = E + F;
108-533 . }
108-534 .
108-535 . A = B*C;
108-536 . A = B/C;
108-537 . A = B-C;
108-538 .
108-539 . if (A le B)
108-540 . {
108-541 . A = B + C;
108-542 . D = E + F;
108-543 . }
108-544 .
108-545 . A = B-C;
108-546 .
108-547 . if (A gt B)
108-548 . {
108-549 . A = B + C;
108-550 . D = E + F;
108-551 . }
108-552 .
108-553 . A = B+C;
108-554 . A = B+C;
108-555 . A = B-C;
108-556 . A = (long)B + C;
108-557 . A = B/C;
108-558 . A = B-C;
108-559 . A = B-C;
108-560 . A = B*C;
108-561 . A = B+C;
108-562 . A = B/C;
108-563 .
108-564 . if (A le B)
108-565 . {
108-566 . A = B + C;
108-567 . D = E + F;
108-568 . }
108-569 .
108-570 . /* dead_code = A * B; */
108-571 .
108-572 . if (A == B)
108-573 . {
108-574 . A = B + C;
108-575 . D = E + F;
108-576 . }
108-577 .
108-578 .
108-579 . switch (stp stuff)
108-580 . {
108-581 . case one:
108-582 . {
108-583 . run_this;
108-584 . break;
108-585 . }
108-586 . case two:
108-587 . {
108-588 . run_this;
108-589 . break;
108-590 . }
108-591 . default:
108-592 . {
108-593 . // missing error call
108-594 . }
108-595 . }
108-596 .
108-597 . A = B+C;
108-598 . A = B+C;
108-599 .
108-600 . if ($stp stuff > $otherstp stuff)
108-601 . /* LE SV TOC-008 we really should log all error calls */
108-602 . {
108-603 . A = B + C;
108-604 . }
108-605 .
108-606 . A = B/C;
108-607 .
108-608 . if (A ge B)
108-609 . {
108-610 . A = B + C;
108-611 . D = E + F;
108-612 . }
108-613 .
108-614 .
108-615 . if (A < = B)
108-616 . {
108-617 . A = B + C;
108-618 . D = E + F;
108-619 . }
108-620 .
108-621 .
108-622 . if (A ne B)
108-623 . {
108-624 . A = B + C;
108-625 . D = E + F;
108-626 . }
108-627 .
108-628 .
108-629 . if (A > B)
108-630 . {
108-631 . A = B + C;
108-632 . D = E + F;
108-633 . }
108-634 .
108-635 . A = B*C;
108-636 .
108-637 . if (A == B)
108-638 . {
108-639 . A = B + C;
108-640 . D = E + F;
108-641 . }
108-642 .
108-643 . A = B+C;
108-644 . A = B-C;
108-645 . A = B-C;
108-646 .
108-647 . if (A eq B)
108-648 . {
108-649 . A = B + C;
108-650 . D = E + F;
108-651 . }
108-652 .
108-653 . A = B*C;
108-654 .
108-655 . if (A eq B)
108-656 . {
108-657 . A = B + C;
108-658 . D = E + F;
108-659 . }
108-660 .
108-661 . A = B-C;
108-662 .
108-663 . switch (stp stuff)
108-664 . {
108-665 . case:
108-666 . case:
108-667 . // stacked case statements but only if there is a new line in between
108-668 .
108-669 . case:
108-670 . case:
108-671 . case:
108-672 . {
108-673 . run_this;
108-674 . break;
108-675 . }
108-676 . default:
108-677 . {
108-678 . halt;
108-679 . }
108-680 . }
108-681 .
108-682 . A = B/C;
108-683 . A = B/C;
108-684 . A = B+C;
108-685 .
108-686 . if (A ge B)
108-687 . {
108-688 . A = B + C;
108-689 . D = E + F;
108-690 . }
108-691 .
108-692 . A = B/C;
108-693 . A = B+C;
108-694 . // max LOC 60
108-695 .
108-696 . }
108-697 .
108-698 .
108-699 . /*
108-700 . -----------------------------------------------------------------------------
108-701 . --| NAME: stp.3.6
108-702 . --|
108-703 . --| ABSTRACT:
108-704 . --| This function does stp stuff.
108-705 . --|
108-706 . --| RETURNS:
108-707 . --| NONE.
108-708 . --|
108-709 . ----------------------------------------------------------------------------
108-710 . */
108-711 . static void stp.3.6(void)
108-712 . {
108-713 . // (P) this is really improtant
108-714 . A = B*C;
108-715 . A = B/C;
108-716 . A = B/C;
108-717 . A = B-C;
108-718 . A = B+C;
108-719 . A = B*C;
108-720 . A = B+C;
108-721 . A = B/C;
108-722 . A = B/C;
108-723 .
108-724 . if (A ge B)
108-725 . {
108-726 . A = B + C;
108-727 . D = E + F;
108-728 . }
108-729 .
108-730 . A = B+C;
108-731 . A = B/C;
108-732 . /* LE SV TOC-2819 this is a stp-03.6.13 req to reject*/
108-733 . A = B-C;
108-734 . A = B-C;
108-735 . A = B/C;
108-736 .
108-737 . if (A eq B)
108-738 . {
108-739 . A = B + C;
108-740 . D = E + F;
108-741 . }
108-742 .
108-743 . A = B+C;
108-744 . A = B-C;
108-745 .
108-746 . if (A > B)
108-747 . {
108-748 . A = B + C;
108-749 . D = E + F;
108-750 . }
108-751 .
108-752 .
108-753 . if (A > B)
108-754 . {
108-755 . A = B + C;
108-756 . D = E + F;
108-757 . }
108-758 .
108-759 . A = B/C;
108-760 . // max LOC 21
108-761 .
108-762 . }
108-763 .
108 108 Result: result/source/ft-app/ft-app-B1.0/stp/stp-03.c
109 109 Source: source/ft-app/ft-app-B1.0/stp/stp-04.c
109-0 .
109-1 .
109-2 . #include B;
109-3 . #include B;
109-4 . #include A;
109-5 . int A;
109-6 . #define B;
109-7 . #include D;
109-8 .
109-9 .
109-10 .
109-11 . /*
109-12 . -----------------------------------------------------------------------------
109-13 . --| NAME: stp.4.1
109-14 . --|
109-15 . --| ABSTRACT:
109-16 . --| This function does stp stuff.
109-17 . --|
109-18 . --| RETURNS:
109-19 . --| NONE.
109-20 . --|
109-21 . ----------------------------------------------------------------------------
109-22 . */
109-23 . static void stp.4.1(void)
109-24 . {
109-25 . A = B-C;
109-26 .
109-27 . if (A == B)
109-28 . {
109-29 . A = B + C;
109-30 . D = E + F;
109-31 . }
109-32 .
109-33 . A = B*C;
109-34 . A = B-C;
109-35 . A = B/C;
109-36 .
109-37 . if (A gt B)
109-38 . {
109-39 . A = B + C;
109-40 . D = E + F;
109-41 . }
109-42 .
109-43 . A = B*C;
109-44 .
109-45 . if (A < B)
109-46 . {
109-47 . A = B + C;
109-48 . D = E + F;
109-49 . }
109-50 .
109-51 . A = B*C;
109-52 . A = B+C;
109-53 .
109-54 . if (A ge B)
109-55 . {
109-56 . A = B + C;
109-57 . D = E + F;
109-58 . }
109-59 .
109-60 . A = B/C;
109-61 . A = B-C;
109-62 . A = B/C;
109-63 . A = B*C;
109-64 . A = B/C;
109-65 . A = B/C;
109-66 . A = B-C;
109-67 . A = B+C;
109-68 . A = B/C;
109-69 . A = B*C;
109-70 . A = B*C;
109-71 . A = B+C;
109-72 .
109-73 . if (A le B)
109-74 . {
109-75 . A = B + C;
109-76 . D = E + F;
109-77 . }
109-78 .
109-79 .
109-80 . if (A gt B)
109-81 . {
109-82 . A = B + C;
109-83 . D = E + F;
109-84 . }
109-85 .
109-86 . A = B-C;
109-87 . A = B-C;
109-88 . /* LE SV TOC-2820 this is a stp-04.1.28 req to validate*/
109-89 . A = B-C;
109-90 . A = B/C;
109-91 .
109-92 . if (A gt B)
109-93 . {
109-94 . A = B + C;
109-95 . D = E + F;
109-96 . }
109-97 .
109-98 . A = B/C;
109-99 . A = B/C;
109-100 . A = B+C;
109-101 . A = B/C;
109-102 . /* LE SV TOC-2821 this is a stp-04.1.35 req to detect error*/
109-103 . A = 0x0002;
109-104 . A = B+C;
109-105 . /* LE SV TOC-2822 this is a stp-04.1.36 req to set Real Time Clock*/
109-106 . A = B*C;
109-107 . /* LE SV TOC-2823 this is a stp-04.1.37 req to audit*/
109-108 . A = B+C;
109-109 . A = B+C;
109-110 . A = B-C;
109-111 . A = 0x0001;
109-112 .
109-113 . if (A != B)
109-114 . {
109-115 . A = B + C;
109-116 . D = E + F;
109-117 . }
109-118 .
109-119 . A = B*C;
109-120 . A = B+C;
109-121 . A = B/C;
109-122 . A = B+C;
109-123 .
109-124 . if (A == B)
109-125 . {
109-126 . A = B + C;
109-127 . D = E + F;
109-128 . }
109-129 .
109-130 .
109-131 . if (A ne B)
109-132 . {
109-133 . A = B + C;
109-134 . D = E + F;
109-135 . }
109-136 .
109-137 . A = B/C;
109-138 . A = B*C;
109-139 . A = B/C;
109-140 .
109-141 . if (A == B)
109-142 . {
109-143 . A = B + C;
109-144 . D = E + F;
109-145 . }
109-146 .
109-147 . A = B+C;
109-148 . /* LE SV TOC-2824 this is a stp-04.1.52 req to verify*/
109-149 . A = B/C;
109-150 .
109-151 . /*
109-152 . dead_code = B - C;
109-153 . dead_code = D - E;
109-154 . dead_code = F - G;
109-155 . */
109-156 .
109-157 .
109-158 . if (A eq B)
109-159 . {
109-160 . A = B + C;
109-161 . D = E + F;
109-162 . }
109-163 .
109-164 . // max LOC 53
109-165 .
109-166 . }
109-167 .
109-168 .
109-169 . /*
109-170 . -----------------------------------------------------------------------------
109-171 . --| NAME: stp.4.2
109-172 . --|
109-173 . --| ABSTRACT:
109-174 . --| This function does stp stuff.
109-175 . --|
109-176 . --| RETURNS:
109-177 . --| NONE.
109-178 . --|
109-179 . ----------------------------------------------------------------------------
109-180 . */
109-181 . static void stp.4.2(void)
109-182 . {
109-183 . A = B*C;
109-184 .
109-185 . if (A != B)
109-186 . {
109-187 . A = B + C;
109-188 . D = E + F;
109-189 . }
109-190 .
109-191 . A = 0x0003;
109-192 .
109-193 . /*
109-194 . dead_code = B - C;
109-195 . dead_code = D - E;
109-196 . dead_code = F - G;
109-197 . */
109-198 .
109-199 . A = B+C;
109-200 .
109-201 . switch (stp stuff)
109-202 . {
109-203 . case one:
109-204 . {
109-205 . run_this;
109-206 . break;
109-207 . }
109-208 . case two:
109-209 . {
109-210 . run_this;
109-211 . break;
109-212 . }
109-213 . default:
109-214 . {
109-215 . SwError;
109-216 . }
109-217 . }
109-218 .
109-219 .
109-220 . switch (stp stuff)
109-221 . {
109-222 . case one:
109-223 . {
109-224 . run_this;
109-225 . break;
109-226 . }
109-227 . case two:
109-228 . {
109-229 . run_this;
109-230 . break;
109-231 . }
109-232 . default:
109-233 . {
109-234 . SwError;
109-235 . }
109-236 . }
109-237 .
109-238 .
109-239 . /*
109-240 . dead_code = B - C;
109-241 . dead_code = D - E;
109-242 . dead_code = F - G;
109-243 . */
109-244 .
109-245 . A = B+C;
109-246 .
109-247 . if (A < B)
109-248 . {
109-249 . A = B + C;
109-250 . D = E + F;
109-251 . }
109-252 .
109-253 . A = B*C;
109-254 . A = B+C;
109-255 . A = B/C;
109-256 . A = 0x0003;
109-257 .
109-258 . if (A gt B)
109-259 . {
109-260 . A = B + C;
109-261 . D = E + F;
109-262 . }
109-263 .
109-264 . A = B-C;
109-265 . A = B*C;
109-266 . A = B*C;
109-267 . A = B/C;
109-268 . A = B*C;
109-269 . A = B*C;
109-270 .
109-271 . if (A != B)
109-272 . {
109-273 . A = B + C;
109-274 . D = E + F;
109-275 . }
109-276 .
109-277 . A = B/C;
109-278 . /* LE SV TOC-2825 this is a stp-04.2.20 req to check unix*/
109-279 .
109-280 . if (A ge B)
109-281 . {
109-282 . A = B + C;
109-283 . D = E + F;
109-284 . }
109-285 .
109-286 .
109-287 . if (A eq B)
109-288 . {
109-289 . A = B + C;
109-290 . D = E + F;
109-291 . }
109-292 .
109-293 . A = B-C;
109-294 . A = B+C;
109-295 .
109-296 . if (A != B)
109-297 . {
109-298 . A = B + C;
109-299 . D = E + F;
109-300 . }
109-301 .
109-302 . A = B*C;
109-303 . A = B+C;
109-304 . A = B/C;
109-305 . A = 0x0008;
109-306 . A = B-C;
109-307 . A = B/C;
109-308 .
109-309 . if (A < = B)
109-310 . {
109-311 . A = B + C;
109-312 . D = E + F;
109-313 . }
109-314 .
109-315 . A = B/C;
109-316 .
109-317 . if (A > = B)
109-318 . {
109-319 . A = B + C;
109-320 . D = E + F;
109-321 . }
109-322 .
109-323 .
109-324 . if (A eq B)
109-325 . {
109-326 . A = B + C;
109-327 . D = E + F;
109-328 . }
109-329 .
109-330 . A = B+C;
109-331 .
109-332 . if (A == B)
109-333 . {
109-334 . A = B + C;
109-335 . D = E + F;
109-336 . }
109-337 .
109-338 . A = B/C;
109-339 . A = B*C;
109-340 . A = B+C;
109-341 . A = B*C;
109-342 .
109-343 . if (A < B)
109-344 . {
109-345 . A = B + C;
109-346 . D = E + F;
109-347 . }
109-348 .
109-349 . // max LOC 40
109-350 .
109-351 . }
109-352 .
109-353 .
109-354 . /*
109-355 . -----------------------------------------------------------------------------
109-356 . --| NAME: stp.4.3
109-357 . --|
109-358 . --| ABSTRACT:
109-359 . --| This function does stp stuff.
109-360 . --|
109-361 . --| RETURNS:
109-362 . --| NONE.
109-363 . --|
109-364 . ----------------------------------------------------------------------------
109-365 . */
109-366 . static void stp.4.3(void)
109-367 . {
109-368 . A = B*C;
109-369 . A = B+C;
109-370 .
109-371 . if (A < B)
109-372 . {
109-373 . A = B + C;
109-374 . D = E + F;
109-375 . }
109-376 .
109-377 . A = B/C;
109-378 . A = B/C;
109-379 . A = B+C;
109-380 . A = B+C;
109-381 . A = B-C;
109-382 . FreePtr = HmiStringPtr;
109-383 .
109-384 . if (A > = B)
109-385 . {
109-386 . A = B + C;
109-387 . D = E + F;
109-388 . }
109-389 .
109-390 .
109-391 . if (A ge B)
109-392 . {
109-393 . A = B + C;
109-394 . D = E + F;
109-395 . }
109-396 .
109-397 . A = B/C;
109-398 . A = B/C;
109-399 . A = B-C;
109-400 .
109-401 . if (A > B)
109-402 . {
109-403 . A = B + C;
109-404 . D = E + F;
109-405 . }
109-406 .
109-407 .
109-408 . if (A > B)
109-409 . {
109-410 . A = B + C;
109-411 . D = E + F;
109-412 . }
109-413 .
109-414 .
109-415 . if (A ne B)
109-416 . {
109-417 . A = B + C;
109-418 . D = E + F;
109-419 . }
109-420 .
109-421 .
109-422 . if (A lt B)
109-423 . {
109-424 . A = B + C;
109-425 . D = E + F;
109-426 . }
109-427 .
109-428 .
109-429 . if (A > = B)
109-430 . {
109-431 . A = B + C;
109-432 . D = E + F;
109-433 . }
109-434 .
109-435 . A = B*C;
109-436 . A = B-C;
109-437 . A = B*C;
109-438 . A = B*C;
109-439 . /* LE SV TOC-2826 this is a stp-04.3.23 req to recover*/
109-440 . A = B*C;
109-441 .
109-442 . if (A le B)
109-443 . {
109-444 . A = B + C;
109-445 . D = E + F;
109-446 . }
109-447 .
109-448 . /* LE SV TOC-2827 this is a stp-04.3.25 req to check pSOS*/
109-449 .
109-450 . if (A < B)
109-451 . {
109-452 . A = B + C;
109-453 . D = E + F;
109-454 . }
109-455 .
109-456 . A = B+C;
109-457 . /* LE SV TOC-2828 this is a stp-04.3.27 req to inhibit*/
109-458 . A = 0x0008;
109-459 .
109-460 . if (A lt B)
109-461 . {
109-462 . A = B + C;
109-463 . D = E + F;
109-464 . }
109-465 .
109-466 . A = B+C;
109-467 . A = B+C;
109-468 . goto error;
109-469 . A = B-C;
109-470 .
109-471 . if (A > B)
109-472 . {
109-473 . A = B + C;
109-474 . D = E + F;
109-475 . }
109-476 .
109-477 . A = B-C;
109-478 . A = B+C;
109-479 .
109-480 . if (A < = B)
109-481 . {
109-482 . A = B + C;
109-483 . D = E + F;
109-484 . }
109-485 .
109-486 . A = B-C;
109-487 . A = B+C;
109-488 .
109-489 . /*
109-490 . dead_block = C * D;
109-491 . dead_block = E * F;
109-492 . */
109-493 .
109-494 . A = B-C;
109-495 . A = B*C;
109-496 . A = B*C;
109-497 .
109-498 . if (A ge B)
109-499 . {
109-500 . A = B + C;
109-501 . D = E + F;
109-502 . }
109-503 .
109-504 .
109-505 . if (A != B)
109-506 . {
109-507 . A = B + C;
109-508 . D = E + F;
109-509 . }
109-510 .
109-511 . A = B*C;
109-512 . A = B/C;
109-513 . A = B+C;
109-514 . A = B+C;
109-515 . A = 0x0006;
109-516 .
109-517 . if (A lt B)
109-518 . {
109-519 . A = B + C;
109-520 . D = E + F;
109-521 . }
109-522 .
109-523 . A = B/C;
109-524 . A = B/C;
109-525 . A = B*C;
109-526 . A = B*C;
109-527 . A = B/C;
109-528 . A = B/C;
109-529 . A = B/C;
109-530 . A = B+C;
109-531 . // max LOC 54
109-532 .
109-533 . }
109-534 .
109-535 .
109-536 . /*
109-537 . -----------------------------------------------------------------------------
109-538 . --| NAME: stp.4.4
109-539 . --|
109-540 . --| ABSTRACT:
109-541 . --| This function does stp stuff.
109-542 . --|
109-543 . --| RETURNS:
109-544 . --| NONE.
109-545 . --|
109-546 . ----------------------------------------------------------------------------
109-547 . */
109-548 . static void stp.4.4(void)
109-549 . {
109-550 .
109-551 . if (A > = B)
109-552 . {
109-553 . A = B + C;
109-554 . D = E + F;
109-555 . }
109-556 .
109-557 . A = B-C;
109-558 . free(FreePtr);
109-559 .
109-560 . if (A lt B)
109-561 . {
109-562 . A = B + C;
109-563 . D = E + F;
109-564 . }
109-565 .
109-566 . A = B/C;
109-567 .
109-568 . if (A > = B)
109-569 . {
109-570 . A = B + C;
109-571 . D = E + F;
109-572 . }
109-573 .
109-574 .
109-575 . if (A != B)
109-576 . {
109-577 . A = B + C;
109-578 . D = E + F;
109-579 . }
109-580 .
109-581 .
109-582 . if (A le B)
109-583 . {
109-584 . A = B + C;
109-585 . D = E + F;
109-586 . }
109-587 .
109-588 . A = B/C;
109-589 . A = B/C;
109-590 . A = B/C;
109-591 . A = B*C;
109-592 . A = B-C;
109-593 . A = B*C;
109-594 . A = 0x0002;
109-595 .
109-596 . if (A != B)
109-597 . {
109-598 . A = B + C;
109-599 . D = E + F;
109-600 . }
109-601 .
109-602 . A = B*C;
109-603 . A = B-C;
109-604 . A = 0x0007;
109-605 . A = B-C;
109-606 . /* LE SV TOC-2829 this is a stp-04.4.18 req to enable*/
109-607 . A = B+C;
109-608 . A = B-C;
109-609 .
109-610 . if (A ne B)
109-611 . {
109-612 . A = B + C;
109-613 . D = E + F;
109-614 . }
109-615 .
109-616 .
109-617 . #ifdef LAZY
109-618 . // this is not nice
109-619 . A = B + C;
109-620 . A = B + C;
109-621 . #endif
109-622 .
109-623 .
109-624 . if (A eq B)
109-625 . {
109-626 . A = B + C;
109-627 . D = E + F;
109-628 . }
109-629 .
109-630 .
109-631 . switch (stp stuff)
109-632 . {
109-633 . case one:
109-634 . {
109-635 . run_this;
109-636 . // missing break
109-637 . }
109-638 . case two:
109-639 . {
109-640 . run_this;
109-641 . break;
109-642 . }
109-643 . default:
109-644 . {
109-645 . SwError;
109-646 . }
109-647 . }
109-648 .
109-649 . A = B-C;
109-650 . A = B-C;
109-651 .
109-652 . if (A le B)
109-653 . {
109-654 . A = B + C;
109-655 . D = E + F;
109-656 . }
109-657 .
109-658 . A = B/C;
109-659 . A = B+C;
109-660 .
109-661 . if (A ge B)
109-662 . {
109-663 . A = B + C;
109-664 . D = E + F;
109-665 . }
109-666 .
109-667 . A = B-C;
109-668 . A = B+C;
109-669 . A = B*C;
109-670 . A = B/C;
109-671 .
109-672 . if (A gt B)
109-673 . {
109-674 . A = B + C;
109-675 . D = E + F;
109-676 . }
109-677 .
109-678 .
109-679 . if (A lt B)
109-680 . {
109-681 . A = B + C;
109-682 . D = E + F;
109-683 . }
109-684 .
109-685 . A = B*C;
109-686 .
109-687 . if (A > = B)
109-688 . {
109-689 . A = B + C;
109-690 . D = E + F;
109-691 . }
109-692 .
109-693 .
109-694 . if (A ge B)
109-695 . {
109-696 . A = B + C;
109-697 . D = E + F;
109-698 . }
109-699 .
109-700 .
109-701 . if (A lt B)
109-702 . {
109-703 . A = B + C;
109-704 . D = E + F;
109-705 . }
109-706 .
109-707 .
109-708 . if (A > = B)
109-709 . {
109-710 . A = B + C;
109-711 . D = E + F;
109-712 . }
109-713 .
109-714 . A = B-C;
109-715 .
109-716 . if (A < B)
109-717 . {
109-718 . A = B + C;
109-719 . D = E + F;
109-720 . }
109-721 .
109-722 .
109-723 . if (A ge B)
109-724 . {
109-725 . A = B + C;
109-726 . D = E + F;
109-727 . }
109-728 .
109-729 . A = B*C;
109-730 .
109-731 . if (A gt B)
109-732 . {
109-733 . A = B + C;
109-734 . D = E + F;
109-735 . }
109-736 .
109-737 .
109-738 . switch (stp stuff)
109-739 . {
109-740 . case one:
109-741 . {
109-742 . run_this;
109-743 . break;
109-744 . }
109-745 . case two:
109-746 . {
109-747 . run_this;
109-748 . break;
109-749 . }
109-750 . default:
109-751 . {
109-752 . SwError;
109-753 . }
109-754 . }
109-755 .
109-756 . A = B*C;
109-757 . A = B-C;
109-758 . A = 0x0004;
109-759 . A = B*C;
109-760 .
109-761 . if (A lt B)
109-762 . {
109-763 . A = B + C;
109-764 . D = E + F;
109-765 . }
109-766 .
109-767 . A = B*C;
109-768 .
109-769 . if (A != B)
109-770 . {
109-771 . A = B + C;
109-772 . D = E + F;
109-773 . }
109-774 .
109-775 . A = B/C;
109-776 . A = B*C;
109-777 . A = B/C;
109-778 .
109-779 . if (A lt B)
109-780 . {
109-781 . A = B + C;
109-782 . D = E + F;
109-783 . }
109-784 .
109-785 . A = B-C;
109-786 . A = B-C;
109-787 . A = B-C;
109-788 . A = B+C;
109-789 . A = B/C;
109-790 . A = B+C;
109-791 . A = B+C;
109-792 .
109-793 . if (A ge B)
109-794 . {
109-795 . A = B + C;
109-796 . D = E + F;
109-797 . }
109-798 .
109-799 . A = B+C;
109-800 . A = B-C;
109-801 . A = B/C;
109-802 . A = B/C;
109-803 . A = B*C;
109-804 .
109-805 . if (A < B)
109-806 . {
109-807 . A = B + C;
109-808 . D = E + F;
109-809 . }
109-810 .
109-811 . A = B/C;
109-812 . A = B-C;
109-813 . A = B/C;
109-814 . rcv_buffer = (U16 *) alloc(size+1);
109-815 . A = B+C;
109-816 .
109-817 . if (A lt B)
109-818 . {
109-819 . A = B + C;
109-820 . D = E + F;
109-821 . }
109-822 .
109-823 . A = B/C;
109-824 . A = B*C;
109-825 .
109-826 . if (A lt B)
109-827 . {
109-828 . A = B + C;
109-829 . D = E + F;
109-830 . }
109-831 .
109-832 . // max LOC 76
109-833 .
109-834 . }
109-835 .
109 109 Result: result/source/ft-app/ft-app-B1.0/stp/stp-04.c
110 110 Source: source/ft-app/ft-app-B1.0/stp/stp-05.c
110-0 . /*
110-1 . ----------------------------------------------------------------------------
110-2 . --| BEGIN PROLOGUE
110-3 . --|
110-4 . --| CLASSIFICATION: UNCLASSIFIED
110-5 . --|
110-6 . --| FILE NAME: stp-05.c
110-7 . --|
110-8 . --| ABSTRACT:
110-9 . --| This file contains the 6 functions that do file stp stuff.
110-10 . --|
110-11 . --| HISTORY:
110-12 . --| CCCQ_NAME:
110-13 . --| CCCQ_VER:
110-14 . --|
110-15 . --| END PROLOGUE
110-16 . ----------------------------------------------------------------------------
110-17 . */
110-18 .
110-19 . #include D;
110-20 . #define D;
110-21 . int A;
110-22 . #include D;
110-23 . int A;
110-24 . #define D;
110-25 . #define C;
110-26 . #define C;
110-27 . double C;
110-28 .
110-29 .
110-30 .
110-31 . /*
110-32 . -----------------------------------------------------------------------------
110-33 . --| NAME: stp.5.1
110-34 . --|
110-35 . --| ABSTRACT:
110-36 . --| This function does stp stuff.
110-37 . --|
110-38 . --| RETURNS:
110-39 . --| NONE.
110-40 . --|
110-41 . ----------------------------------------------------------------------------
110-42 . */
110-43 . static void stp.5.1(void)
110-44 . {
110-45 .
110-46 . if (A < = B)
110-47 . {
110-48 . A = B + C;
110-49 . D = E + F;
110-50 . }
110-51 .
110-52 .
110-53 . if (A > = B)
110-54 . {
110-55 . A = B + C;
110-56 . D = E + F;
110-57 . }
110-58 .
110-59 . A = B-C;
110-60 . A = B*C;
110-61 . A = B/C;
110-62 . A = B*C;
110-63 .
110-64 . /* dead_block = C * D;
110-65 . dead_block = E * F; */
110-66 .
110-67 . A = B/C;
110-68 . A = B/C;
110-69 . /* LE SV TOC-2830 this is a stp-05.1.9 req to assign*/
110-70 . A = B+C;
110-71 .
110-72 . if (A > B)
110-73 . {
110-74 . A = B + C;
110-75 . D = E + F;
110-76 . }
110-77 .
110-78 . A = B*C;
110-79 . A = B*C;
110-80 . A = B+C;
110-81 . A = B*C;
110-82 . A = B/C;
110-83 .
110-84 . if (A != B)
110-85 . {
110-86 . A = B + C;
110-87 . D = E + F;
110-88 . }
110-89 .
110-90 . A = B+C;
110-91 . A = B/C;
110-92 .
110-93 . switch (stp stuff)
110-94 . {
110-95 . case one:
110-96 . {
110-97 . run_this;
110-98 . break;
110-99 . }
110-100 . case two:
110-101 . {
110-102 . run_this;
110-103 . break;
110-104 . }
110-105 . default:
110-106 . {
110-107 . SwError;
110-108 . }
110-109 . }
110-110 .
110-111 . A = B+C;
110-112 . A = B/C;
110-113 . A = B+C;
110-114 .
110-115 . if (A ne B)
110-116 . {
110-117 . A = B + C;
110-118 . D = E + F;
110-119 . }
110-120 .
110-121 . A = B/C;
110-122 . A = B-C;
110-123 . A = B*C;
110-124 . A = B*C;
110-125 . A = B+C;
110-126 .
110-127 . if (A eq B)
110-128 . {
110-129 . A = B + C;
110-130 . D = E + F;
110-131 . }
110-132 .
110-133 . A = B*C;
110-134 . A = B+C;
110-135 . A = B*C;
110-136 . A = B/C;
110-137 . A = B-C;
110-138 .
110-139 . switch (stp stuff)
110-140 . {
110-141 . case one:
110-142 . {
110-143 . switch (nested)
110-144 . {
110-145 . case:
110-146 . X = Y + Z;
110-147 . case:
110-148 . X = Y + Z;
110-149 . default:
110-150 . SwError;
110-151 . }
110-152 . }
110-153 . case two:
110-154 . {
110-155 . run_this;
110-156 . break;
110-157 . }
110-158 . default:
110-159 . {
110-160 . SwError;
110-161 . }
110-162 . }
110-163 .
110-164 .
110-165 . if (A eq B)
110-166 . {
110-167 . A = B + C;
110-168 . D = E + F;
110-169 . }
110-170 .
110-171 . A = B/C;
110-172 . A = B/C;
110-173 . A = B+C;
110-174 . A = B*C;
110-175 . A = B-C;
110-176 .
110-177 . if (A < B)
110-178 . {
110-179 . A = B + C;
110-180 . D = E + F;
110-181 . }
110-182 .
110-183 . A = B-C;
110-184 . A = B*C;
110-185 . A = B/C;
110-186 . A = B+C;
110-187 . A = B-C;
110-188 . /* LE SV TOC-2831 this is a stp-05.1.47 req to translate*/
110-189 . A = B/C;
110-190 . /* LE SV TOC-2832 this is a stp-05.1.48 req to disable*/
110-191 . A = B-C;
110-192 . A = 0x0002;
110-193 .
110-194 . if (A gt B)
110-195 . {
110-196 . A = B + C;
110-197 . D = E + F;
110-198 . }
110-199 .
110-200 . A = B*C;
110-201 . A = B-C;
110-202 . A = B/C;
110-203 . A = B+C;
110-204 . A = B*C;
110-205 .
110-206 . if (A ne B)
110-207 . {
110-208 . A = B + C;
110-209 . D = E + F;
110-210 . }
110-211 .
110-212 . A = B/C;
110-213 . A = B/C;
110-214 . A = B-C;
110-215 . A = B/C;
110-216 . A = B-C;
110-217 . A = B/C;
110-218 . A = B+C;
110-219 . A = B*C;
110-220 . A = B-C;
110-221 . A = B-C;
110-222 .
110-223 . if (A < B)
110-224 . {
110-225 . A = B + C;
110-226 . D = E + F;
110-227 . }
110-228 .
110-229 .
110-230 . if (A gt B)
110-231 . {
110-232 . A = B + C;
110-233 . D = E + F;
110-234 . }
110-235 .
110-236 . A = B/C;
110-237 . A = B+C;
110-238 . /* LE SV TOC-2833 this is a stp-05.1.70 req to recover*/
110-239 .
110-240 . if (veg)
110-241 . // missing curly brace
110-242 . variable = orange;
110-243 .
110-244 . A = B/C;
110-245 . A = B*C;
110-246 . // max LOC 71
110-247 .
110-248 . }
110-249 .
110-250 .
110-251 . /*
110-252 . -----------------------------------------------------------------------------
110-253 . --| NAME: stp.5.2
110-254 . --|
110-255 . --| ABSTRACT:
110-256 . --| This function does stp stuff.
110-257 . --|
110-258 . --| RETURNS:
110-259 . --| NONE.
110-260 . --|
110-261 . ----------------------------------------------------------------------------
110-262 . */
110-263 . static void stp.5.2(void)
110-264 . {
110-265 . /* LE SV TOC-2834 this is a stp-05.2.1 req to assign*/
110-266 . A = B*C;
110-267 . A = B/C;
110-268 . A = B*C;
110-269 . A = B-C;
110-270 .
110-271 . if (A != B)
110-272 . {
110-273 . A = B + C;
110-274 . D = E + F;
110-275 . }
110-276 .
110-277 .
110-278 . if (A gt B)
110-279 . {
110-280 . A = B + C;
110-281 . D = E + F;
110-282 . }
110-283 .
110-284 . A = B*C;
110-285 . A = B*C;
110-286 . /* LE SV TOC-2835 this is a stp-05.2.9 req to store*/
110-287 .
110-288 . if (A le B)
110-289 . {
110-290 . A = B + C;
110-291 . D = E + F;
110-292 . }
110-293 .
110-294 . A = B-C;
110-295 .
110-296 . if (A ge B)
110-297 . {
110-298 . A = B + C;
110-299 . D = E + F;
110-300 . }
110-301 .
110-302 . /* LE SV TOC-2836 this is a stp-05.2.12 req to disable*/
110-303 .
110-304 . if (veg)
110-305 . // missing curly brace
110-306 . variable = orange;
110-307 .
110-308 . A = B-C;
110-309 . A = 0x0002;
110-310 .
110-311 . if (A eq B)
110-312 . {
110-313 . A = B + C;
110-314 . D = E + F;
110-315 . }
110-316 .
110-317 .
110-318 . if (A < B)
110-319 . {
110-320 . A = B + C;
110-321 . D = E + F;
110-322 . }
110-323 .
110-324 . A = B+C;
110-325 . A = B/C;
110-326 . A = B-C;
110-327 .
110-328 . if (A > B)
110-329 . {
110-330 . A = B + C;
110-331 . D = E + F;
110-332 . }
110-333 .
110-334 . A = 0x0009;
110-335 . A = B+C;
110-336 . /* LE SV TOC-2837 this is a stp-05.2.20 req to process*/
110-337 . A = B+C;
110-338 . /* LE SV TOC-2838 this is a stp-05.2.21 req to detect error*/
110-339 . A = B+C;
110-340 .
110-341 . if (A gt B)
110-342 . {
110-343 . A = B + C;
110-344 . D = E + F;
110-345 . }
110-346 .
110-347 . A = B-C;
110-348 .
110-349 . if (A < = B)
110-350 . {
110-351 . A = B + C;
110-352 . D = E + F;
110-353 . }
110-354 .
110-355 . A = B/C;
110-356 . A = B-C;
110-357 . A = B/C;
110-358 .
110-359 . if (A lt B)
110-360 . {
110-361 . A = B + C;
110-362 . D = E + F;
110-363 . }
110-364 .
110-365 . A = B+C;
110-366 . // max LOC 29
110-367 .
110-368 . }
110-369 .
110-370 .
110-371 . /*
110-372 . -----------------------------------------------------------------------------
110-373 . --| NAME: stp.5.3
110-374 . --|
110-375 . --| ABSTRACT:
110-376 . --| This function does stp stuff.
110-377 . --|
110-378 . --| RETURNS:
110-379 . --| NONE.
110-380 . --|
110-381 . ----------------------------------------------------------------------------
110-382 . */
110-383 . static void stp.5.3(void)
110-384 . {
110-385 .
110-386 . if (A eq B)
110-387 . {
110-388 . A = B + C;
110-389 . D = E + F;
110-390 . }
110-391 .
110-392 . A = B/C;
110-393 .
110-394 . if (A ne B)
110-395 . {
110-396 . A = B + C;
110-397 . D = E + F;
110-398 . }
110-399 .
110-400 . A = B+C;
110-401 . A = B/C;
110-402 . A = B/C;
110-403 .
110-404 . if (A gt B)
110-405 . {
110-406 . A = B + C;
110-407 . D = E + F;
110-408 . }
110-409 .
110-410 . /* LE SV TOC-2839 this is a stp-05.3.8 req to validate*/
110-411 . A = B*C;
110-412 . A = B-C;
110-413 . A = B-C;
110-414 . A = B*C;
110-415 . A = B+C;
110-416 . A = B+C;
110-417 .
110-418 . if (A ge B)
110-419 . {
110-420 . A = B + C;
110-421 . D = E + F;
110-422 . }
110-423 .
110-424 .
110-425 . if (A lt B)
110-426 . {
110-427 . A = B + C;
110-428 . D = E + F;
110-429 . }
110-430 .
110-431 . A = B*C;
110-432 . A = B-C;
110-433 . A = B-C;
110-434 .
110-435 . if (A lt B)
110-436 . {
110-437 . A = B + C;
110-438 . D = E + F;
110-439 . }
110-440 .
110-441 .
110-442 . if (A eq B)
110-443 . {
110-444 . A = B + C;
110-445 . D = E + F;
110-446 . }
110-447 .
110-448 .
110-449 . if (A lt B)
110-450 . {
110-451 . A = B + C;
110-452 . D = E + F;
110-453 . }
110-454 .
110-455 . A = B-C;
110-456 . // max LOC 22
110-457 .
110-458 . }
110-459 .
110-460 .
110-461 . /*
110-462 . -----------------------------------------------------------------------------
110-463 . --| NAME: stp.5.4
110-464 . --|
110-465 . --| ABSTRACT:
110-466 . --| This function does stp stuff.
110-467 . --|
110-468 . --| RETURNS:
110-469 . --| NONE.
110-470 . --|
110-471 . ----------------------------------------------------------------------------
110-472 . */
110-473 . static void stp.5.4(void)
110-474 . {
110-475 . A = B-C;
110-476 .
110-477 . switch (stp stuff)
110-478 . {
110-479 . case one:
110-480 . {
110-481 . run_this;
110-482 . break;
110-483 . }
110-484 . case two:
110-485 . {
110-486 . run_this;
110-487 . break;
110-488 . }
110-489 . default:
110-490 . {
110-491 . SwError;
110-492 . }
110-493 . }
110-494 .
110-495 .
110-496 . if (A gt B)
110-497 . {
110-498 . A = B + C;
110-499 . D = E + F;
110-500 . }
110-501 .
110-502 .
110-503 . if (A ne B)
110-504 . {
110-505 . A = B + C;
110-506 . D = E + F;
110-507 . }
110-508 .
110-509 . A = B/C;
110-510 .
110-511 . if (A lt B)
110-512 . {
110-513 . A = B + C;
110-514 . D = E + F;
110-515 . }
110-516 .
110-517 . A = B*C;
110-518 . A = B*C;
110-519 . A = B/C;
110-520 . A = B/C;
110-521 . A = B*C;
110-522 . A = B*C;
110-523 . A = B/C;
110-524 . // max LOC 13
110-525 .
110-526 . }
110-527 .
110-528 .
110-529 . /*
110-530 . -----------------------------------------------------------------------------
110-531 . --| NAME: stp.5.5
110-532 . --|
110-533 . --| ABSTRACT:
110-534 . --| This function does stp stuff.
110-535 . --|
110-536 . --| RETURNS:
110-537 . --| NONE.
110-538 . --|
110-539 . ----------------------------------------------------------------------------
110-540 . */
110-541 . static void stp.5.5(void)
110-542 . {
110-543 . A = 0x0003;
110-544 . A = B-C;
110-545 .
110-546 . if (A < = B)
110-547 . {
110-548 . A = B + C;
110-549 . D = E + F;
110-550 . }
110-551 .
110-552 .
110-553 . if (A gt B)
110-554 . {
110-555 . A = B + C;
110-556 . D = E + F;
110-557 . }
110-558 .
110-559 .
110-560 . if (A eq B)
110-561 . {
110-562 . A = B + C;
110-563 . D = E + F;
110-564 . }
110-565 .
110-566 . A = B-C;
110-567 . A = B-C;
110-568 .
110-569 . if (A > B)
110-570 . {
110-571 . A = B + C;
110-572 . D = E + F;
110-573 . }
110-574 .
110-575 . A = B+C;
110-576 . A = B+C;
110-577 . A = B-C;
110-578 .
110-579 . if (A gt B)
110-580 . {
110-581 . A = B + C;
110-582 . D = E + F;
110-583 . }
110-584 .
110-585 . A = B/C;
110-586 .
110-587 . if (A == B)
110-588 . {
110-589 . A = B + C;
110-590 . D = E + F;
110-591 . }
110-592 .
110-593 . A = B+C;
110-594 .
110-595 . if (A le B)
110-596 . {
110-597 . A = B + C;
110-598 . D = E + F;
110-599 . }
110-600 .
110-601 . goto error;
110-602 .
110-603 . if (A ge B)
110-604 . {
110-605 . A = B + C;
110-606 . D = E + F;
110-607 . }
110-608 .
110-609 . A = B*C;
110-610 . A = B/C;
110-611 . A = B-C;
110-612 . A = B+C;
110-613 . A = B*C;
110-614 . A = B*C;
110-615 . free(FreePtr);
110-616 . A = B-C;
110-617 . A = B-C;
110-618 . A = B/C;
110-619 . /* LE SV TOC-2840 this is a stp-05.5.26 req to transform*/
110-620 . A = B-C;
110-621 . A = B/C;
110-622 . // max LOC 27
110-623 .
110-624 . }
110-625 .
110-626 .
110-627 . /*
110-628 . -----------------------------------------------------------------------------
110-629 . --| NAME: stp.5.6
110-630 . --|
110-631 . --| ABSTRACT:
110-632 . --| This function does stp stuff.
110-633 . --|
110-634 . --| RETURNS:
110-635 . --| NONE.
110-636 . --|
110-637 . ----------------------------------------------------------------------------
110-638 . */
110-639 . static void stp.5.6(void)
110-640 . {
110-641 . A = B-C;
110-642 .
110-643 . if (A gt B)
110-644 . {
110-645 . A = B + C;
110-646 . D = E + F;
110-647 . }
110-648 .
110-649 . A = B/C;
110-650 . A = B/C;
110-651 . A = B-C;
110-652 . A = B-C;
110-653 . A = B/C;
110-654 .
110-655 . if (A == B)
110-656 . {
110-657 . A = B + C;
110-658 . D = E + F;
110-659 . }
110-660 .
110-661 . A = B-C;
110-662 . send_buffer = (U16 *) malloc(size+1);
110-663 . A = B*C;
110-664 .
110-665 . if {
110-666 . X = Y + Z;
110-667 . }
110-668 . else {
110-669 . halt;
110-670 . }
110-671 .
110-672 . A = B+C;
110-673 . A = B+C;
110-674 . A = B-C;
110-675 . A = B*C;
110-676 .
110-677 . if (A > B)
110-678 . {
110-679 . A = B + C;
110-680 . D = E + F;
110-681 . }
110-682 .
110-683 . A = B+C;
110-684 .
110-685 . if (A < B)
110-686 . {
110-687 . A = B + C;
110-688 . D = E + F;
110-689 . }
110-690 .
110-691 . /* LE SV TOC-2841 this is a stp-05.6.18 req to disable*/
110-692 . A = B-C;
110-693 . A = B/C;
110-694 . A = B/C;
110-695 . /* LE SV TOC-2842 this is a stp-05.6.21 req to record*/
110-696 . A = B/C;
110-697 . A = B+C;
110-698 .
110-699 . switch (stp stuff)
110-700 . {
110-701 . case one:
110-702 . {
110-703 . run_this;
110-704 . break;
110-705 . }
110-706 . case two:
110-707 . {
110-708 . run_this;
110-709 . break;
110-710 . }
110-711 . default:
110-712 . {
110-713 . SwError;
110-714 . }
110-715 . }
110-716 .
110-717 . A = B+C;
110-718 . A = B-C;
110-719 . A = B/C;
110-720 . A = B+C;
110-721 . /* LE SV TOC-2843 this is a stp-05.6.28 req to set RTC*/
110-722 . A = B*C;
110-723 . A = B/C;
110-724 .
110-725 . if (A ge B)
110-726 . {
110-727 . A = B + C;
110-728 . D = E + F;
110-729 . }
110-730 .
110-731 . A = B*C;
110-732 . A = B+C;
110-733 .
110-734 . if (A gt B)
110-735 . {
110-736 . A = B + C;
110-737 . D = E + F;
110-738 . }
110-739 .
110-740 .
110-741 . if (A gt B)
110-742 . {
110-743 . A = B + C;
110-744 . D = E + F;
110-745 . }
110-746 .
110-747 . /* LE SV TOC-2844 this is a stp-05.6.35 req to update*/
110-748 .
110-749 . if (A ne B)
110-750 . {
110-751 . A = B + C;
110-752 . D = E + F;
110-753 . }
110-754 .
110-755 .
110-756 . if (A ge B)
110-757 . {
110-758 . A = B + C;
110-759 . D = E + F;
110-760 . }
110-761 .
110-762 . A = B-C;
110-763 . A = B*C;
110-764 .
110-765 . switch (stp stuff)
110-766 . {
110-767 . case one:
110-768 . {
110-769 . run_this;
110-770 . break;
110-771 . }
110-772 . case two:
110-773 . {
110-774 . run_this;
110-775 . break;
110-776 . }
110-777 . default:
110-778 . {
110-779 . // missing error call
110-780 . }
110-781 . }
110-782 .
110-783 . A = B-C;
110-784 . A = B-C;
110-785 .
110-786 . if (A == B)
110-787 . {
110-788 . A = B + C;
110-789 . D = E + F;
110-790 . }
110-791 .
110-792 .
110-793 . if ($stp stuff > $otherstp stuff)
110-794 . /* LE SV TOC-008 we really should log all error calls */
110-795 . {
110-796 . A = B + C;
110-797 . }
110-798 .
110-799 . A = B-C;
110-800 . A = B+C;
110-801 . A = B*C;
110-802 . /* LE SV TOC-2845 this is a stp-05.6.45 req to fail*/
110-803 . A = B*C;
110-804 . A = B+C;
110-805 . A = B-C;
110-806 . A = B-C;
110-807 .
110-808 . if (A < = B)
110-809 . {
110-810 . A = B + C;
110-811 . D = E + F;
110-812 . }
110-813 .
110-814 . A = B*C;
110-815 . A = B*C;
110-816 . // max LOC 51
110-817 .
110-818 . }
110-819 .
110 110 Result: result/source/ft-app/ft-app-B1.0/stp/stp-05.c
111 111 Source: source/ft-app/ft-app-B1.0/stp/stp-06.c
111-0 . /*
111-1 . ----------------------------------------------------------------------------
111-2 . --| BEGIN PROLOGUE
111-3 . --|
111-4 . --| CLASSIFICATION: UNCLASSIFIED
111-5 . --|
111-6 . --| FILE NAME: stp-06.c
111-7 . --|
111-8 . --| ABSTRACT:
111-9 . --| This file contains the 4 functions that do file stp stuff.
111-10 . --|
111-11 . --| HISTORY:
111-12 . --| CCCQ_NAME:
111-13 . --| CCCQ_VER:
111-14 . --|
111-15 . --| END PROLOGUE
111-16 . ----------------------------------------------------------------------------
111-17 . */
111-18 .
111-19 . #include C;
111-20 . #include B;
111-21 . float B;
111-22 . int A;
111-23 .
111-24 .
111-25 .
111-26 . /*
111-27 . -----------------------------------------------------------------------------
111-28 . --| NAME: stp.6.1
111-29 . --|
111-30 . --| ABSTRACT:
111-31 . --| This function does stp stuff.
111-32 . --|
111-33 . --| RETURNS:
111-34 . --| NONE.
111-35 . --|
111-36 . ----------------------------------------------------------------------------
111-37 . */
111-38 . static void stp.6.1(void)
111-39 . {
111-40 . A = B-C;
111-41 . A = B*C;
111-42 .
111-43 . if (A < = B)
111-44 . {
111-45 . A = B + C;
111-46 . D = E + F;
111-47 . }
111-48 .
111-49 . A = B+C;
111-50 .
111-51 . if (A < B)
111-52 . {
111-53 . A = B + C;
111-54 . D = E + F;
111-55 . }
111-56 .
111-57 . A = B*C;
111-58 . A = B+C;
111-59 . A = B+C;
111-60 . A = B/C;
111-61 .
111-62 . if (A le B)
111-63 . {
111-64 . A = B + C;
111-65 . D = E + F;
111-66 . }
111-67 .
111-68 . A = B*C;
111-69 .
111-70 . if (A == B)
111-71 . {
111-72 . A = B + C;
111-73 . D = E + F;
111-74 . }
111-75 .
111-76 . A = B+C;
111-77 . A = B*C;
111-78 . A = B-C;
111-79 . A = B-C;
111-80 . A = B/C;
111-81 . /* LE SV TOC-2846 this is a stp-06.1.18 req to process*/
111-82 . A = B-C;
111-83 .
111-84 . if (A lt B)
111-85 . {
111-86 . A = B + C;
111-87 . D = E + F;
111-88 . }
111-89 .
111-90 . A = (long)B + C;
111-91 . A = B-C;
111-92 . A = B*C;
111-93 . A = B*C;
111-94 . A = B+C;
111-95 . A = B*C;
111-96 . // max LOC 24
111-97 .
111-98 . }
111-99 .
111-100 .
111-101 . /*
111-102 . -----------------------------------------------------------------------------
111-103 . --| NAME: stp.6.2
111-104 . --|
111-105 . --| ABSTRACT:
111-106 . --| This function does stp stuff.
111-107 . --|
111-108 . --| RETURNS:
111-109 . --| NONE.
111-110 . --|
111-111 . ----------------------------------------------------------------------------
111-112 . */
111-113 . static void stp.6.2(void)
111-114 . {
111-115 . A = B/C;
111-116 . A = B+C;
111-117 . A = B+C;
111-118 . A = B-C;
111-119 . A = 0x0003;
111-120 .
111-121 . switch (stp stuff)
111-122 . {
111-123 . case one:
111-124 . {
111-125 . run_this;
111-126 . break;
111-127 . }
111-128 . case two:
111-129 . {
111-130 . run_this;
111-131 . break;
111-132 . }
111-133 . default:
111-134 . {
111-135 . SwError;
111-136 . }
111-137 . }
111-138 .
111-139 . A = B+C;
111-140 . A = B*C;
111-141 . A = B+C;
111-142 . A = B*C;
111-143 .
111-144 . if (A < B)
111-145 . {
111-146 . A = B + C;
111-147 . D = E + F;
111-148 . }
111-149 .
111-150 .
111-151 . if (A > B)
111-152 . {
111-153 . A = B + C;
111-154 . D = E + F;
111-155 . }
111-156 .
111-157 . A = B-C;
111-158 . A = B-C;
111-159 . A = B+C;
111-160 . A = B/C;
111-161 . A = B*C;
111-162 . A = B+C;
111-163 .
111-164 . if (A < = B)
111-165 . {
111-166 . A = B + C;
111-167 . D = E + F;
111-168 . }
111-169 .
111-170 .
111-171 . if (A ge B)
111-172 . {
111-173 . A = B + C;
111-174 . D = E + F;
111-175 . }
111-176 .
111-177 . /* LE SV TOC-2847 this is a stp-06.2.20 req to set Real Time Clock*/
111-178 . A = B/C;
111-179 .
111-180 . if (A lt B)
111-181 . {
111-182 . A = B + C;
111-183 . D = E + F;
111-184 . }
111-185 .
111-186 . A = B-C;
111-187 . A = B*C;
111-188 .
111-189 . if (A ge B)
111-190 . {
111-191 . A = B + C;
111-192 . D = E + F;
111-193 . }
111-194 .
111-195 . A = B+C;
111-196 .
111-197 . if (A > = B)
111-198 . {
111-199 . A = B + C;
111-200 . D = E + F;
111-201 . }
111-202 .
111-203 . A = B+C;
111-204 . A = B*C;
111-205 .
111-206 . if (A ge B)
111-207 . {
111-208 . A = B + C;
111-209 . D = E + F;
111-210 . }
111-211 .
111-212 .
111-213 . if (A < = B)
111-214 . {
111-215 . A = B + C;
111-216 . D = E + F;
111-217 . }
111-218 .
111-219 . A = B-C;
111-220 . /* LE SV TOC-2848 this is a stp-06.2.32 req to audit*/
111-221 .
111-222 . switch (stp stuff)
111-223 . {
111-224 . case one:
111-225 . {
111-226 . run_this;
111-227 . break;
111-228 . }
111-229 . case two:
111-230 . {
111-231 . run_this;
111-232 . break;
111-233 . }
111-234 . default:
111-235 . {
111-236 . SwError;
111-237 . }
111-238 . }
111-239 .
111-240 . A = B+C;
111-241 .
111-242 . switch (stp stuff)
111-243 . {
111-244 . case one:
111-245 . {
111-246 . run_this;
111-247 . break;
111-248 . }
111-249 . case two:
111-250 . {
111-251 . run_this;
111-252 . break;
111-253 . }
111-254 . default:
111-255 . {
111-256 . // missing error call
111-257 . }
111-258 . }
111-259 .
111-260 . A = B-C;
111-261 .
111-262 . if (A eq B)
111-263 . {
111-264 . A = B + C;
111-265 . D = E + F;
111-266 . }
111-267 .
111-268 . A = B*C;
111-269 . A = B/C;
111-270 . A = B*C;
111-271 . A = B*C;
111-272 .
111-273 . if (A lt B)
111-274 . {
111-275 . A = B + C;
111-276 . D = E + F;
111-277 . }
111-278 .
111-279 . A = B*C;
111-280 . /* LE SV TOC-2849 this is a stp-06.2.42 req to fail*/
111-281 . A = B+C;
111-282 . /* LE SV TOC-2850 this is a stp-06.2.43 req to detect error*/
111-283 .
111-284 . if (A eq B)
111-285 . {
111-286 . A = B + C;
111-287 . D = E + F;
111-288 . }
111-289 .
111-290 . /* LE SV TOC-2851 this is a stp-06.2.44 req to validate*/
111-291 .
111-292 . if (A ge B)
111-293 . {
111-294 . A = B + C;
111-295 . D = E + F;
111-296 . }
111-297 .
111-298 .
111-299 . if (A eq B)
111-300 . {
111-301 . A = B + C;
111-302 . D = E + F;
111-303 . }
111-304 .
111-305 . A = B*C;
111-306 . A = B-C;
111-307 .
111-308 . if (A lt B)
111-309 . {
111-310 . A = B + C;
111-311 . D = E + F;
111-312 . }
111-313 .
111-314 . A = B-C;
111-315 . A = B+C;
111-316 .
111-317 . if (A ge B)
111-318 . {
111-319 . A = B + C;
111-320 . D = E + F;
111-321 . }
111-322 .
111-323 . A = B/C;
111-324 .
111-325 . if (A > = B)
111-326 . {
111-327 . A = B + C;
111-328 . D = E + F;
111-329 . }
111-330 .
111-331 . FreePtr = HmiStringPtr;
111-332 .
111-333 . switch (stp stuff)
111-334 . {
111-335 . case one:
111-336 . {
111-337 . run_this;
111-338 . break;
111-339 . }
111-340 . case two:
111-341 . {
111-342 . run_this;
111-343 . break;
111-344 . }
111-345 . default:
111-346 . {
111-347 . SwError;
111-348 . }
111-349 . }
111-350 .
111-351 . // max LOC 54
111-352 .
111-353 . }
111-354 .
111-355 .
111-356 . /*
111-357 . -----------------------------------------------------------------------------
111-358 . --| NAME: stp.6.3
111-359 . --|
111-360 . --| ABSTRACT:
111-361 . --| This function does stp stuff.
111-362 . --|
111-363 . --| RETURNS:
111-364 . --| NONE.
111-365 . --|
111-366 . ----------------------------------------------------------------------------
111-367 . */
111-368 . static void stp.6.3(void)
111-369 . {
111-370 . A = B*C;
111-371 . A = B-C;
111-372 . A = B+C;
111-373 . /* LE SV TOC-2852 this is a stp-06.3.4 req to inhibit*/
111-374 . A = B/C;
111-375 . A = B-C;
111-376 .
111-377 . switch (stp stuff)
111-378 . {
111-379 . case one:
111-380 . {
111-381 . run_this;
111-382 . break;
111-383 . }
111-384 . case two:
111-385 . {
111-386 . run_this;
111-387 . break;
111-388 . }
111-389 . default:
111-390 . {
111-391 . // missing error call
111-392 . }
111-393 . }
111-394 .
111-395 .
111-396 . if (A ne B)
111-397 . {
111-398 . A = B + C;
111-399 . D = E + F;
111-400 . }
111-401 .
111-402 . A = B/C;
111-403 . A = B+C;
111-404 .
111-405 . if (A < = B)
111-406 . {
111-407 . A = B + C;
111-408 . D = E + F;
111-409 . }
111-410 .
111-411 . A = B-C;
111-412 . A = B-C;
111-413 . A = B/C;
111-414 . A = B-C;
111-415 . A = B-C;
111-416 .
111-417 . if (A eq B)
111-418 . {
111-419 . A = B + C;
111-420 . D = E + F;
111-421 . }
111-422 .
111-423 . A = B+C;
111-424 .
111-425 . if (A > = B)
111-426 . {
111-427 . A = B + C;
111-428 . D = E + F;
111-429 . }
111-430 .
111-431 . A = B-C;
111-432 . A = B-C;
111-433 . A = B-C;
111-434 . A = B/C;
111-435 . A = B+C;
111-436 . A = B*C;
111-437 . A = B-C;
111-438 .
111-439 . if (A > B)
111-440 . {
111-441 . A = B + C;
111-442 . D = E + F;
111-443 . }
111-444 .
111-445 . A = B/C;
111-446 . A = B+C;
111-447 . A = B/C;
111-448 . A = B-C;
111-449 . A = B*C;
111-450 . A = B-C;
111-451 . A = B/C;
111-452 . A = B-C;
111-453 . A = B+C;
111-454 . A = B*C;
111-455 .
111-456 . if (A eq B)
111-457 . {
111-458 . A = B + C;
111-459 . D = E + F;
111-460 . }
111-461 .
111-462 . A = B-C;
111-463 .
111-464 . switch (stp stuff)
111-465 . {
111-466 . case:
111-467 . case:
111-468 . // stacked case statements but only if there is a new line in between
111-469 .
111-470 . case:
111-471 . case:
111-472 . case:
111-473 . {
111-474 . run_this;
111-475 . break;
111-476 . }
111-477 . default:
111-478 . {
111-479 . halt;
111-480 . }
111-481 . }
111-482 .
111-483 .
111-484 . if (A gt B)
111-485 . {
111-486 . A = B + C;
111-487 . D = E + F;
111-488 . }
111-489 .
111-490 . A = B-C;
111-491 . A = B/C;
111-492 . A = B+C;
111-493 .
111-494 . if (A < B)
111-495 . {
111-496 . A = B + C;
111-497 . D = E + F;
111-498 . }
111-499 .
111-500 . A = B/C;
111-501 . A = B-C;
111-502 . A = B+C;
111-503 . // max LOC 45
111-504 .
111-505 . }
111-506 .
111-507 .
111-508 . /*
111-509 . -----------------------------------------------------------------------------
111-510 . --| NAME: stp.6.4
111-511 . --|
111-512 . --| ABSTRACT:
111-513 . --| This function does stp stuff.
111-514 . --|
111-515 . --| RETURNS:
111-516 . --| NONE.
111-517 . --|
111-518 . ----------------------------------------------------------------------------
111-519 . */
111-520 . static void stp.6.4(void)
111-521 . {
111-522 . A = B/C;
111-523 . A = B-C;
111-524 . A = B*C;
111-525 . A = B+C;
111-526 . A = B-C;
111-527 . A = B/C;
111-528 . A = B*C;
111-529 . A = B/C;
111-530 . A = B*C;
111-531 . A = B-C;
111-532 .
111-533 . if (A < B)
111-534 . {
111-535 . A = B + C;
111-536 . D = E + F;
111-537 . }
111-538 .
111-539 . A = B+C;
111-540 . /* LE SV TOC-2853 this is a stp-06.4.13 req to validate*/
111-541 . A = B-C;
111-542 .
111-543 . if (A != B)
111-544 . {
111-545 . A = B + C;
111-546 . D = E + F;
111-547 . }
111-548 .
111-549 . A = B-C;
111-550 .
111-551 . if (A > = B)
111-552 . {
111-553 . A = B + C;
111-554 . D = E + F;
111-555 . }
111-556 .
111-557 . A = B*C;
111-558 .
111-559 . if (A le B)
111-560 . {
111-561 . A = B + C;
111-562 . D = E + F;
111-563 . }
111-564 .
111-565 . A = B-C;
111-566 . A = B-C;
111-567 . /* LE SV TOC-2854 this is a stp-06.4.21 req to enable*/
111-568 . A = B-C;
111-569 . A = 0x0001;
111-570 . FreePtr = HmiStringPtr;
111-571 . A = B+C;
111-572 . A = B/C;
111-573 .
111-574 . switch (stp stuff)
111-575 . {
111-576 . case one:
111-577 . {
111-578 . run_this;
111-579 . // missing break
111-580 . }
111-581 . case two:
111-582 . {
111-583 . run_this;
111-584 . break;
111-585 . }
111-586 . default:
111-587 . {
111-588 . SwError;
111-589 . }
111-590 . }
111-591 .
111-592 .
111-593 . switch (stp stuff)
111-594 . {
111-595 . case one:
111-596 . {
111-597 . run_this;
111-598 . break;
111-599 . }
111-600 . case two:
111-601 . {
111-602 . run_this;
111-603 . break;
111-604 . }
111-605 . default:
111-606 . {
111-607 . SwError;
111-608 . }
111-609 . }
111-610 .
111-611 . /* LE SV TOC-2855 this is a stp-06.4.25 req to detect error*/
111-612 .
111-613 . if (A < = B)
111-614 . {
111-615 . A = B + C;
111-616 . D = E + F;
111-617 . }
111-618 .
111-619 .
111-620 . switch (stp stuff)
111-621 . {
111-622 . case one:
111-623 . {
111-624 . run_this;
111-625 . break;
111-626 . }
111-627 . case two:
111-628 . {
111-629 . run_this;
111-630 . break;
111-631 . }
111-632 . default:
111-633 . {
111-634 . SwError;
111-635 . }
111-636 . }
111-637 .
111-638 . A = B+C;
111-639 . A = B+C;
111-640 . A = B-C;
111-641 . A = B/C;
111-642 .
111-643 . if (A > B)
111-644 . {
111-645 . A = B + C;
111-646 . D = E + F;
111-647 . }
111-648 .
111-649 . A = B/C;
111-650 .
111-651 . if (A ne B)
111-652 . {
111-653 . A = B + C;
111-654 . D = E + F;
111-655 . }
111-656 .
111-657 . A = B*C;
111-658 .
111-659 . switch (stp stuff)
111-660 . {
111-661 . case one:
111-662 . {
111-663 . run_this;
111-664 . break;
111-665 . }
111-666 . case two:
111-667 . {
111-668 . run_this;
111-669 . break;
111-670 . }
111-671 . default:
111-672 . {
111-673 . SwError;
111-674 . }
111-675 . }
111-676 .
111-677 . A = B/C;
111-678 .
111-679 . if (A ge B)
111-680 . {
111-681 . A = B + C;
111-682 . D = E + F;
111-683 . }
111-684 .
111-685 . A = B-C;
111-686 .
111-687 . if (A ge B)
111-688 . {
111-689 . A = B + C;
111-690 . D = E + F;
111-691 . }
111-692 .
111-693 . A = B-C;
111-694 .
111-695 . if (A != B)
111-696 . {
111-697 . A = B + C;
111-698 . D = E + F;
111-699 . }
111-700 .
111-701 .
111-702 . if (A le B)
111-703 . {
111-704 . A = B + C;
111-705 . D = E + F;
111-706 . }
111-707 .
111-708 . A = B-C;
111-709 . A = B-C;
111-710 . A = B/C;
111-711 . A = B/C;
111-712 . A = B+C;
111-713 . A = B-C;
111-714 . A = B*C;
111-715 . A = B+C;
111-716 . A = B-C;
111-717 .
111-718 . #ifdef LAZY
111-719 . // this is not nice
111-720 . A = B + C;
111-721 . A = B + C;
111-722 . #endif
111-723 .
111-724 . A = B-C;
111-725 . // max LOC 52
111-726 .
111-727 . }
111-728 .
111 111 Result: result/source/ft-app/ft-app-B1.0/stp/stp-06.c
112 112 Source: source/ft-app/ft-app-B1.0/stp/stp-07.c
112-0 . /*
112-1 . ----------------------------------------------------------------------------
112-2 . --| BEGIN PROLOGUE
112-3 . --|
112-4 . --| CLASSIFICATION: UNCLASSIFIED
112-5 . --|
112-6 . --| FILE NAME: stp-07.c
112-7 . --|
112-8 . --| ABSTRACT:
112-9 . --| This file contains the 1 functions that do file stp stuff.
112-10 . --|
112-11 . --| HISTORY:
112-12 . --| CCCQ_NAME:
112-13 . --| CCCQ_VER:
112-14 . --|
112-15 . --| END PROLOGUE
112-16 . ----------------------------------------------------------------------------
112-17 . */
112-18 .
112-19 . #include D;
112-20 . #include C;
112-21 . #include D;
112-22 . float B;
112-23 . #define B;
112-24 . char D;
112-25 . char D;
112-26 . char D;
112-27 .
112-28 .
112-29 .
112-30 . /*
112-31 . -----------------------------------------------------------------------------
112-32 . --| NAME: stp.7.1
112-33 . --|
112-34 . --| ABSTRACT:
112-35 . --| This function does stp stuff.
112-36 . --|
112-37 . --| RETURNS:
112-38 . --| NONE.
112-39 . --|
112-40 . ----------------------------------------------------------------------------
112-41 . */
112-42 . static void stp.7.1(void)
112-43 . {
112-44 . A = B*C;
112-45 .
112-46 . if (A != B)
112-47 . {
112-48 . A = B + C;
112-49 . D = E + F;
112-50 . }
112-51 .
112-52 .
112-53 . if (A ne B)
112-54 . {
112-55 . A = B + C;
112-56 . D = E + F;
112-57 . }
112-58 .
112-59 .
112-60 . if (A le B)
112-61 . {
112-62 . A = B + C;
112-63 . D = E + F;
112-64 . }
112-65 .
112-66 . A = B-C;
112-67 . A = B+C;
112-68 . goto error;
112-69 . A = B-C;
112-70 . A = B-C;
112-71 . A = B+C;
112-72 . A = B*C;
112-73 . A = B-C;
112-74 . A = B+C;
112-75 .
112-76 . if (A le B)
112-77 . {
112-78 . A = B + C;
112-79 . D = E + F;
112-80 . }
112-81 .
112-82 . A = B+C;
112-83 .
112-84 . if (A == B)
112-85 . {
112-86 . A = B + C;
112-87 . D = E + F;
112-88 . }
112-89 .
112-90 . A = B-C;
112-91 . A = B-C;
112-92 . A = B/C;
112-93 . A = B/C;
112-94 .
112-95 . if (A > = B)
112-96 . {
112-97 . A = B + C;
112-98 . D = E + F;
112-99 . }
112-100 .
112-101 .
112-102 . if (A == B)
112-103 . {
112-104 . A = B + C;
112-105 . D = E + F;
112-106 . }
112-107 .
112-108 .
112-109 . if (A le B)
112-110 . {
112-111 . A = B + C;
112-112 . D = E + F;
112-113 . }
112-114 .
112-115 . A = B/C;
112-116 . A = B+C;
112-117 .
112-118 . if (A < B)
112-119 . {
112-120 . A = B + C;
112-121 . D = E + F;
112-122 . }
112-123 .
112-124 . A = B*C;
112-125 . A = B/C;
112-126 .
112-127 . /* dead_block = C * D;
112-128 . dead_block = E * F; */
112-129 .
112-130 .
112-131 . if (A > B)
112-132 . {
112-133 . A = B + C;
112-134 . D = E + F;
112-135 . }
112-136 .
112-137 .
112-138 . if (A < B)
112-139 . {
112-140 . A = B + C;
112-141 . D = E + F;
112-142 . }
112-143 .
112-144 .
112-145 . if (A > B)
112-146 . {
112-147 . A = B + C;
112-148 . D = E + F;
112-149 . }
112-150 .
112-151 . A = B/C;
112-152 .
112-153 . if (A ne B)
112-154 . {
112-155 . A = B + C;
112-156 . D = E + F;
112-157 . }
112-158 .
112-159 . A = B*C;
112-160 .
112-161 . if (A ne B)
112-162 . {
112-163 . A = B + C;
112-164 . D = E + F;
112-165 . }
112-166 .
112-167 .
112-168 . if (A < = B)
112-169 . {
112-170 . A = B + C;
112-171 . D = E + F;
112-172 . }
112-173 .
112-174 . A = B/C;
112-175 . A = B/C;
112-176 . /* LE SV TOC-2856 this is a stp-07.1.38 req to set RTC*/
112-177 . A = B+C;
112-178 . A = B-C;
112-179 . A = B*C;
112-180 . A = B-C;
112-181 .
112-182 . if (A > = B)
112-183 . {
112-184 . A = B + C;
112-185 . D = E + F;
112-186 . }
112-187 .
112-188 . A = (long)B + C;
112-189 . A = B/C;
112-190 . A = B+C;
112-191 . // max LOC 44
112-192 .
112-193 . }
112-194 .
112 112 Result: result/source/ft-app/ft-app-B1.0/stp/stp-07.c
113 113 Source: source/ft-app/ft-app-B1.0/stp/stp-08.c
113-0 . /*
113-1 . ----------------------------------------------------------------------------
113-2 . --| BEGIN PROLOGUE
113-3 . --|
113-4 . --| CLASSIFICATION: UNCLASSIFIED
113-5 . --|
113-6 . --| FILE NAME: stp-08.c
113-7 . --|
113-8 . --| ABSTRACT:
113-9 . --| This file contains the 2 functions that do file stp stuff.
113-10 . --|
113-11 . --| HISTORY:
113-12 . --| CCCQ_NAME:
113-13 . --| CCCQ_VER:
113-14 . --|
113-15 . --| END PROLOGUE
113-16 . ----------------------------------------------------------------------------
113-17 . */
113-18 .
113-19 . int A;
113-20 . char D;
113-21 . int A;
113-22 . double C;
113-23 . double C;
113-24 . #define A;
113-25 . char D;
113-26 . #include B;
113-27 . #define C;
113-28 .
113-29 .
113-30 .
113-31 . /*
113-32 . -----------------------------------------------------------------------------
113-33 . --| NAME: stp.8.1
113-34 . --|
113-35 . --| ABSTRACT:
113-36 . --| This function does stp stuff.
113-37 . --|
113-38 . --| RETURNS:
113-39 . --| NONE.
113-40 . --|
113-41 . ----------------------------------------------------------------------------
113-42 . */
113-43 . static void stp.8.1(void)
113-44 . {
113-45 .
113-46 . if (A gt B)
113-47 . {
113-48 . A = B + C;
113-49 . D = E + F;
113-50 . }
113-51 .
113-52 . /* LE SV TOC-2857 this is a stp-08.1.2 req to set RTC*/
113-53 . A = B*C;
113-54 .
113-55 . if (A > = B)
113-56 . {
113-57 . A = B + C;
113-58 . D = E + F;
113-59 . }
113-60 .
113-61 .
113-62 . if (A lt B)
113-63 . {
113-64 . A = B + C;
113-65 . D = E + F;
113-66 . }
113-67 .
113-68 . A = B+C;
113-69 . /* LE SV TOC-2858 this is a stp-08.1.6 req to store*/
113-70 .
113-71 . if (A == B)
113-72 . {
113-73 . A = B + C;
113-74 . D = E + F;
113-75 . }
113-76 .
113-77 .
113-78 . switch (stp stuff)
113-79 . {
113-80 . case one:
113-81 . {
113-82 . switch (nested)
113-83 . {
113-84 . case:
113-85 . X = Y + Z;
113-86 . case:
113-87 . X = Y + Z;
113-88 . default:
113-89 . SwError;
113-90 . }
113-91 . }
113-92 . case two:
113-93 . {
113-94 . run_this;
113-95 . break;
113-96 . }
113-97 . default:
113-98 . {
113-99 . SwError;
113-100 . }
113-101 . }
113-102 .
113-103 . A = B-C;
113-104 . A = B*C;
113-105 . // max LOC 8
113-106 .
113-107 . }
113-108 .
113-109 .
113-110 . /*
113-111 . -----------------------------------------------------------------------------
113-112 . --| NAME: stp.8.2
113-113 . --|
113-114 . --| ABSTRACT:
113-115 . --| This function does stp stuff.
113-116 . --|
113-117 . --| RETURNS:
113-118 . --| NONE.
113-119 . --|
113-120 . ----------------------------------------------------------------------------
113-121 . */
113-122 . static void stp.8.2(void)
113-123 . {
113-124 . A = B-C;
113-125 .
113-126 . if (A != B)
113-127 . {
113-128 . A = B + C;
113-129 . D = E + F;
113-130 . }
113-131 .
113-132 . A = B+C;
113-133 . A = B-C;
113-134 . A = B*C;
113-135 . A = B-C;
113-136 . A = B-C;
113-137 .
113-138 . if (A < B)
113-139 . {
113-140 . A = B + C;
113-141 . D = E + F;
113-142 . }
113-143 .
113-144 . A = B/C;
113-145 . A = B-C;
113-146 .
113-147 . if (A < B)
113-148 . {
113-149 . A = B + C;
113-150 . D = E + F;
113-151 . }
113-152 .
113-153 . A = B-C;
113-154 . A = B+C;
113-155 . A = B+C;
113-156 . A = B*C;
113-157 . A = B/C;
113-158 .
113-159 . if (A ne B)
113-160 . {
113-161 . A = B + C;
113-162 . D = E + F;
113-163 . }
113-164 .
113-165 . A = B+C;
113-166 . // max LOC 18
113-167 .
113-168 . }
113-169 .
113 113 Result: result/source/ft-app/ft-app-B1.0/stp/stp-08.c
114 114 Source: source/ft-app/ft-app-B1.0/stp/stp-09.c
114-0 . /*
114-1 . ----------------------------------------------------------------------------
114-2 . --| BEGIN PROLOGUE
114-3 . --|
114-4 . --| CLASSIFICATION: UNCLASSIFIED
114-5 . --|
114-6 . --| FILE NAME: stp-09.c
114-7 . --|
114-8 . --| ABSTRACT:
114-9 . --| This file contains the 7 functions that do file stp stuff.
114-10 . --|
114-11 . --| HISTORY:
114-12 . --| CCCQ_NAME:
114-13 . --| CCCQ_VER:
114-14 . --|
114-15 . --| END PROLOGUE
114-16 . ----------------------------------------------------------------------------
114-17 . */
114-18 .
114-19 . #define D;
114-20 . #define C;
114-21 . #define C;
114-22 . #define C;
114-23 . #include D;
114-24 .
114-25 .
114-26 .
114-27 . /*
114-28 . -----------------------------------------------------------------------------
114-29 . --| NAME: stp.9.1
114-30 . --|
114-31 . --| ABSTRACT:
114-32 . --| This function does stp stuff.
114-33 . --|
114-34 . --| RETURNS:
114-35 . --| NONE.
114-36 . --|
114-37 . ----------------------------------------------------------------------------
114-38 . */
114-39 . static void stp.9.1(void)
114-40 . {
114-41 . A = B/C;
114-42 . A = B*C;
114-43 . send_buffer = (U16 *) malloc(size+1);
114-44 . A = B+C;
114-45 . A = B+C;
114-46 . A = B*C;
114-47 . A = B*C;
114-48 . A = B*C;
114-49 . A = B-C;
114-50 . A = B-C;
114-51 . A = B+C;
114-52 . A = B/C;
114-53 .
114-54 . if (A eq B)
114-55 . {
114-56 . A = B + C;
114-57 . D = E + F;
114-58 . }
114-59 .
114-60 . A = B-C;
114-61 .
114-62 . if (A ne B)
114-63 . {
114-64 . A = B + C;
114-65 . D = E + F;
114-66 . }
114-67 .
114-68 . A = B/C;
114-69 . A = B+C;
114-70 . A = B+C;
114-71 . A = B*C;
114-72 . A = B-C;
114-73 . A = B/C;
114-74 .
114-75 . if (A gt B)
114-76 . {
114-77 . A = B + C;
114-78 . D = E + F;
114-79 . }
114-80 .
114-81 .
114-82 . if (A > B)
114-83 . {
114-84 . A = B + C;
114-85 . D = E + F;
114-86 . }
114-87 .
114-88 . A = B/C;
114-89 . /* LE SV TOC-2859 this is a stp-09.1.24 req to set RTC*/
114-90 .
114-91 . if (A == B)
114-92 . {
114-93 . A = B + C;
114-94 . D = E + F;
114-95 . }
114-96 .
114-97 . A = B+C;
114-98 . A = B*C;
114-99 .
114-100 . if (A < B)
114-101 . {
114-102 . A = B + C;
114-103 . D = E + F;
114-104 . }
114-105 .
114-106 . A = B/C;
114-107 . A = B+C;
114-108 . A = B*C;
114-109 .
114-110 . if (A != B)
114-111 . {
114-112 . A = B + C;
114-113 . D = E + F;
114-114 . }
114-115 .
114-116 .
114-117 . if (A eq B)
114-118 . {
114-119 . A = B + C;
114-120 . D = E + F;
114-121 . }
114-122 .
114-123 .
114-124 . /* dead_code = B + C;
114-125 . dead_code = D + E;
114-126 . dead_code = F + G; */
114-127 .
114-128 .
114-129 . if (A != B)
114-130 . {
114-131 . A = B + C;
114-132 . D = E + F;
114-133 . }
114-134 .
114-135 . A = B*C;
114-136 . A = B*C;
114-137 . /* LE SV TOC-2860 this is a stp-09.1.36 req to disable*/
114-138 . A = B/C;
114-139 . A = B-C;
114-140 .
114-141 . if (A lt B)
114-142 . {
114-143 . A = B + C;
114-144 . D = E + F;
114-145 . }
114-146 .
114-147 . A = B-C;
114-148 . A = B*C;
114-149 .
114-150 . if (A < = B)
114-151 . {
114-152 . A = B + C;
114-153 . D = E + F;
114-154 . }
114-155 .
114-156 . A = B-C;
114-157 . A = B*C;
114-158 .
114-159 . if (A lt B)
114-160 . {
114-161 . A = B + C;
114-162 . D = E + F;
114-163 . }
114-164 .
114-165 . // max LOC 44
114-166 .
114-167 . }
114-168 .
114-169 .
114-170 . /*
114-171 . -----------------------------------------------------------------------------
114-172 . --| NAME: stp.9.2
114-173 . --|
114-174 . --| ABSTRACT:
114-175 . --| This function does stp stuff.
114-176 . --|
114-177 . --| RETURNS:
114-178 . --| NONE.
114-179 . --|
114-180 . ----------------------------------------------------------------------------
114-181 . */
114-182 . static void stp.9.2(void)
114-183 . {
114-184 . A = B-C;
114-185 . A = B-C;
114-186 . A = B/C;
114-187 .
114-188 . if (A le B)
114-189 . {
114-190 . A = B + C;
114-191 . D = E + F;
114-192 . }
114-193 .
114-194 . A = B+C;
114-195 .
114-196 . if (A le B)
114-197 . {
114-198 . A = B + C;
114-199 . D = E + F;
114-200 . }
114-201 .
114-202 . A = B+C;
114-203 .
114-204 . if (A ge B)
114-205 . {
114-206 . A = B + C;
114-207 . D = E + F;
114-208 . }
114-209 .
114-210 .
114-211 . if {
114-212 . X = Y + Z;
114-213 . }
114-214 . else {
114-215 . halt;
114-216 . }
114-217 .
114-218 . A = B*C;
114-219 . A = B+C;
114-220 . A = B/C;
114-221 . A = 0x0002;
114-222 .
114-223 . if (A == B)
114-224 . {
114-225 . A = B + C;
114-226 . D = E + F;
114-227 . }
114-228 .
114-229 . A = B/C;
114-230 . A = B*C;
114-231 . A = B-C;
114-232 . A = B*C;
114-233 .
114-234 . if (A ne B)
114-235 . {
114-236 . A = B + C;
114-237 . D = E + F;
114-238 . }
114-239 .
114-240 .
114-241 . if (A > B)
114-242 . {
114-243 . A = B + C;
114-244 . D = E + F;
114-245 . }
114-246 .
114-247 . A = B/C;
114-248 . A = B-C;
114-249 . A = B*C;
114-250 .
114-251 . if (A lt B)
114-252 . {
114-253 . A = B + C;
114-254 . D = E + F;
114-255 . }
114-256 .
114-257 . A = B-C;
114-258 . A = B+C;
114-259 . A = B*C;
114-260 . /* LE SV TOC-2861 this is a stp-09.2.26 req to process*/
114-261 .
114-262 . if (A > = B)
114-263 . {
114-264 . A = B + C;
114-265 . D = E + F;
114-266 . }
114-267 .
114-268 . A = B/C;
114-269 . A = (long)B + C;
114-270 . A = B+C;
114-271 . A = B*C;
114-272 .
114-273 . if (A le B)
114-274 . {
114-275 . A = B + C;
114-276 . D = E + F;
114-277 . }
114-278 .
114-279 . A = B-C;
114-280 . /* LE SV TOC-2862 this is a stp-09.2.32 req to detect error*/
114-281 .
114-282 . if (A eq B)
114-283 . {
114-284 . A = B + C;
114-285 . D = E + F;
114-286 . }
114-287 .
114-288 . /* LE SV TOC-2863 this is a stp-09.2.33 req to record*/
114-289 . A = B*C;
114-290 . A = B/C;
114-291 . A = B-C;
114-292 . A = B-C;
114-293 . A = B*C;
114-294 .
114-295 . if (A ne B)
114-296 . {
114-297 . A = B + C;
114-298 . D = E + F;
114-299 . }
114-300 .
114-301 . A = B-C;
114-302 . A = B+C;
114-303 .
114-304 . if (A ge B)
114-305 . {
114-306 . A = B + C;
114-307 . D = E + F;
114-308 . }
114-309 .
114-310 . A = B*C;
114-311 . /* LE SV TOC-2864 this is a stp-09.2.43 req to fail*/
114-312 . A = B-C;
114-313 .
114-314 . if (A > B)
114-315 . {
114-316 . A = B + C;
114-317 . D = E + F;
114-318 . }
114-319 .
114-320 . /* LE SV TOC-2865 this is a stp-09.2.45 req to process*/
114-321 . A = B/C;
114-322 .
114-323 . if (A > B)
114-324 . {
114-325 . A = B + C;
114-326 . D = E + F;
114-327 . }
114-328 .
114-329 .
114-330 . if (A gt B)
114-331 . {
114-332 . A = B + C;
114-333 . D = E + F;
114-334 . }
114-335 .
114-336 . A = B-C;
114-337 .
114-338 . if (A ge B)
114-339 . {
114-340 . A = B + C;
114-341 . D = E + F;
114-342 . }
114-343 .
114-344 . A = B+C;
114-345 . A = B*C;
114-346 .
114-347 . switch (stp stuff)
114-348 . {
114-349 . case one:
114-350 . {
114-351 . run_this;
114-352 . break;
114-353 . }
114-354 . case two:
114-355 . {
114-356 . run_this;
114-357 . break;
114-358 . }
114-359 . default:
114-360 . {
114-361 . SwError;
114-362 . }
114-363 . }
114-364 .
114-365 . A = B/C;
114-366 . A = B-C;
114-367 . A = B-C;
114-368 .
114-369 . if (A < B)
114-370 . {
114-371 . A = B + C;
114-372 . D = E + F;
114-373 . }
114-374 .
114-375 . /* LE SV TOC-2866 this is a stp-09.2.57 req to enable*/
114-376 . A = B-C;
114-377 . A = B-C;
114-378 . A = B*C;
114-379 .
114-380 . if (A le B)
114-381 . {
114-382 . A = B + C;
114-383 . D = E + F;
114-384 . }
114-385 .
114-386 . A = B/C;
114-387 . /* LE SV TOC-2867 this is a stp-09.2.62 req to check unix*/
114-388 . A = B+C;
114-389 . A = B+C;
114-390 . // (P) this is really improtant
114-391 . A = B*C;
114-392 . A = B*C;
114-393 .
114-394 . if (A ge B)
114-395 . {
114-396 . A = B + C;
114-397 . D = E + F;
114-398 . }
114-399 .
114-400 . A = (float)B + C;
114-401 .
114-402 . if (A < = B)
114-403 . {
114-404 . A = B + C;
114-405 . D = E + F;
114-406 . }
114-407 .
114-408 . // max LOC 67
114-409 .
114-410 . }
114-411 .
114-412 .
114-413 . /*
114-414 . -----------------------------------------------------------------------------
114-415 . --| NAME: stp.9.3
114-416 . --|
114-417 . --| ABSTRACT:
114-418 . --| This function does stp stuff.
114-419 . --|
114-420 . --| RETURNS:
114-421 . --| NONE.
114-422 . --|
114-423 . ----------------------------------------------------------------------------
114-424 . */
114-425 . static void stp.9.3(void)
114-426 . {
114-427 . A = B+C;
114-428 . A = B/C;
114-429 . A = B+C;
114-430 .
114-431 . if (A == B)
114-432 . {
114-433 . A = B + C;
114-434 . D = E + F;
114-435 . }
114-436 .
114-437 . A = 0x0007;
114-438 .
114-439 . if (A eq B)
114-440 . {
114-441 . A = B + C;
114-442 . D = E + F;
114-443 . }
114-444 .
114-445 . /* LE SV TOC-2868 this is a stp-09.3.6 req to assign*/
114-446 .
114-447 . if (A > = B)
114-448 . {
114-449 . A = B + C;
114-450 . D = E + F;
114-451 . }
114-452 .
114-453 . /* LE SV TOC-2869 this is a stp-09.3.7 req to disable*/
114-454 . A = B*C;
114-455 .
114-456 . if (A > = B)
114-457 . {
114-458 . A = B + C;
114-459 . D = E + F;
114-460 . }
114-461 .
114-462 .
114-463 . switch (stp stuff)
114-464 . {
114-465 . case one:
114-466 . {
114-467 . run_this;
114-468 . break;
114-469 . }
114-470 . case two:
114-471 . {
114-472 . run_this;
114-473 . break;
114-474 . }
114-475 . default:
114-476 . {
114-477 . SwError;
114-478 . }
114-479 . }
114-480 .
114-481 . A = B-C;
114-482 . A = B+C;
114-483 . A = B-C;
114-484 . A = B*C;
114-485 . A = B*C;
114-486 .
114-487 . if (A < B)
114-488 . {
114-489 . A = B + C;
114-490 . D = E + F;
114-491 . }
114-492 .
114-493 . FreePtr = HmiStringPtr;
114-494 . A = B+C;
114-495 . A = 0x0007;
114-496 .
114-497 . if (A ne B)
114-498 . {
114-499 . A = B + C;
114-500 . D = E + F;
114-501 . }
114-502 .
114-503 .
114-504 . if (A < = B)
114-505 . {
114-506 . A = B + C;
114-507 . D = E + F;
114-508 . }
114-509 .
114-510 . A = B/C;
114-511 . A = B+C;
114-512 .
114-513 . if (A gt B)
114-514 . {
114-515 . A = B + C;
114-516 . D = E + F;
114-517 . }
114-518 .
114-519 . // max LOC 21
114-520 .
114-521 . }
114-522 .
114-523 .
114-524 . /*
114-525 . -----------------------------------------------------------------------------
114-526 . --| NAME: stp.9.4
114-527 . --|
114-528 . --| ABSTRACT:
114-529 . --| This function does stp stuff.
114-530 . --|
114-531 . --| RETURNS:
114-532 . --| NONE.
114-533 . --|
114-534 . ----------------------------------------------------------------------------
114-535 . */
114-536 . static void stp.9.4(void)
114-537 . {
114-538 . /* LE SV TOC-2870 this is a stp-09.4.1 req to process*/
114-539 . do forever;
114-540 . A = B*C;
114-541 . A = B*C;
114-542 . A = B+C;
114-543 .
114-544 . switch (stp stuff)
114-545 . {
114-546 . case one:
114-547 . {
114-548 . run_this;
114-549 . break;
114-550 . }
114-551 . case two:
114-552 . {
114-553 . run_this;
114-554 . break;
114-555 . }
114-556 . default:
114-557 . {
114-558 . SwError;
114-559 . }
114-560 . }
114-561 .
114-562 .
114-563 . if (A ne B)
114-564 . {
114-565 . A = B + C;
114-566 . D = E + F;
114-567 . }
114-568 .
114-569 . A = B+C;
114-570 . A = B+C;
114-571 . A = B-C;
114-572 .
114-573 . if (A < = B)
114-574 . {
114-575 . A = B + C;
114-576 . D = E + F;
114-577 . }
114-578 .
114-579 . A = B-C;
114-580 . A = B-C;
114-581 .
114-582 . if (A ge B)
114-583 . {
114-584 . A = B + C;
114-585 . D = E + F;
114-586 . }
114-587 .
114-588 . A = B/C;
114-589 .
114-590 . if (A le B)
114-591 . {
114-592 . A = B + C;
114-593 . D = E + F;
114-594 . }
114-595 .
114-596 . A = 0x0009;
114-597 . A = B*C;
114-598 .
114-599 . if (A ge B)
114-600 . {
114-601 . A = B + C;
114-602 . D = E + F;
114-603 . }
114-604 .
114-605 . A = B-C;
114-606 .
114-607 . if (A ne B)
114-608 . {
114-609 . A = B + C;
114-610 . D = E + F;
114-611 . }
114-612 .
114-613 . A = B-C;
114-614 . A = B+C;
114-615 . A = B*C;
114-616 . A = B*C;
114-617 . A = B+C;
114-618 .
114-619 . if (A ne B)
114-620 . {
114-621 . A = B + C;
114-622 . D = E + F;
114-623 . }
114-624 .
114-625 . A = B*C;
114-626 .
114-627 . if (A eq B)
114-628 . {
114-629 . A = B + C;
114-630 . D = E + F;
114-631 . }
114-632 .
114-633 . A = B-C;
114-634 . /* LE SV TOC-2871 this is a stp-09.4.28 req to convert*/
114-635 . A = B+C;
114-636 . A = B-C;
114-637 . A = B/C;
114-638 .
114-639 . switch (stp stuff)
114-640 . {
114-641 . case one:
114-642 . {
114-643 . run_this;
114-644 . break;
114-645 . }
114-646 . case two:
114-647 . {
114-648 . run_this;
114-649 . break;
114-650 . }
114-651 . default:
114-652 . {
114-653 . SwError;
114-654 . }
114-655 . }
114-656 .
114-657 .
114-658 . if (A < B)
114-659 . {
114-660 . A = B + C;
114-661 . D = E + F;
114-662 . }
114-663 .
114-664 . A = (float)B + C;
114-665 . A = B/C;
114-666 . A = B/C;
114-667 . /* LE SV TOC-2872 this is a stp-09.4.35 req to detect error*/
114-668 .
114-669 . if (A != B)
114-670 . {
114-671 . A = B + C;
114-672 . D = E + F;
114-673 . }
114-674 .
114-675 . A = B-C;
114-676 . /* LE SV TOC-2873 this is a stp-09.4.37 req to detect error*/
114-677 . A = B+C;
114-678 . A = 0x0003;
114-679 . A = B/C;
114-680 . A = B/C;
114-681 . A = B*C;
114-682 .
114-683 . if (A le B)
114-684 . {
114-685 . A = B + C;
114-686 . D = E + F;
114-687 . }
114-688 .
114-689 .
114-690 . if (A eq B)
114-691 . {
114-692 . A = B + C;
114-693 . D = E + F;
114-694 . }
114-695 .
114-696 . A = B*C;
114-697 . A = B*C;
114-698 . /* LE SV TOC-2874 this is a stp-09.4.45 req to process*/
114-699 . A = B/C;
114-700 . A = B/C;
114-701 .
114-702 . if (A < = B)
114-703 . {
114-704 . A = B + C;
114-705 . D = E + F;
114-706 . }
114-707 .
114-708 . A = B/C;
114-709 . A = B*C;
114-710 . A = B*C;
114-711 . A = (float)B + C;
114-712 .
114-713 . if (A eq B)
114-714 . {
114-715 . A = B + C;
114-716 . D = E + F;
114-717 . }
114-718 .
114-719 . A = B/C;
114-720 . A = B/C;
114-721 . A = B+C;
114-722 .
114-723 . if (A > = B)
114-724 . {
114-725 . A = B + C;
114-726 . D = E + F;
114-727 . }
114-728 .
114-729 . A = B+C;
114-730 .
114-731 . if (A < = B)
114-732 . {
114-733 . A = B + C;
114-734 . D = E + F;
114-735 . }
114-736 .
114-737 . A = B-C;
114-738 .
114-739 . /* dead_code = B + C;
114-740 . dead_code = D + E;
114-741 . dead_code = F + G; */
114-742 .
114-743 . A = B*C;
114-744 .
114-745 . if (A le B)
114-746 . {
114-747 . A = B + C;
114-748 . D = E + F;
114-749 . }
114-750 .
114-751 .
114-752 . if (A < B)
114-753 . {
114-754 . A = B + C;
114-755 . D = E + F;
114-756 . }
114-757 .
114-758 . A = B/C;
114-759 . A = B+C;
114-760 . A = B*C;
114-761 . /* LE SV TOC-2875 this is a stp-09.4.65 req to detect error*/
114-762 .
114-763 . switch (stp stuff)
114-764 . {
114-765 . case one:
114-766 . {
114-767 . run_this;
114-768 . break;
114-769 . }
114-770 . case two:
114-771 . {
114-772 . run_this;
114-773 . break;
114-774 . }
114-775 . default:
114-776 . {
114-777 . SwError;
114-778 . }
114-779 . }
114-780 .
114-781 . A = B+C;
114-782 .
114-783 . if (A > B)
114-784 . {
114-785 . A = B + C;
114-786 . D = E + F;
114-787 . }
114-788 .
114-789 . A = B*C;
114-790 . A = B-C;
114-791 . // max LOC 69
114-792 .
114-793 . }
114-794 .
114-795 .
114-796 . /*
114-797 . -----------------------------------------------------------------------------
114-798 . --| NAME: stp.9.5
114-799 . --|
114-800 . --| ABSTRACT:
114-801 . --| This function does stp stuff.
114-802 . --|
114-803 . --| RETURNS:
114-804 . --| NONE.
114-805 . --|
114-806 . ----------------------------------------------------------------------------
114-807 . */
114-808 . static void stp.9.5(void)
114-809 . {
114-810 . A = B-C;
114-811 . A = B+C;
114-812 .
114-813 . if (A le B)
114-814 . {
114-815 . A = B + C;
114-816 . D = E + F;
114-817 . }
114-818 .
114-819 . A = B+C;
114-820 . /* LE SV TOC-2876 this is a stp-09.5.5 req to fail*/
114-821 . A = B/C;
114-822 .
114-823 . if (A gt B)
114-824 . {
114-825 . A = B + C;
114-826 . D = E + F;
114-827 . }
114-828 .
114-829 .
114-830 . if (A gt B)
114-831 . {
114-832 . A = B + C;
114-833 . D = E + F;
114-834 . }
114-835 .
114-836 . A = B-C;
114-837 . A = B*C;
114-838 . A = B/C;
114-839 .
114-840 . if (A != B)
114-841 . {
114-842 . A = B + C;
114-843 . D = E + F;
114-844 . }
114-845 .
114-846 . A = B+C;
114-847 .
114-848 . if (A > B)
114-849 . {
114-850 . A = B + C;
114-851 . D = E + F;
114-852 . }
114-853 .
114-854 . A = (long)B + C;
114-855 . A = B-C;
114-856 .
114-857 . if (A < B)
114-858 . {
114-859 . A = B + C;
114-860 . D = E + F;
114-861 . }
114-862 .
114-863 . A = B/C;
114-864 .
114-865 . if (A eq B)
114-866 . {
114-867 . A = B + C;
114-868 . D = E + F;
114-869 . }
114-870 .
114-871 . A = B/C;
114-872 .
114-873 . if (A eq B)
114-874 . {
114-875 . A = B + C;
114-876 . D = E + F;
114-877 . }
114-878 .
114-879 . A = B*C;
114-880 . A = B/C;
114-881 .
114-882 . if (A ne B)
114-883 . {
114-884 . A = B + C;
114-885 . D = E + F;
114-886 . }
114-887 .
114-888 . A = B-C;
114-889 . A = B/C;
114-890 . A = B/C;
114-891 . A = B+C;
114-892 .
114-893 . if (A ne B)
114-894 . {
114-895 . A = B + C;
114-896 . D = E + F;
114-897 . }
114-898 .
114-899 .
114-900 . if (A < = B)
114-901 . {
114-902 . A = B + C;
114-903 . D = E + F;
114-904 . }
114-905 .
114-906 .
114-907 . /* dead_code = B + C;
114-908 . dead_code = D + E;
114-909 . dead_code = F + G; */
114-910 .
114-911 . A = B/C;
114-912 . A = 0x0008;
114-913 .
114-914 . if (A > = B)
114-915 . {
114-916 . A = B + C;
114-917 . D = E + F;
114-918 . }
114-919 .
114-920 . A = B+C;
114-921 . A = B+C;
114-922 . /* LE SV TOC-2877 this is a stp-09.5.33 req to record*/
114-923 . A = B*C;
114-924 . A = B/C;
114-925 . /* LE SV TOC-2878 this is a stp-09.5.35 req to set Real Time Clock*/
114-926 . A = B*C;
114-927 . A = B+C;
114-928 . A = B-C;
114-929 .
114-930 . if (A < = B)
114-931 . {
114-932 . A = B + C;
114-933 . D = E + F;
114-934 . }
114-935 .
114-936 .
114-937 . if (A gt B)
114-938 . {
114-939 . A = B + C;
114-940 . D = E + F;
114-941 . }
114-942 .
114-943 . A = B/C;
114-944 .
114-945 . if (A ge B)
114-946 . {
114-947 . A = B + C;
114-948 . D = E + F;
114-949 . }
114-950 .
114-951 . A = B*C;
114-952 . A = B-C;
114-953 .
114-954 . if (A ne B)
114-955 . {
114-956 . A = B + C;
114-957 . D = E + F;
114-958 . }
114-959 .
114-960 .
114-961 . if (A eq B)
114-962 . {
114-963 . A = B + C;
114-964 . D = E + F;
114-965 . }
114-966 .
114-967 . A = B-C;
114-968 . A = B*C;
114-969 . A = B/C;
114-970 .
114-971 . if (A le B)
114-972 . {
114-973 . A = B + C;
114-974 . D = E + F;
114-975 . }
114-976 .
114-977 . A = B+C;
114-978 . A = B-C;
114-979 .
114-980 . if (A eq B)
114-981 . {
114-982 . A = B + C;
114-983 . D = E + F;
114-984 . }
114-985 .
114-986 . A = B*C;
114-987 .
114-988 . switch (stp stuff)
114-989 . {
114-990 . case one:
114-991 . {
114-992 . run_this;
114-993 . break;
114-994 . }
114-995 . case two:
114-996 . {
114-997 . run_this;
114-998 . break;
114-999 . }
114-1000 . default:
114-1001 . {
114-1002 . SwError;
114-1003 . }
114-1004 . }
114-1005 .
114-1006 . A = B/C;
114-1007 . A = B/C;
114-1008 .
114-1009 . if (A != B)
114-1010 . {
114-1011 . A = B + C;
114-1012 . D = E + F;
114-1013 . }
114-1014 .
114-1015 .
114-1016 . if (A == B)
114-1017 . {
114-1018 . A = B + C;
114-1019 . D = E + F;
114-1020 . }
114-1021 .
114-1022 . A = B+C;
114-1023 . /* LE SV TOC-2879 this is a stp-09.5.60 req to compare*/
114-1024 .
114-1025 . if (A == B)
114-1026 . {
114-1027 . A = B + C;
114-1028 . D = E + F;
114-1029 . }
114-1030 .
114-1031 . A = B*C;
114-1032 . A = B+C;
114-1033 . A = B/C;
114-1034 . A = B*C;
114-1035 .
114-1036 . if (A eq B)
114-1037 . {
114-1038 . A = B + C;
114-1039 . D = E + F;
114-1040 . }
114-1041 .
114-1042 . A = B/C;
114-1043 . A = B-C;
114-1044 . A = B-C;
114-1045 . A = B+C;
114-1046 .
114-1047 . if (A > = B)
114-1048 . {
114-1049 . A = B + C;
114-1050 . D = E + F;
114-1051 . }
114-1052 .
114-1053 . A = B*C;
114-1054 . A = B/C;
114-1055 . A = B+C;
114-1056 . A = B*C;
114-1057 .
114-1058 . if (A eq B)
114-1059 . {
114-1060 . A = B + C;
114-1061 . D = E + F;
114-1062 . }
114-1063 .
114-1064 . // max LOC 75
114-1065 .
114-1066 . }
114-1067 .
114-1068 .
114-1069 . /*
114-1070 . -----------------------------------------------------------------------------
114-1071 . --| NAME: stp.9.6
114-1072 . --|
114-1073 . --| ABSTRACT:
114-1074 . --| This function does stp stuff.
114-1075 . --|
114-1076 . --| RETURNS:
114-1077 . --| NONE.
114-1078 . --|
114-1079 . ----------------------------------------------------------------------------
114-1080 . */
114-1081 . static void stp.9.6(void)
114-1082 . {
114-1083 .
114-1084 . if (A eq B)
114-1085 . {
114-1086 . A = B + C;
114-1087 . D = E + F;
114-1088 . }
114-1089 .
114-1090 . A = B+C;
114-1091 . A = B+C;
114-1092 . A = B-C;
114-1093 . A = (int)B + C;
114-1094 . A = B-C;
114-1095 . A = B*C;
114-1096 . A = B*C;
114-1097 . A = B/C;
114-1098 . A = B+C;
114-1099 .
114-1100 . if (A ne B)
114-1101 . {
114-1102 . A = B + C;
114-1103 . D = E + F;
114-1104 . }
114-1105 .
114-1106 . A = B*C;
114-1107 . A = B*C;
114-1108 . A = B*C;
114-1109 .
114-1110 . if (A < = B)
114-1111 . {
114-1112 . A = B + C;
114-1113 . D = E + F;
114-1114 . }
114-1115 .
114-1116 . A = B/C;
114-1117 . A = B+C;
114-1118 . A = B-C;
114-1119 . A = B*C;
114-1120 . A = B/C;
114-1121 .
114-1122 . if (A < B)
114-1123 . {
114-1124 . A = B + C;
114-1125 . D = E + F;
114-1126 . }
114-1127 .
114-1128 .
114-1129 . if (A gt B)
114-1130 . {
114-1131 . A = B + C;
114-1132 . D = E + F;
114-1133 . }
114-1134 .
114-1135 .
114-1136 . if (A lt B)
114-1137 . {
114-1138 . A = B + C;
114-1139 . D = E + F;
114-1140 . }
114-1141 .
114-1142 . A = B*C;
114-1143 . A = B*C;
114-1144 . A = B+C;
114-1145 . A = B-C;
114-1146 . A = B*C;
114-1147 . /* LE SV TOC-2880 this is a stp-09.6.28 req to translate*/
114-1148 . A = B*C;
114-1149 .
114-1150 . if (A > B)
114-1151 . {
114-1152 . A = B + C;
114-1153 . D = E + F;
114-1154 . }
114-1155 .
114-1156 . A = B-C;
114-1157 .
114-1158 . if (A ge B)
114-1159 . {
114-1160 . A = B + C;
114-1161 . D = E + F;
114-1162 . }
114-1163 .
114-1164 . A = B-C;
114-1165 .
114-1166 . if (A lt B)
114-1167 . {
114-1168 . A = B + C;
114-1169 . D = E + F;
114-1170 . }
114-1171 .
114-1172 . A = B+C;
114-1173 . A = B*C;
114-1174 . A = B-C;
114-1175 . A = B/C;
114-1176 . A = B-C;
114-1177 .
114-1178 . if (A < = B)
114-1179 . {
114-1180 . A = B + C;
114-1181 . D = E + F;
114-1182 . }
114-1183 .
114-1184 .
114-1185 . switch (stp stuff)
114-1186 . {
114-1187 . case one:
114-1188 . {
114-1189 . run_this;
114-1190 . break;
114-1191 . }
114-1192 . case two:
114-1193 . {
114-1194 . run_this;
114-1195 . break;
114-1196 . }
114-1197 . default:
114-1198 . {
114-1199 . SwError;
114-1200 . }
114-1201 . }
114-1202 .
114-1203 . A = B+C;
114-1204 .
114-1205 . if (A gt B)
114-1206 . {
114-1207 . A = B + C;
114-1208 . D = E + F;
114-1209 . }
114-1210 .
114-1211 . A = B-C;
114-1212 . A = B-C;
114-1213 . A = B-C;
114-1214 . A = B/C;
114-1215 .
114-1216 . if (A ne B)
114-1217 . {
114-1218 . A = B + C;
114-1219 . D = E + F;
114-1220 . }
114-1221 .
114-1222 . A = B/C;
114-1223 . A = B+C;
114-1224 . A = B*C;
114-1225 .
114-1226 . if (A ne B)
114-1227 . {
114-1228 . A = B + C;
114-1229 . D = E + F;
114-1230 . }
114-1231 .
114-1232 . A = B*C;
114-1233 .
114-1234 . if {
114-1235 . X = Y + Z;
114-1236 . }
114-1237 . else {
114-1238 . halt;
114-1239 . }
114-1240 .
114-1241 . A = B/C;
114-1242 . A = B-C;
114-1243 .
114-1244 . if (A == B)
114-1245 . {
114-1246 . A = B + C;
114-1247 . D = E + F;
114-1248 . }
114-1249 .
114-1250 .
114-1251 . switch (stp stuff)
114-1252 . {
114-1253 . case one:
114-1254 . {
114-1255 . run_this;
114-1256 . break;
114-1257 . }
114-1258 . case two:
114-1259 . {
114-1260 . run_this;
114-1261 . break;
114-1262 . }
114-1263 . default:
114-1264 . {
114-1265 . SwError;
114-1266 . }
114-1267 . }
114-1268 .
114-1269 . A = B*C;
114-1270 . A = B/C;
114-1271 . A = B+C;
114-1272 .
114-1273 . if (A > = B)
114-1274 . {
114-1275 . A = B + C;
114-1276 . D = E + F;
114-1277 . }
114-1278 .
114-1279 . A = B*C;
114-1280 . A = (float)B + C;
114-1281 . A = B/C;
114-1282 .
114-1283 . if (A ne B)
114-1284 . {
114-1285 . A = B + C;
114-1286 . D = E + F;
114-1287 . }
114-1288 .
114-1289 . A = B/C;
114-1290 .
114-1291 . if (A lt B)
114-1292 . {
114-1293 . A = B + C;
114-1294 . D = E + F;
114-1295 . }
114-1296 .
114-1297 .
114-1298 . /* dead_block = C * D;
114-1299 . dead_block = E * F; */
114-1300 .
114-1301 . A = B-C;
114-1302 .
114-1303 . if (A le B)
114-1304 . {
114-1305 . A = B + C;
114-1306 . D = E + F;
114-1307 . }
114-1308 .
114-1309 . A = B-C;
114-1310 .
114-1311 . if (A le B)
114-1312 . {
114-1313 . A = B + C;
114-1314 . D = E + F;
114-1315 . }
114-1316 .
114-1317 . goto error;
114-1318 . A = B-C;
114-1319 . A = 0x0004;
114-1320 . A = B/C;
114-1321 .
114-1322 . if (A < B)
114-1323 . {
114-1324 . A = B + C;
114-1325 . D = E + F;
114-1326 . }
114-1327 .
114-1328 . A = B+C;
114-1329 . A = B*C;
114-1330 .
114-1331 . if (A == B)
114-1332 . {
114-1333 . A = B + C;
114-1334 . D = E + F;
114-1335 . }
114-1336 .
114-1337 . A = B*C;
114-1338 .
114-1339 . if (A < B)
114-1340 . {
114-1341 . A = B + C;
114-1342 . D = E + F;
114-1343 . }
114-1344 .
114-1345 . A = B+C;
114-1346 . /* LE SV TOC-2881 this is a stp-09.6.79 req to convert*/
114-1347 . A = B*C;
114-1348 .
114-1349 . if (A < B)
114-1350 . {
114-1351 . A = B + C;
114-1352 . D = E + F;
114-1353 . }
114-1354 .
114-1355 . A = B-C;
114-1356 . A = B-C;
114-1357 . A = B*C;
114-1358 . A = B+C;
114-1359 . // max LOC 84
114-1360 .
114-1361 . }
114-1362 .
114-1363 .
114-1364 . /*
114-1365 . -----------------------------------------------------------------------------
114-1366 . --| NAME: stp.9.7
114-1367 . --|
114-1368 . --| ABSTRACT:
114-1369 . --| This function does stp stuff.
114-1370 . --|
114-1371 . --| RETURNS:
114-1372 . --| NONE.
114-1373 . --|
114-1374 . ----------------------------------------------------------------------------
114-1375 . */
114-1376 . static void stp.9.7(void)
114-1377 . {
114-1378 . A = B-C;
114-1379 .
114-1380 . if (A le B)
114-1381 . {
114-1382 . A = B + C;
114-1383 . D = E + F;
114-1384 . }
114-1385 .
114-1386 .
114-1387 . /* dead_block = C * D;
114-1388 . dead_block = E * F; */
114-1389 .
114-1390 .
114-1391 . if (A ge B)
114-1392 . {
114-1393 . A = B + C;
114-1394 . D = E + F;
114-1395 . }
114-1396 .
114-1397 .
114-1398 . switch (stp stuff)
114-1399 . {
114-1400 . case one:
114-1401 . {
114-1402 . run_this;
114-1403 . break;
114-1404 . }
114-1405 . case two:
114-1406 . {
114-1407 . run_this;
114-1408 . break;
114-1409 . }
114-1410 . default:
114-1411 . {
114-1412 . SwError;
114-1413 . }
114-1414 . }
114-1415 .
114-1416 . goto error;
114-1417 .
114-1418 . if (A > = B)
114-1419 . {
114-1420 . A = B + C;
114-1421 . D = E + F;
114-1422 . }
114-1423 .
114-1424 . A = B/C;
114-1425 . A = B+C;
114-1426 . A = B*C;
114-1427 . A = B*C;
114-1428 . A = B-C;
114-1429 .
114-1430 . if (A lt B)
114-1431 . {
114-1432 . A = B + C;
114-1433 . D = E + F;
114-1434 . }
114-1435 .
114-1436 . A = B/C;
114-1437 . A = B-C;
114-1438 . A = B-C;
114-1439 . A = B*C;
114-1440 . A = B/C;
114-1441 .
114-1442 . if (A != B)
114-1443 . {
114-1444 . A = B + C;
114-1445 . D = E + F;
114-1446 . }
114-1447 .
114-1448 . A = B+C;
114-1449 .
114-1450 . if (A lt B)
114-1451 . {
114-1452 . A = B + C;
114-1453 . D = E + F;
114-1454 . }
114-1455 .
114-1456 . A = B+C;
114-1457 . /* LE SV TOC-2882 this is a stp-09.7.21 req to increment*/
114-1458 . A = B+C;
114-1459 . A = B+C;
114-1460 . A = B*C;
114-1461 .
114-1462 . if (A gt B)
114-1463 . {
114-1464 . A = B + C;
114-1465 . D = E + F;
114-1466 . }
114-1467 .
114-1468 . A = B+C;
114-1469 .
114-1470 . if (A gt B)
114-1471 . {
114-1472 . A = B + C;
114-1473 . D = E + F;
114-1474 . }
114-1475 .
114-1476 . A = B+C;
114-1477 . // max LOC 27
114-1478 .
114-1479 . }
114-1480 .
114 114 Result: result/source/ft-app/ft-app-B1.0/stp/stp-09.c
115 115 Source: source/ft-app/ft-app-B1.0/stp/stp-10.c
115-0 . /*
115-1 . ----------------------------------------------------------------------------
115-2 . --| BEGIN PROLOGUE
115-3 . --|
115-4 . --| CLASSIFICATION: UNCLASSIFIED
115-5 . --|
115-6 . --| FILE NAME: stp-10.c
115-7 . --|
115-8 . --| ABSTRACT:
115-9 . --| This file contains the 2 functions that do file stp stuff.
115-10 . --|
115-11 . --| HISTORY:
115-12 . --| CCCQ_NAME:
115-13 . --| CCCQ_VER:
115-14 . --|
115-15 . --| END PROLOGUE
115-16 . ----------------------------------------------------------------------------
115-17 . */
115-18 .
115-19 . #define C;
115-20 . #define C;
115-21 . #include C;
115-22 . #define D;
115-23 .
115-24 .
115-25 .
115-26 . /*
115-27 . -----------------------------------------------------------------------------
115-28 . --| NAME: stp.10.1
115-29 . --|
115-30 . --| ABSTRACT:
115-31 . --| This function does stp stuff.
115-32 . --|
115-33 . --| RETURNS:
115-34 . --| NONE.
115-35 . --|
115-36 . ----------------------------------------------------------------------------
115-37 . */
115-38 . static void stp.10.1(void)
115-39 . {
115-40 . A = (int)B + C;
115-41 .
115-42 . if (A != B)
115-43 . {
115-44 . A = B + C;
115-45 . D = E + F;
115-46 . }
115-47 .
115-48 . A = B-C;
115-49 . A = B*C;
115-50 .
115-51 . if (A eq B)
115-52 . {
115-53 . A = B + C;
115-54 . D = E + F;
115-55 . }
115-56 .
115-57 . A = B-C;
115-58 . A = B+C;
115-59 . A = B/C;
115-60 .
115-61 . if (A ne B)
115-62 . {
115-63 . A = B + C;
115-64 . D = E + F;
115-65 . }
115-66 .
115-67 .
115-68 . if (A > B)
115-69 . {
115-70 . A = B + C;
115-71 . D = E + F;
115-72 . }
115-73 .
115-74 . A = B*C;
115-75 . A = B*C;
115-76 . /* LE SV TOC-2883 this is a stp-10.1.12 req to check unix*/
115-77 .
115-78 . if (A ne B)
115-79 . {
115-80 . A = B + C;
115-81 . D = E + F;
115-82 . }
115-83 .
115-84 .
115-85 . if (A != B)
115-86 . {
115-87 . A = B + C;
115-88 . D = E + F;
115-89 . }
115-90 .
115-91 .
115-92 . switch (stp stuff)
115-93 . {
115-94 . case one:
115-95 . {
115-96 . run_this;
115-97 . break;
115-98 . }
115-99 . case two:
115-100 . {
115-101 . run_this;
115-102 . break;
115-103 . }
115-104 . default:
115-105 . {
115-106 . SwError;
115-107 . }
115-108 . }
115-109 .
115-110 .
115-111 . if (A gt B)
115-112 . {
115-113 . A = B + C;
115-114 . D = E + F;
115-115 . }
115-116 .
115-117 .
115-118 . if (A != B)
115-119 . {
115-120 . A = B + C;
115-121 . D = E + F;
115-122 . }
115-123 .
115-124 . A = B+C;
115-125 .
115-126 . if (A == B)
115-127 . {
115-128 . A = B + C;
115-129 . D = E + F;
115-130 . }
115-131 .
115-132 . A = B*C;
115-133 . A = B/C;
115-134 . A = B/C;
115-135 . A = B*C;
115-136 .
115-137 . if (A lt B)
115-138 . {
115-139 . A = B + C;
115-140 . D = E + F;
115-141 . }
115-142 .
115-143 . A = B-C;
115-144 . /* LE SV TOC-2884 this is a stp-10.1.25 req to increment*/
115-145 . A = B*C;
115-146 . A = B/C;
115-147 . A = B/C;
115-148 . A = B*C;
115-149 . A = B*C;
115-150 . A = B-C;
115-151 .
115-152 . if (A > B)
115-153 . {
115-154 . A = B + C;
115-155 . D = E + F;
115-156 . }
115-157 .
115-158 . A = B*C;
115-159 . A = B*C;
115-160 . A = B+C;
115-161 . A = B+C;
115-162 .
115-163 . if (A != B)
115-164 . {
115-165 . A = B + C;
115-166 . D = E + F;
115-167 . }
115-168 .
115-169 .
115-170 . if (A ne B)
115-171 . {
115-172 . A = B + C;
115-173 . D = E + F;
115-174 . }
115-175 .
115-176 . A = B/C;
115-177 . A = B*C;
115-178 . // max LOC 39
115-179 .
115-180 . }
115-181 .
115-182 .
115-183 . /*
115-184 . -----------------------------------------------------------------------------
115-185 . --| NAME: stp.10.2
115-186 . --|
115-187 . --| ABSTRACT:
115-188 . --| This function does stp stuff.
115-189 . --|
115-190 . --| RETURNS:
115-191 . --| NONE.
115-192 . --|
115-193 . ----------------------------------------------------------------------------
115-194 . */
115-195 . static void stp.10.2(void)
115-196 . {
115-197 . A = B/C;
115-198 .
115-199 . if (A != B)
115-200 . {
115-201 . A = B + C;
115-202 . D = E + F;
115-203 . }
115-204 .
115-205 . A = B*C;
115-206 .
115-207 . if (A > = B)
115-208 . {
115-209 . A = B + C;
115-210 . D = E + F;
115-211 . }
115-212 .
115-213 .
115-214 . if (A eq B)
115-215 . {
115-216 . A = B + C;
115-217 . D = E + F;
115-218 . }
115-219 .
115-220 .
115-221 . if (A != B)
115-222 . {
115-223 . A = B + C;
115-224 . D = E + F;
115-225 . }
115-226 .
115-227 . A = B-C;
115-228 .
115-229 . if (A < B)
115-230 . {
115-231 . A = B + C;
115-232 . D = E + F;
115-233 . }
115-234 .
115-235 . A = B-C;
115-236 . A = B-C;
115-237 .
115-238 . if (A lt B)
115-239 . {
115-240 . A = B + C;
115-241 . D = E + F;
115-242 . }
115-243 .
115-244 . A = B*C;
115-245 . A = B-C;
115-246 . // TBS - I need to figure this out
115-247 .
115-248 . if (A != B)
115-249 . {
115-250 . A = B + C;
115-251 . D = E + F;
115-252 . }
115-253 .
115-254 .
115-255 . if (A le B)
115-256 . {
115-257 . A = B + C;
115-258 . D = E + F;
115-259 . }
115-260 .
115-261 . A = B/C;
115-262 .
115-263 . if (A ge B)
115-264 . {
115-265 . A = B + C;
115-266 . D = E + F;
115-267 . }
115-268 .
115-269 .
115-270 . if (A != B)
115-271 . {
115-272 . A = B + C;
115-273 . D = E + F;
115-274 . }
115-275 .
115-276 . A = B-C;
115-277 .
115-278 . if (A le B)
115-279 . {
115-280 . A = B + C;
115-281 . D = E + F;
115-282 . }
115-283 .
115-284 . A = B+C;
115-285 . A = B+C;
115-286 . A = B+C;
115-287 . A = B+C;
115-288 .
115-289 . if (A < = B)
115-290 . {
115-291 . A = B + C;
115-292 . D = E + F;
115-293 . }
115-294 .
115-295 . /* LE SV TOC-2885 this is a stp-10.2.26 req to enable*/
115-296 . A = 0x0003;
115-297 .
115-298 . if (A eq B)
115-299 . {
115-300 . A = B + C;
115-301 . D = E + F;
115-302 . }
115-303 .
115-304 .
115-305 . if (A le B)
115-306 . {
115-307 . A = B + C;
115-308 . D = E + F;
115-309 . }
115-310 .
115-311 . A = B+C;
115-312 .
115-313 . if (A < = B)
115-314 . {
115-315 . A = B + C;
115-316 . D = E + F;
115-317 . }
115-318 .
115-319 . A = B*C;
115-320 .
115-321 . if (A < B)
115-322 . {
115-323 . A = B + C;
115-324 . D = E + F;
115-325 . }
115-326 .
115-327 . // max LOC 31
115-328 .
115-329 . }
115-330 .
115 115 Result: result/source/ft-app/ft-app-B1.0/stp/stp-10.c
116 116 Source: source/ft-app/ft-app-B1.0/stp/stp-11.c
116-0 . /*
116-1 . ----------------------------------------------------------------------------
116-2 . --| BEGIN PROLOGUE
116-3 . --|
116-4 . --| CLASSIFICATION: UNCLASSIFIED
116-5 . --|
116-6 . --| FILE NAME: stp-11.c
116-7 . --|
116-8 . --| ABSTRACT:
116-9 . --| This file contains the 1 functions that do file stp stuff.
116-10 . --|
116-11 . --| HISTORY:
116-12 . --| CCCQ_NAME:
116-13 . --| CCCQ_VER:
116-14 . --|
116-15 . --| END PROLOGUE
116-16 . ----------------------------------------------------------------------------
116-17 . */
116-18 .
116-19 . int A;
116-20 . double C;
116-21 . #define A;
116-22 . int A;
116-23 .
116-24 .
116-25 .
116-26 . /*
116-27 . -----------------------------------------------------------------------------
116-28 . --| NAME: stp.11.1
116-29 . --|
116-30 . --| ABSTRACT:
116-31 . --| This function does stp stuff.
116-32 . --|
116-33 . --| RETURNS:
116-34 . --| NONE.
116-35 . --|
116-36 . ----------------------------------------------------------------------------
116-37 . */
116-38 . static void stp.11.1(void)
116-39 . {
116-40 . A = B+C;
116-41 .
116-42 . switch (stp stuff)
116-43 . {
116-44 . case one:
116-45 . {
116-46 . run_this;
116-47 . break;
116-48 . }
116-49 . case two:
116-50 . {
116-51 . run_this;
116-52 . break;
116-53 . }
116-54 . default:
116-55 . {
116-56 . SwError;
116-57 . }
116-58 . }
116-59 .
116-60 .
116-61 . if (A < = B)
116-62 . {
116-63 . A = B + C;
116-64 . D = E + F;
116-65 . }
116-66 .
116-67 . /* LE SV TOC-2886 this is a stp-11.1.4 req to compare*/
116-68 . A = 0x0001;
116-69 . A = B/C;
116-70 . A = B-C;
116-71 . A = B+C;
116-72 .
116-73 . if (A ge B)
116-74 . {
116-75 . A = B + C;
116-76 . D = E + F;
116-77 . }
116-78 .
116-79 . A = B+C;
116-80 . A = B-C;
116-81 .
116-82 . if (A < = B)
116-83 . {
116-84 . A = B + C;
116-85 . D = E + F;
116-86 . }
116-87 .
116-88 . A = B*C;
116-89 . A = B-C;
116-90 . A = B*C;
116-91 . /* LE SV TOC-2887 this is a stp-11.1.14 req to transform*/
116-92 . A = B-C;
116-93 .
116-94 . if (A ne B)
116-95 . {
116-96 . A = B + C;
116-97 . D = E + F;
116-98 . }
116-99 .
116-100 .
116-101 . if (A > = B)
116-102 . {
116-103 . A = B + C;
116-104 . D = E + F;
116-105 . }
116-106 .
116-107 .
116-108 . if (A != B)
116-109 . {
116-110 . A = B + C;
116-111 . D = E + F;
116-112 . }
116-113 .
116-114 .
116-115 . if (A > = B)
116-116 . {
116-117 . A = B + C;
116-118 . D = E + F;
116-119 . }
116-120 .
116-121 . A = B*C;
116-122 . A = B-C;
116-123 .
116-124 . if (A != B)
116-125 . {
116-126 . A = B + C;
116-127 . D = E + F;
116-128 . }
116-129 .
116-130 . A = B/C;
116-131 . A = B-C;
116-132 . A = B/C;
116-133 . A = B-C;
116-134 . A = B*C;
116-135 . A = B/C;
116-136 . A = B-C;
116-137 . A = B/C;
116-138 . A = B-C;
116-139 .
116-140 . if (A le B)
116-141 . {
116-142 . A = B + C;
116-143 . D = E + F;
116-144 . }
116-145 .
116-146 . /* LE SV TOC-2888 this is a stp-11.1.32 req to reject*/
116-147 . A = B+C;
116-148 . A = B/C;
116-149 . A = B+C;
116-150 . A = B*C;
116-151 . A = B+C;
116-152 . A = B/C;
116-153 . A = B+C;
116-154 .
116-155 . if (A < B)
116-156 . {
116-157 . A = B + C;
116-158 . D = E + F;
116-159 . }
116-160 .
116-161 . A = B-C;
116-162 .
116-163 . if (A eq B)
116-164 . {
116-165 . A = B + C;
116-166 . D = E + F;
116-167 . }
116-168 .
116-169 . A = B+C;
116-170 . A = B+C;
116-171 .
116-172 . if (A > = B)
116-173 . {
116-174 . A = B + C;
116-175 . D = E + F;
116-176 . }
116-177 .
116-178 . /* LE SV TOC-2889 this is a stp-11.1.45 req to audit*/
116-179 . A = B/C;
116-180 .
116-181 . if (A ne B)
116-182 . {
116-183 . A = B + C;
116-184 . D = E + F;
116-185 . }
116-186 .
116-187 . A = B*C;
116-188 .
116-189 . if (A < B)
116-190 . {
116-191 . A = B + C;
116-192 . D = E + F;
116-193 . }
116-194 .
116-195 . A = B*C;
116-196 . A = B-C;
116-197 .
116-198 . if (A < = B)
116-199 . {
116-200 . A = B + C;
116-201 . D = E + F;
116-202 . }
116-203 .
116-204 . A = B/C;
116-205 . A = B*C;
116-206 . A = B/C;
116-207 . A = B-C;
116-208 . A = B/C;
116-209 . A = B/C;
116-210 . A = B-C;
116-211 . A = B+C;
116-212 . /* LE SV TOC-2890 this is a stp-11.1.60 req to call isr*/
116-213 . A = B*C;
116-214 . A = B*C;
116-215 . /* LE SV TOC-2891 this is a stp-11.1.62 req to verify*/
116-216 . A = B+C;
116-217 . A = B+C;
116-218 . A = B/C;
116-219 . A = B-C;
116-220 . A = B/C;
116-221 . /* LE SV TOC-2892 this is a stp-11.1.67 req to check pSOS*/
116-222 . A = B/C;
116-223 . A = B-C;
116-224 . A = B*C;
116-225 . A = B-C;
116-226 . A = B/C;
116-227 . // max LOC 71
116-228 .
116-229 . }
116-230 .
116 116 Result: result/source/ft-app/ft-app-B1.0/stp/stp-11.c
117 117 Source: source/ft-app/ft-app-B1.0/stp/stp-12.c
117-0 . /*
117-1 . ----------------------------------------------------------------------------
117-2 . --| BEGIN PROLOGUE
117-3 . --|
117-4 . --| CLASSIFICATION: UNCLASSIFIED
117-5 . --|
117-6 . --| FILE NAME: stp-12.c
117-7 . --|
117-8 . --| ABSTRACT:
117-9 . --| This file contains the 6 functions that do file stp stuff.
117-10 . --|
117-11 . --| HISTORY:
117-12 . --| CCCQ_NAME:
117-13 . --| CCCQ_VER:
117-14 . --|
117-15 . --| END PROLOGUE
117-16 . ----------------------------------------------------------------------------
117-17 . */
117-18 .
117-19 . char D;
117-20 . #include A;
117-21 . #include D;
117-22 .
117-23 .
117-24 .
117-25 . /*
117-26 . -----------------------------------------------------------------------------
117-27 . --| NAME: stp.12.1
117-28 . --|
117-29 . --| ABSTRACT:
117-30 . --| This function does stp stuff.
117-31 . --|
117-32 . --| RETURNS:
117-33 . --| NONE.
117-34 . --|
117-35 . ----------------------------------------------------------------------------
117-36 . */
117-37 . static void stp.12.1(void)
117-38 . {
117-39 . A = 0x0001;
117-40 . A = B+C;
117-41 . A = B-C;
117-42 .
117-43 . if (A > B)
117-44 . {
117-45 . A = B + C;
117-46 . D = E + F;
117-47 . }
117-48 .
117-49 . A = B+C;
117-50 .
117-51 . if (A != B)
117-52 . {
117-53 . A = B + C;
117-54 . D = E + F;
117-55 . }
117-56 .
117-57 .
117-58 . if (A eq B)
117-59 . {
117-60 . A = B + C;
117-61 . D = E + F;
117-62 . }
117-63 .
117-64 . /* LE SV TOC-2893 this is a stp-12.1.7 req to check pSOS*/
117-65 . A = B*C;
117-66 .
117-67 . if (A > B)
117-68 . {
117-69 . A = B + C;
117-70 . D = E + F;
117-71 . }
117-72 .
117-73 . A = B-C;
117-74 . A = B-C;
117-75 . A = B+C;
117-76 .
117-77 . if (A == B)
117-78 . {
117-79 . A = B + C;
117-80 . D = E + F;
117-81 . }
117-82 .
117-83 . A = B+C;
117-84 . // TBD - what do I do now
117-85 .
117-86 . if (A > B)
117-87 . {
117-88 . A = B + C;
117-89 . D = E + F;
117-90 . }
117-91 .
117-92 .
117-93 . if (A < = B)
117-94 . {
117-95 . A = B + C;
117-96 . D = E + F;
117-97 . }
117-98 .
117-99 . A = B/C;
117-100 .
117-101 . if (A != B)
117-102 . {
117-103 . A = B + C;
117-104 . D = E + F;
117-105 . }
117-106 .
117-107 .
117-108 . if (A > B)
117-109 . {
117-110 . A = B + C;
117-111 . D = E + F;
117-112 . }
117-113 .
117-114 . A = B-C;
117-115 . A = B-C;
117-116 . A = B*C;
117-117 . A = B-C;
117-118 .
117-119 . /*
117-120 . dead_code = B - C;
117-121 . dead_code = D - E;
117-122 . dead_code = F - G;
117-123 . */
117-124 .
117-125 .
117-126 . if (A == B)
117-127 . {
117-128 . A = B + C;
117-129 . D = E + F;
117-130 . }
117-131 .
117-132 . A = B*C;
117-133 . A = B-C;
117-134 . A = B+C;
117-135 .
117-136 . if (A ne B)
117-137 . {
117-138 . A = B + C;
117-139 . D = E + F;
117-140 . }
117-141 .
117-142 .
117-143 . if (A == B)
117-144 . {
117-145 . A = B + C;
117-146 . D = E + F;
117-147 . }
117-148 .
117-149 . A = B*C;
117-150 .
117-151 . switch (stp stuff)
117-152 . {
117-153 . case one:
117-154 . {
117-155 . run_this;
117-156 . // missing break
117-157 . }
117-158 . case two:
117-159 . {
117-160 . run_this;
117-161 . break;
117-162 . }
117-163 . default:
117-164 . {
117-165 . SwError;
117-166 . }
117-167 . }
117-168 .
117-169 . A = B-C;
117-170 .
117-171 . if (A < = B)
117-172 . {
117-173 . A = B + C;
117-174 . D = E + F;
117-175 . }
117-176 .
117-177 .
117-178 . if (A < = B)
117-179 . {
117-180 . A = B + C;
117-181 . D = E + F;
117-182 . }
117-183 .
117-184 . A = B/C;
117-185 . A = B/C;
117-186 .
117-187 . if (A eq B)
117-188 . {
117-189 . A = B + C;
117-190 . D = E + F;
117-191 . }
117-192 .
117-193 . A = B/C;
117-194 .
117-195 . if (veg)
117-196 . // missing curly brace
117-197 . variable = orange;
117-198 .
117-199 . A = B+C;
117-200 . A = B*C;
117-201 . A = B+C;
117-202 .
117-203 . if (A != B)
117-204 . {
117-205 . A = B + C;
117-206 . D = E + F;
117-207 . }
117-208 .
117-209 .
117-210 . if (A ge B)
117-211 . {
117-212 . A = B + C;
117-213 . D = E + F;
117-214 . }
117-215 .
117-216 . A = B/C;
117-217 . A = B/C;
117-218 . A = B/C;
117-219 . A = B+C;
117-220 . A = B+C;
117-221 . A = B-C;
117-222 . // max LOC 47
117-223 .
117-224 . }
117-225 .
117-226 .
117-227 . /*
117-228 . -----------------------------------------------------------------------------
117-229 . --| NAME: stp.12.2
117-230 . --|
117-231 . --| ABSTRACT:
117-232 . --| This function does stp stuff.
117-233 . --|
117-234 . --| RETURNS:
117-235 . --| NONE.
117-236 . --|
117-237 . ----------------------------------------------------------------------------
117-238 . */
117-239 . static void stp.12.2(void)
117-240 . {
117-241 . A = B+C;
117-242 . /* LE SV TOC-2894 this is a stp-12.2.2 req to assign*/
117-243 .
117-244 . if (A > = B)
117-245 . {
117-246 . A = B + C;
117-247 . D = E + F;
117-248 . }
117-249 .
117-250 .
117-251 . if (A == B)
117-252 . {
117-253 . A = B + C;
117-254 . D = E + F;
117-255 . }
117-256 .
117-257 . A = B-C;
117-258 . A = B-C;
117-259 . A = B+C;
117-260 .
117-261 . if (A != B)
117-262 . {
117-263 . A = B + C;
117-264 . D = E + F;
117-265 . }
117-266 .
117-267 .
117-268 . if (A gt B)
117-269 . {
117-270 . A = B + C;
117-271 . D = E + F;
117-272 . }
117-273 .
117-274 . A = B*C;
117-275 . A = B-C;
117-276 . A = B+C;
117-277 . A = 0x0009;
117-278 . A = B+C;
117-279 .
117-280 . if (A != B)
117-281 . {
117-282 . A = B + C;
117-283 . D = E + F;
117-284 . }
117-285 .
117-286 . A = B+C;
117-287 . A = B/C;
117-288 .
117-289 . if (A < = B)
117-290 . {
117-291 . A = B + C;
117-292 . D = E + F;
117-293 . }
117-294 .
117-295 .
117-296 . /*
117-297 . dead_code = B - C;
117-298 . dead_code = D - E;
117-299 . dead_code = F - G;
117-300 . */
117-301 .
117-302 . A = B*C;
117-303 . A = B+C;
117-304 . A = B+C;
117-305 . // max LOC 19
117-306 .
117-307 . }
117-308 .
117-309 .
117-310 . /*
117-311 . -----------------------------------------------------------------------------
117-312 . --| NAME: stp.12.3
117-313 . --|
117-314 . --| ABSTRACT:
117-315 . --| This function does stp stuff.
117-316 . --|
117-317 . --| RETURNS:
117-318 . --| NONE.
117-319 . --|
117-320 . ----------------------------------------------------------------------------
117-321 . */
117-322 . static void stp.12.3(void)
117-323 . {
117-324 . A = B*C;
117-325 . A = B-C;
117-326 . A = B-C;
117-327 .
117-328 . if (A ge B)
117-329 . {
117-330 . A = B + C;
117-331 . D = E + F;
117-332 . }
117-333 .
117-334 . A = B/C;
117-335 .
117-336 . if (A le B)
117-337 . {
117-338 . A = B + C;
117-339 . D = E + F;
117-340 . }
117-341 .
117-342 . A = B/C;
117-343 . // max LOC 7
117-344 .
117-345 . }
117-346 .
117-347 .
117-348 . /*
117-349 . -----------------------------------------------------------------------------
117-350 . --| NAME: stp.12.4
117-351 . --|
117-352 . --| ABSTRACT:
117-353 . --| This function does stp stuff.
117-354 . --|
117-355 . --| RETURNS:
117-356 . --| NONE.
117-357 . --|
117-358 . ----------------------------------------------------------------------------
117-359 . */
117-360 . static void stp.12.4(void)
117-361 . {
117-362 . A = B+C;
117-363 . A = B/C;
117-364 . A = B/C;
117-365 . A = 0x0003;
117-366 . A = B-C;
117-367 . A = B*C;
117-368 .
117-369 . if (A < = B)
117-370 . {
117-371 . A = B + C;
117-372 . D = E + F;
117-373 . }
117-374 .
117-375 . /* LE SV TOC-2895 this is a stp-12.4.7 req to increment*/
117-376 . A = B/C;
117-377 . A = B*C;
117-378 . A = B*C;
117-379 . A = B/C;
117-380 .
117-381 . if (A ge B)
117-382 . {
117-383 . A = B + C;
117-384 . D = E + F;
117-385 . }
117-386 .
117-387 . A = B*C;
117-388 . A = B*C;
117-389 .
117-390 . if (A ge B)
117-391 . {
117-392 . A = B + C;
117-393 . D = E + F;
117-394 . }
117-395 .
117-396 .
117-397 . if (A eq B)
117-398 . {
117-399 . A = B + C;
117-400 . D = E + F;
117-401 . }
117-402 .
117-403 .
117-404 . if (A > B)
117-405 . {
117-406 . A = B + C;
117-407 . D = E + F;
117-408 . }
117-409 .
117-410 . A = B-C;
117-411 .
117-412 . switch (stp stuff)
117-413 . {
117-414 . case one:
117-415 . {
117-416 . run_this;
117-417 . break;
117-418 . }
117-419 . case two:
117-420 . {
117-421 . run_this;
117-422 . break;
117-423 . }
117-424 . default:
117-425 . {
117-426 . SwError;
117-427 . }
117-428 . }
117-429 .
117-430 .
117-431 . switch (stp stuff)
117-432 . {
117-433 . case one:
117-434 . {
117-435 . run_this;
117-436 . break;
117-437 . }
117-438 . case two:
117-439 . {
117-440 . run_this;
117-441 . break;
117-442 . }
117-443 . default:
117-444 . {
117-445 . SwError;
117-446 . }
117-447 . }
117-448 .
117-449 . /* LE SV TOC-2896 this is a stp-12.4.20 req to check pSOS*/
117-450 .
117-451 . if (A != B)
117-452 . {
117-453 . A = B + C;
117-454 . D = E + F;
117-455 . }
117-456 .
117-457 .
117-458 . if (A le B)
117-459 . {
117-460 . A = B + C;
117-461 . D = E + F;
117-462 . }
117-463 .
117-464 . A = B+C;
117-465 . A = B+C;
117-466 .
117-467 . if (A < B)
117-468 . {
117-469 . A = B + C;
117-470 . D = E + F;
117-471 . }
117-472 .
117-473 .
117-474 . if (A == B)
117-475 . {
117-476 . A = B + C;
117-477 . D = E + F;
117-478 . }
117-479 .
117-480 .
117-481 . if (A > B)
117-482 . {
117-483 . A = B + C;
117-484 . D = E + F;
117-485 . }
117-486 .
117-487 . A = B*C;
117-488 . A = B*C;
117-489 . A = B-C;
117-490 . A = B*C;
117-491 .
117-492 . if (A gt B)
117-493 . {
117-494 . A = B + C;
117-495 . D = E + F;
117-496 . }
117-497 .
117-498 . /* LE SV TOC-2897 this is a stp-12.4.32 req to compare*/
117-499 . A = B*C;
117-500 . A = B-C;
117-501 . A = B/C;
117-502 . A = B*C;
117-503 . A = B*C;
117-504 . A = B/C;
117-505 . A = B-C;
117-506 . /* LE SV TOC-2898 this is a stp-12.4.39 req to fail*/
117-507 . A = B*C;
117-508 .
117-509 . if (A > = B)
117-510 . {
117-511 . A = B + C;
117-512 . D = E + F;
117-513 . }
117-514 .
117-515 . A = 0x0004;
117-516 .
117-517 . if (A > B)
117-518 . {
117-519 . A = B + C;
117-520 . D = E + F;
117-521 . }
117-522 .
117-523 . A = B*C;
117-524 . A = B/C;
117-525 . A = B*C;
117-526 . A = B*C;
117-527 . A = B*C;
117-528 . A = B*C;
117-529 . A = B*C;
117-530 . A = B/C;
117-531 .
117-532 . if (A gt B)
117-533 . {
117-534 . A = B + C;
117-535 . D = E + F;
117-536 . }
117-537 .
117-538 .
117-539 . if (A ne B)
117-540 . {
117-541 . A = B + C;
117-542 . D = E + F;
117-543 . }
117-544 .
117-545 .
117-546 . if (A lt B)
117-547 . {
117-548 . A = B + C;
117-549 . D = E + F;
117-550 . }
117-551 .
117-552 . A = B/C;
117-553 . A = B-C;
117-554 . A = B*C;
117-555 . A = B-C;
117-556 . /* LE SV TOC-2899 this is a stp-12.4.57 req to set RTC*/
117-557 .
117-558 . switch (stp stuff)
117-559 . {
117-560 . case one:
117-561 . {
117-562 . run_this;
117-563 . break;
117-564 . }
117-565 . case two:
117-566 . {
117-567 . run_this;
117-568 . break;
117-569 . }
117-570 . default:
117-571 . {
117-572 . SwError;
117-573 . }
117-574 . }
117-575 .
117-576 .
117-577 . switch (stp stuff)
117-578 . {
117-579 . case one:
117-580 . {
117-581 . run_this;
117-582 . // missing break
117-583 . }
117-584 . case two:
117-585 . {
117-586 . run_this;
117-587 . break;
117-588 . }
117-589 . default:
117-590 . {
117-591 . SwError;
117-592 . }
117-593 . }
117-594 .
117-595 . A = B*C;
117-596 . A = 0x0007;
117-597 . A = B-C;
117-598 . A = B*C;
117-599 . A = B*C;
117-600 . A = B/C;
117-601 . A = B-C;
117-602 . A = B+C;
117-603 .
117-604 . if (A lt B)
117-605 . {
117-606 . A = B + C;
117-607 . D = E + F;
117-608 . }
117-609 .
117-610 . /* LE SV TOC-2900 this is a stp-12.4.66 req to halt*/
117-611 . A = B-C;
117-612 .
117-613 . if (A ne B)
117-614 . {
117-615 . A = B + C;
117-616 . D = E + F;
117-617 . }
117-618 .
117-619 . A = B/C;
117-620 . A = B*C;
117-621 . A = B-C;
117-622 .
117-623 . if (A eq B)
117-624 . {
117-625 . A = B + C;
117-626 . D = E + F;
117-627 . }
117-628 .
117-629 . A = B/C;
117-630 . /* LE SV TOC-2901 this is a stp-12.4.73 req to store*/
117-631 .
117-632 . if (A eq B)
117-633 . {
117-634 . A = B + C;
117-635 . D = E + F;
117-636 . }
117-637 .
117-638 . A = B*C;
117-639 . A = B*C;
117-640 . A = B-C;
117-641 . A = B-C;
117-642 . A = B+C;
117-643 . A = B/C;
117-644 . // ??? go see ws
117-645 . A = B-C;
117-646 . A = B/C;
117-647 . A = B+C;
117-648 . /* LE SV TOC-2902 this is a stp-12.4.83 req to translate*/
117-649 .
117-650 . if (A != B)
117-651 . {
117-652 . A = B + C;
117-653 . D = E + F;
117-654 . }
117-655 .
117-656 .
117-657 . if (A == B)
117-658 . {
117-659 . A = B + C;
117-660 . D = E + F;
117-661 . }
117-662 .
117-663 . /* LE SV TOC-2903 this is a stp-12.4.85 req to check pSOS*/
117-664 . A = B/C;
117-665 .
117-666 . switch (stp stuff)
117-667 . {
117-668 . case one:
117-669 . {
117-670 . run_this;
117-671 . break;
117-672 . }
117-673 . case two:
117-674 . {
117-675 . run_this;
117-676 . break;
117-677 . }
117-678 . default:
117-679 . {
117-680 . SwError;
117-681 . }
117-682 . }
117-683 .
117-684 . A = B*C;
117-685 . /* LE SV TOC-2904 this is a stp-12.4.88 req to convert*/
117-686 . A = B-C;
117-687 . // max LOC 88
117-688 .
117-689 . }
117-690 .
117-691 .
117-692 . /*
117-693 . -----------------------------------------------------------------------------
117-694 . --| NAME: stp.12.5
117-695 . --|
117-696 . --| ABSTRACT:
117-697 . --| This function does stp stuff.
117-698 . --|
117-699 . --| RETURNS:
117-700 . --| NONE.
117-701 . --|
117-702 . ----------------------------------------------------------------------------
117-703 . */
117-704 . static void stp.12.5(void)
117-705 . {
117-706 .
117-707 . if (A gt B)
117-708 . {
117-709 . A = B + C;
117-710 . D = E + F;
117-711 . }
117-712 .
117-713 .
117-714 . if (A > = B)
117-715 . {
117-716 . A = B + C;
117-717 . D = E + F;
117-718 . }
117-719 .
117-720 . A = B/C;
117-721 . A = B-C;
117-722 .
117-723 . switch (stp stuff)
117-724 . {
117-725 . case one:
117-726 . {
117-727 . switch (nested)
117-728 . {
117-729 . case:
117-730 . X = Y + Z;
117-731 . case:
117-732 . X = Y + Z;
117-733 . default:
117-734 . SwError;
117-735 . }
117-736 . }
117-737 . case two:
117-738 . {
117-739 . run_this;
117-740 . break;
117-741 . }
117-742 . default:
117-743 . {
117-744 . SwError;
117-745 . }
117-746 . }
117-747 .
117-748 . A = B+C;
117-749 . A = B*C;
117-750 . A = B/C;
117-751 . // max LOC 7
117-752 .
117-753 . }
117-754 .
117-755 .
117-756 . /*
117-757 . -----------------------------------------------------------------------------
117-758 . --| NAME: stp.12.6
117-759 . --|
117-760 . --| ABSTRACT:
117-761 . --| This function does stp stuff.
117-762 . --|
117-763 . --| RETURNS:
117-764 . --| NONE.
117-765 . --|
117-766 . ----------------------------------------------------------------------------
117-767 . */
117-768 . static void stp.12.6(void)
117-769 . {
117-770 .
117-771 . if (A le B)
117-772 . {
117-773 . A = B + C;
117-774 . D = E + F;
117-775 . }
117-776 .
117-777 . A = B-C;
117-778 . A = B-C;
117-779 . free(FreePtr);
117-780 . A = B/C;
117-781 . A = B/C;
117-782 . /* LE SV TOC-2905 this is a stp-12.6.6 req to inhibit*/
117-783 . A = B+C;
117-784 . A = B*C;
117-785 . /* LE SV TOC-2906 this is a stp-12.6.8 req to halt*/
117-786 . A = B+C;
117-787 . A = B/C;
117-788 . /* LE SV TOC-2907 this is a stp-12.6.10 req to store*/
117-789 .
117-790 . if (A < B)
117-791 . {
117-792 . A = B + C;
117-793 . D = E + F;
117-794 . }
117-795 .
117-796 . A = B/C;
117-797 . /* LE SV TOC-2908 this is a stp-12.6.12 req to process*/
117-798 . goto error;
117-799 . A = B/C;
117-800 .
117-801 . if (A eq B)
117-802 . {
117-803 . A = B + C;
117-804 . D = E + F;
117-805 . }
117-806 .
117-807 . A = B/C;
117-808 . A = B-C;
117-809 .
117-810 . if (A != B)
117-811 . {
117-812 . A = B + C;
117-813 . D = E + F;
117-814 . }
117-815 .
117-816 . A = B/C;
117-817 . A = B-C;
117-818 . A = B-C;
117-819 . A = B*C;
117-820 . A = B*C;
117-821 . A = B/C;
117-822 . A = B*C;
117-823 . A = B+C;
117-824 .
117-825 . if (A > B)
117-826 . {
117-827 . A = B + C;
117-828 . D = E + F;
117-829 . }
117-830 .
117-831 . A = B*C;
117-832 . A = B-C;
117-833 .
117-834 . if (A lt B)
117-835 . {
117-836 . A = B + C;
117-837 . D = E + F;
117-838 . }
117-839 .
117-840 . A = B*C;
117-841 . A = B/C;
117-842 . A = B-C;
117-843 . A = B-C;
117-844 . A = 0x0006;
117-845 .
117-846 . if (A lt B)
117-847 . {
117-848 . A = B + C;
117-849 . D = E + F;
117-850 . }
117-851 .
117-852 .
117-853 . if (A != B)
117-854 . {
117-855 . A = B + C;
117-856 . D = E + F;
117-857 . }
117-858 .
117-859 .
117-860 . if (A eq B)
117-861 . {
117-862 . A = B + C;
117-863 . D = E + F;
117-864 . }
117-865 .
117-866 .
117-867 . if (A gt B)
117-868 . {
117-869 . A = B + C;
117-870 . D = E + F;
117-871 . }
117-872 .
117-873 .
117-874 . if (A != B)
117-875 . {
117-876 . A = B + C;
117-877 . D = E + F;
117-878 . }
117-879 .
117-880 . A = B*C;
117-881 . /* LE SV TOC-2909 this is a stp-12.6.39 req to compare*/
117-882 . A = B*C;
117-883 . A = B+C;
117-884 . A = B+C;
117-885 . A = B-C;
117-886 . A = B*C;
117-887 . A = B+C;
117-888 . A = B+C;
117-889 . A = B/C;
117-890 . A = B*C;
117-891 .
117-892 . switch (stp stuff)
117-893 . {
117-894 . case one:
117-895 . {
117-896 . run_this;
117-897 . break;
117-898 . }
117-899 . case two:
117-900 . {
117-901 . run_this;
117-902 . break;
117-903 . }
117-904 . default:
117-905 . {
117-906 . // missing error call
117-907 . }
117-908 . }
117-909 .
117-910 .
117-911 . if (A < = B)
117-912 . {
117-913 . A = B + C;
117-914 . D = E + F;
117-915 . }
117-916 .
117-917 .
117-918 . if (A gt B)
117-919 . {
117-920 . A = B + C;
117-921 . D = E + F;
117-922 . }
117-923 .
117-924 . A = B/C;
117-925 . /* LE SV TOC-2910 this is a stp-12.6.51 req to recover*/
117-926 . A = B*C;
117-927 . A = B*C;
117-928 .
117-929 . if (A eq B)
117-930 . {
117-931 . A = B + C;
117-932 . D = E + F;
117-933 . }
117-934 .
117-935 .
117-936 . switch (stp stuff)
117-937 . {
117-938 . case one:
117-939 . {
117-940 . run_this;
117-941 . break;
117-942 . }
117-943 . case two:
117-944 . {
117-945 . run_this;
117-946 . break;
117-947 . }
117-948 . default:
117-949 . {
117-950 . SwError;
117-951 . }
117-952 . }
117-953 .
117-954 . A = B-C;
117-955 . // max LOC 55
117-956 .
117-957 . }
117-958 .
117 117 Result: result/source/ft-app/ft-app-B1.0/stp/stp-12.c
118 118 Source: source/ft-app/ft-app-B1.0/wxp/wxp-01.c
118-0 . /*
118-1 . ----------------------------------------------------------------------------
118-2 . --| BEGIN PROLOGUE
118-3 . --|
118-4 . --| CLASSIFICATION: UNCLASSIFIED
118-5 . --|
118-6 . --| FILE NAME: wxp-01.c
118-7 . --|
118-8 . --| ABSTRACT:
118-9 . --| This file contains the 5 functions that do file wxp stuff.
118-10 . --|
118-11 . --| HISTORY:
118-12 . --| CCCQ_NAME:
118-13 . --| CCCQ_VER:
118-14 . --|
118-15 . --| END PROLOGUE
118-16 . ----------------------------------------------------------------------------
118-17 . */
118-18 .
118-19 . char D;
118-20 . char D;
118-21 . #define B;
118-22 .
118-23 .
118-24 .
118-25 . /*
118-26 . -----------------------------------------------------------------------------
118-27 . --| NAME: wxp.1.1
118-28 . --|
118-29 . --| ABSTRACT:
118-30 . --| This function does wxp stuff.
118-31 . --|
118-32 . --| RETURNS:
118-33 . --| NONE.
118-34 . --|
118-35 . ----------------------------------------------------------------------------
118-36 . */
118-37 . static void wxp.1.1(void)
118-38 . {
118-39 .
118-40 . if (A != B)
118-41 . {
118-42 . A = B + C;
118-43 . D = E + F;
118-44 . }
118-45 .
118-46 .
118-47 . if (A le B)
118-48 . {
118-49 . A = B + C;
118-50 . D = E + F;
118-51 . }
118-52 .
118-53 . do forever;
118-54 . A = B-C;
118-55 .
118-56 . if (A == B)
118-57 . {
118-58 . A = B + C;
118-59 . D = E + F;
118-60 . }
118-61 .
118-62 . A = B/C;
118-63 . A = B-C;
118-64 . A = B+C;
118-65 . A = B*C;
118-66 . /* LE SV TOC-3001 this is a wxp-01.1.9 req to halt*/
118-67 . A = B-C;
118-68 . A = B+C;
118-69 . A = B*C;
118-70 .
118-71 . if (A != B)
118-72 . {
118-73 . A = B + C;
118-74 . D = E + F;
118-75 . }
118-76 .
118-77 .
118-78 . if (A != B)
118-79 . {
118-80 . A = B + C;
118-81 . D = E + F;
118-82 . }
118-83 .
118-84 . A = B-C;
118-85 . A = B+C;
118-86 . /* LE SV TOC-3002 this is a wxp-01.1.16 req to store*/
118-87 . A = B*C;
118-88 . A = B+C;
118-89 . A = B+C;
118-90 . A = B*C;
118-91 . A = B/C;
118-92 . A = B/C;
118-93 .
118-94 . if (A ge B)
118-95 . {
118-96 . A = B + C;
118-97 . D = E + F;
118-98 . }
118-99 .
118-100 .
118-101 . if (A le B)
118-102 . {
118-103 . A = B + C;
118-104 . D = E + F;
118-105 . }
118-106 .
118-107 . A = B+C;
118-108 . A = B/C;
118-109 . A = B*C;
118-110 .
118-111 . switch (wxp stuff)
118-112 . {
118-113 . case one:
118-114 . {
118-115 . run_this;
118-116 . break;
118-117 . }
118-118 . case two:
118-119 . {
118-120 . run_this;
118-121 . break;
118-122 . }
118-123 . default:
118-124 . {
118-125 . SwError;
118-126 . }
118-127 . }
118-128 .
118-129 . A = B-C;
118-130 . A = 0x0008;
118-131 . A = B+C;
118-132 . A = B*C;
118-133 . A = B-C;
118-134 . A = B-C;
118-135 . A = B*C;
118-136 .
118-137 . if (veg)
118-138 . // missing curly brace
118-139 . variable = orange;
118-140 .
118-141 .
118-142 . if (A == B)
118-143 . {
118-144 . A = B + C;
118-145 . D = E + F;
118-146 . }
118-147 .
118-148 . A = B/C;
118-149 . A = B/C;
118-150 . A = B-C;
118-151 . A = B*C;
118-152 .
118-153 . if (A le B)
118-154 . {
118-155 . A = B + C;
118-156 . D = E + F;
118-157 . }
118-158 .
118-159 . // max LOC 39
118-160 .
118-161 . }
118-162 .
118-163 .
118-164 . /*
118-165 . -----------------------------------------------------------------------------
118-166 . --| NAME: wxp.1.2
118-167 . --|
118-168 . --| ABSTRACT:
118-169 . --| This function does wxp stuff.
118-170 . --|
118-171 . --| RETURNS:
118-172 . --| NONE.
118-173 . --|
118-174 . ----------------------------------------------------------------------------
118-175 . */
118-176 . static void wxp.1.2(void)
118-177 . {
118-178 . A = B+C;
118-179 . A = B*C;
118-180 . A = B+C;
118-181 . A = B+C;
118-182 . A = B-C;
118-183 . A = B-C;
118-184 . A = B-C;
118-185 . A = B*C;
118-186 . A = B+C;
118-187 . A = B-C;
118-188 . A = B-C;
118-189 . A = B+C;
118-190 .
118-191 . switch (wxp stuff)
118-192 . {
118-193 . case one:
118-194 . {
118-195 . run_this;
118-196 . break;
118-197 . }
118-198 . case two:
118-199 . {
118-200 . run_this;
118-201 . break;
118-202 . }
118-203 . default:
118-204 . {
118-205 . SwError;
118-206 . }
118-207 . }
118-208 .
118-209 . A = B+C;
118-210 . A = B-C;
118-211 .
118-212 . if (A != B)
118-213 . {
118-214 . A = B + C;
118-215 . D = E + F;
118-216 . }
118-217 .
118-218 .
118-219 . if (A > B)
118-220 . {
118-221 . A = B + C;
118-222 . D = E + F;
118-223 . }
118-224 .
118-225 . /* LE SV TOC-3003 this is a wxp-01.2.18 req to fail*/
118-226 . A = B/C;
118-227 . A = B*C;
118-228 .
118-229 . if (A gt B)
118-230 . {
118-231 . A = B + C;
118-232 . D = E + F;
118-233 . }
118-234 .
118-235 . A = B-C;
118-236 . A = B/C;
118-237 . A = B-C;
118-238 .
118-239 . if (A > = B)
118-240 . {
118-241 . A = B + C;
118-242 . D = E + F;
118-243 . }
118-244 .
118-245 .
118-246 . if (A > = B)
118-247 . {
118-248 . A = B + C;
118-249 . D = E + F;
118-250 . }
118-251 .
118-252 . A = B-C;
118-253 . A = B/C;
118-254 . A = B*C;
118-255 . A = B*C;
118-256 . /* LE SV TOC-3004 this is a wxp-01.2.30 req to enable*/
118-257 . A = B*C;
118-258 .
118-259 . if (A != B)
118-260 . {
118-261 . A = B + C;
118-262 . D = E + F;
118-263 . }
118-264 .
118-265 .
118-266 . if (A > = B)
118-267 . {
118-268 . A = B + C;
118-269 . D = E + F;
118-270 . }
118-271 .
118-272 . A = B+C;
118-273 .
118-274 . /* dead_code = B + C;
118-275 . dead_code = D + E;
118-276 . dead_code = F + G; */
118-277 .
118-278 . A = B*C;
118-279 . A = 0x0003;
118-280 . A = B-C;
118-281 . A = B-C;
118-282 . /* LE SV TOC-3005 this is a wxp-01.2.37 req to assign*/
118-283 .
118-284 . switch (wxp stuff)
118-285 . {
118-286 . case one:
118-287 . {
118-288 . run_this;
118-289 . break;
118-290 . }
118-291 . case two:
118-292 . {
118-293 . run_this;
118-294 . break;
118-295 . }
118-296 . default:
118-297 . {
118-298 . SwError;
118-299 . }
118-300 . }
118-301 .
118-302 .
118-303 . if (A != B)
118-304 . {
118-305 . A = B + C;
118-306 . D = E + F;
118-307 . }
118-308 .
118-309 .
118-310 . if (A ne B)
118-311 . {
118-312 . A = B + C;
118-313 . D = E + F;
118-314 . }
118-315 .
118-316 . A = B+C;
118-317 .
118-318 . /*
118-319 . dead_code = B - C;
118-320 . dead_code = D - E;
118-321 . dead_code = F - G;
118-322 . */
118-323 .
118-324 . A = B/C;
118-325 . A = B*C;
118-326 .
118-327 . if (A ge B)
118-328 . {
118-329 . A = B + C;
118-330 . D = E + F;
118-331 . }
118-332 .
118-333 . A = B+C;
118-334 . A = B+C;
118-335 . A = B-C;
118-336 . A = B+C;
118-337 . A = B*C;
118-338 . A = B*C;
118-339 .
118-340 . if (A lt B)
118-341 . {
118-342 . A = B + C;
118-343 . D = E + F;
118-344 . }
118-345 .
118-346 . A = B-C;
118-347 . A = B+C;
118-348 . A = B-C;
118-349 . A = B+C;
118-350 . A = B*C;
118-351 . A = B-C;
118-352 . A = B-C;
118-353 .
118-354 . if (A != B)
118-355 . {
118-356 . A = B + C;
118-357 . D = E + F;
118-358 . }
118-359 .
118-360 . A = B-C;
118-361 . A = B*C;
118-362 . A = B/C;
118-363 .
118-364 . #ifdef LAZY
118-365 . // this is not nice
118-366 . A = B + C;
118-367 . A = B + C;
118-368 . #endif
118-369 .
118-370 . A = B+C;
118-371 . A = B*C;
118-372 . A = B-C;
118-373 .
118-374 . if (A lt B)
118-375 . {
118-376 . A = B + C;
118-377 . D = E + F;
118-378 . }
118-379 .
118-380 . A = B+C;
118-381 .
118-382 . switch (wxp stuff)
118-383 . {
118-384 . case one:
118-385 . {
118-386 . run_this;
118-387 . break;
118-388 . }
118-389 . case two:
118-390 . {
118-391 . run_this;
118-392 . break;
118-393 . }
118-394 . default:
118-395 . {
118-396 . // missing error call
118-397 . }
118-398 . }
118-399 .
118-400 .
118-401 . if (A == B)
118-402 . {
118-403 . A = B + C;
118-404 . D = E + F;
118-405 . }
118-406 .
118-407 .
118-408 . if (A < B)
118-409 . {
118-410 . A = B + C;
118-411 . D = E + F;
118-412 . }
118-413 .
118-414 . A = B+C;
118-415 . A = B+C;
118-416 . A = B+C;
118-417 . A = B/C;
118-418 . A = B-C;
118-419 . A = B+C;
118-420 . A = B/C;
118-421 . A = B*C;
118-422 .
118-423 . if (A < B)
118-424 . {
118-425 . A = B + C;
118-426 . D = E + F;
118-427 . }
118-428 .
118-429 . A = B*C;
118-430 .
118-431 . if (A > B)
118-432 . {
118-433 . A = B + C;
118-434 . D = E + F;
118-435 . }
118-436 .
118-437 . A = 0x0001;
118-438 .
118-439 . switch (wxp stuff)
118-440 . {
118-441 . case one:
118-442 . {
118-443 . switch (nested)
118-444 . {
118-445 . case:
118-446 . X = Y + Z;
118-447 . case:
118-448 . X = Y + Z;
118-449 . default:
118-450 . SwError;
118-451 . }
118-452 . }
118-453 . case two:
118-454 . {
118-455 . run_this;
118-456 . break;
118-457 . }
118-458 . default:
118-459 . {
118-460 . SwError;
118-461 . }
118-462 . }
118-463 .
118-464 .
118-465 . if (A == B)
118-466 . {
118-467 . A = B + C;
118-468 . D = E + F;
118-469 . }
118-470 .
118-471 .
118-472 . switch (wxp stuff)
118-473 . {
118-474 . case one:
118-475 . {
118-476 . run_this;
118-477 . break;
118-478 . }
118-479 . case two:
118-480 . {
118-481 . run_this;
118-482 . break;
118-483 . }
118-484 . default:
118-485 . {
118-486 . SwError;
118-487 . }
118-488 . }
118-489 .
118-490 .
118-491 . if (A > B)
118-492 . {
118-493 . A = B + C;
118-494 . D = E + F;
118-495 . }
118-496 .
118-497 . A = B*C;
118-498 . A = B/C;
118-499 . A = B+C;
118-500 . // max LOC 85
118-501 .
118-502 . }
118-503 .
118-504 .
118-505 . /*
118-506 . -----------------------------------------------------------------------------
118-507 . --| NAME: wxp.1.3
118-508 . --|
118-509 . --| ABSTRACT:
118-510 . --| This function does wxp stuff.
118-511 . --|
118-512 . --| RETURNS:
118-513 . --| NONE.
118-514 . --|
118-515 . ----------------------------------------------------------------------------
118-516 . */
118-517 . static void wxp.1.3(void)
118-518 . {
118-519 . A = B*C;
118-520 . A = B/C;
118-521 . A = B+C;
118-522 . A = B-C;
118-523 . /* LE SV TOC-3006 this is a wxp-01.3.5 req to reject*/
118-524 . A = B+C;
118-525 . goto error;
118-526 . A = B-C;
118-527 .
118-528 . switch (wxp stuff)
118-529 . {
118-530 . case:
118-531 . case:
118-532 . // stacked case statements but only if there is a new line in between
118-533 .
118-534 . case:
118-535 . case:
118-536 . case:
118-537 . {
118-538 . run_this;
118-539 . break;
118-540 . }
118-541 . default:
118-542 . {
118-543 . halt;
118-544 . }
118-545 . }
118-546 .
118-547 . A = B-C;
118-548 . A = B/C;
118-549 . A = B*C;
118-550 .
118-551 . if (A != B)
118-552 . {
118-553 . A = B + C;
118-554 . D = E + F;
118-555 . }
118-556 .
118-557 . A = B/C;
118-558 . A = B-C;
118-559 .
118-560 . if (A ne B)
118-561 . {
118-562 . A = B + C;
118-563 . D = E + F;
118-564 . }
118-565 .
118-566 . /* LE SV TOC-3007 this is a wxp-01.3.14 req to inhibit*/
118-567 .
118-568 . if (A > B)
118-569 . {
118-570 . A = B + C;
118-571 . D = E + F;
118-572 . }
118-573 .
118-574 . A = B*C;
118-575 . A = B+C;
118-576 .
118-577 . if (A lt B)
118-578 . {
118-579 . A = B + C;
118-580 . D = E + F;
118-581 . }
118-582 .
118-583 . A = B/C;
118-584 . A = B-C;
118-585 .
118-586 . if (A == B)
118-587 . {
118-588 . A = B + C;
118-589 . D = E + F;
118-590 . }
118-591 .
118-592 . A = B+C;
118-593 . A = (float)B + C;
118-594 .
118-595 . if (A > B)
118-596 . {
118-597 . A = B + C;
118-598 . D = E + F;
118-599 . }
118-600 .
118-601 .
118-602 . switch (wxp stuff)
118-603 . {
118-604 . case one:
118-605 . {
118-606 . run_this;
118-607 . break;
118-608 . }
118-609 . case two:
118-610 . {
118-611 . run_this;
118-612 . break;
118-613 . }
118-614 . default:
118-615 . {
118-616 . SwError;
118-617 . }
118-618 . }
118-619 .
118-620 . A = B-C;
118-621 .
118-622 . /*
118-623 . dead_block = C * D;
118-624 . dead_block = E * F;
118-625 . */
118-626 .
118-627 . A = B/C;
118-628 .
118-629 . switch (wxp stuff)
118-630 . {
118-631 . case one:
118-632 . {
118-633 . run_this;
118-634 . break;
118-635 . }
118-636 . case two:
118-637 . {
118-638 . run_this;
118-639 . break;
118-640 . }
118-641 . default:
118-642 . {
118-643 . SwError;
118-644 . }
118-645 . }
118-646 .
118-647 . A = B/C;
118-648 . A = B+C;
118-649 . A = B*C;
118-650 . A = B*C;
118-651 . A = 0x0001;
118-652 . A = B*C;
118-653 . A = B/C;
118-654 . A = B/C;
118-655 . A = B/C;
118-656 . /* LE SV TOC-3008 this is a wxp-01.3.35 req to detect error*/
118-657 . A = B/C;
118-658 . A = B-C;
118-659 . A = B-C;
118-660 . A = B+C;
118-661 . A = B*C;
118-662 .
118-663 . if (A le B)
118-664 . {
118-665 . A = B + C;
118-666 . D = E + F;
118-667 . }
118-668 .
118-669 . /* LE SV TOC-3009 this is a wxp-01.3.41 req to check unix*/
118-670 .
118-671 . if (A eq B)
118-672 . {
118-673 . A = B + C;
118-674 . D = E + F;
118-675 . }
118-676 .
118-677 . /* LE SV TOC-3010 this is a wxp-01.3.42 req to reject*/
118-678 . A = B/C;
118-679 .
118-680 . if (A == B)
118-681 . {
118-682 . A = B + C;
118-683 . D = E + F;
118-684 . }
118-685 .
118-686 . A = B/C;
118-687 . A = B-C;
118-688 . A = B*C;
118-689 .
118-690 . if (A != B)
118-691 . {
118-692 . A = B + C;
118-693 . D = E + F;
118-694 . }
118-695 .
118-696 . A = 0x0006;
118-697 . A = B+C;
118-698 . A = B/C;
118-699 . A = B+C;
118-700 . // TBS - I need to figure this out
118-701 . A = B/C;
118-702 .
118-703 . if (A < B)
118-704 . {
118-705 . A = B + C;
118-706 . D = E + F;
118-707 . }
118-708 .
118-709 . A = B/C;
118-710 . A = B-C;
118-711 . A = B/C;
118-712 . A = B/C;
118-713 .
118-714 . if (A == B)
118-715 . {
118-716 . A = B + C;
118-717 . D = E + F;
118-718 . }
118-719 .
118-720 .
118-721 . if (A < = B)
118-722 . {
118-723 . A = B + C;
118-724 . D = E + F;
118-725 . }
118-726 .
118-727 . A = B*C;
118-728 . A = B-C;
118-729 . // max LOC 60
118-730 .
118-731 . }
118-732 .
118-733 .
118-734 . /*
118-735 . -----------------------------------------------------------------------------
118-736 . --| NAME: wxp.1.4
118-737 . --|
118-738 . --| ABSTRACT:
118-739 . --| This function does wxp stuff.
118-740 . --|
118-741 . --| RETURNS:
118-742 . --| NONE.
118-743 . --|
118-744 . ----------------------------------------------------------------------------
118-745 . */
118-746 . static void wxp.1.4(void)
118-747 . {
118-748 . A = 0x0004;
118-749 . A = B+C;
118-750 . A = 0x0008;
118-751 . A = B-C;
118-752 . A = B-C;
118-753 .
118-754 . if (A > = B)
118-755 . {
118-756 . A = B + C;
118-757 . D = E + F;
118-758 . }
118-759 .
118-760 . A = B/C;
118-761 . A = B-C;
118-762 . A = B-C;
118-763 . A = B-C;
118-764 . A = 0x0008;
118-765 . A = B+C;
118-766 . A = B-C;
118-767 . A = B*C;
118-768 . send_buffer = (U16 *) malloc(size+1);
118-769 . A = B+C;
118-770 .
118-771 . if (A > = B)
118-772 . {
118-773 . A = B + C;
118-774 . D = E + F;
118-775 . }
118-776 .
118-777 . A = B-C;
118-778 . A = B*C;
118-779 . A = B*C;
118-780 . A = B+C;
118-781 . /* LE SV TOC-3011 this is a wxp-01.4.18 req to halt*/
118-782 . A = B-C;
118-783 . A = B*C;
118-784 . // (P) this is really improtant
118-785 .
118-786 . if (A == B)
118-787 . {
118-788 . A = B + C;
118-789 . D = E + F;
118-790 . }
118-791 .
118-792 . A = B/C;
118-793 . // max LOC 21
118-794 .
118-795 . }
118-796 .
118-797 .
118-798 . /*
118-799 . -----------------------------------------------------------------------------
118-800 . --| NAME: wxp.1.5
118-801 . --|
118-802 . --| ABSTRACT:
118-803 . --| This function does wxp stuff.
118-804 . --|
118-805 . --| RETURNS:
118-806 . --| NONE.
118-807 . --|
118-808 . ----------------------------------------------------------------------------
118-809 . */
118-810 . static void wxp.1.5(void)
118-811 . {
118-812 . A = B*C;
118-813 . A = B*C;
118-814 . A = B*C;
118-815 . A = B-C;
118-816 . A = B+C;
118-817 . A = B+C;
118-818 .
118-819 . if (A ge B)
118-820 . {
118-821 . A = B + C;
118-822 . D = E + F;
118-823 . }
118-824 .
118-825 . A = B-C;
118-826 . A = B+C;
118-827 .
118-828 . if (A lt B)
118-829 . {
118-830 . A = B + C;
118-831 . D = E + F;
118-832 . }
118-833 .
118-834 .
118-835 . if (A lt B)
118-836 . {
118-837 . A = B + C;
118-838 . D = E + F;
118-839 . }
118-840 .
118-841 . do forever;
118-842 .
118-843 . if (A eq B)
118-844 . {
118-845 . A = B + C;
118-846 . D = E + F;
118-847 . }
118-848 .
118-849 . A = B/C;
118-850 . A = B+C;
118-851 .
118-852 . if (A ge B)
118-853 . {
118-854 . A = B + C;
118-855 . D = E + F;
118-856 . }
118-857 .
118-858 . A = B*C;
118-859 . A = B/C;
118-860 . /* LE SV TOC-3012 this is a wxp-01.5.18 req to recover*/
118-861 .
118-862 . if (A lt B)
118-863 . {
118-864 . A = B + C;
118-865 . D = E + F;
118-866 . }
118-867 .
118-868 . A = B+C;
118-869 . A = B-C;
118-870 . A = B-C;
118-871 . A = B/C;
118-872 . /* LE SV TOC-3013 this is a wxp-01.5.23 req to detect error*/
118-873 . // ??? go see ws
118-874 .
118-875 . if (A != B)
118-876 . {
118-877 . A = B + C;
118-878 . D = E + F;
118-879 . }
118-880 .
118-881 . A = B+C;
118-882 . /* LE SV TOC-3014 this is a wxp-01.5.25 req to disable*/
118-883 . A = B-C;
118-884 .
118-885 . if (A < B)
118-886 . {
118-887 . A = B + C;
118-888 . D = E + F;
118-889 . }
118-890 .
118-891 .
118-892 . if (A ne B)
118-893 . {
118-894 . A = B + C;
118-895 . D = E + F;
118-896 . }
118-897 .
118-898 .
118-899 . if (A eq B)
118-900 . {
118-901 . A = B + C;
118-902 . D = E + F;
118-903 . }
118-904 .
118-905 .
118-906 . if (A gt B)
118-907 . {
118-908 . A = B + C;
118-909 . D = E + F;
118-910 . }
118-911 .
118-912 . A = B-C;
118-913 .
118-914 . if (A < B)
118-915 . {
118-916 . A = B + C;
118-917 . D = E + F;
118-918 . }
118-919 .
118-920 . A = B/C;
118-921 . rcv_buffer = (U16 *) alloc(size+1);
118-922 . A = B/C;
118-923 .
118-924 . if (A > = B)
118-925 . {
118-926 . A = B + C;
118-927 . D = E + F;
118-928 . }
118-929 .
118-930 . A = B/C;
118-931 .
118-932 . if (A > B)
118-933 . {
118-934 . A = B + C;
118-935 . D = E + F;
118-936 . }
118-937 .
118-938 . A = B*C;
118-939 .
118-940 . if (A == B)
118-941 . {
118-942 . A = B + C;
118-943 . D = E + F;
118-944 . }
118-945 .
118-946 .
118-947 . if (A ge B)
118-948 . {
118-949 . A = B + C;
118-950 . D = E + F;
118-951 . }
118-952 .
118-953 . A = B*C;
118-954 . A = B/C;
118-955 . A = B*C;
118-956 .
118-957 . if (A == B)
118-958 . {
118-959 . A = B + C;
118-960 . D = E + F;
118-961 . }
118-962 .
118-963 . A = B+C;
118-964 . A = B+C;
118-965 . A = B-C;
118-966 . A = B-C;
118-967 . A = (int)B + C;
118-968 .
118-969 . if (A eq B)
118-970 . {
118-971 . A = B + C;
118-972 . D = E + F;
118-973 . }
118-974 .
118-975 . A = B+C;
118-976 . A = B/C;
118-977 . A = B/C;
118-978 . A = B+C;
118-979 . A = B/C;
118-980 . // max LOC 53
118-981 .
118-982 . }
118-983 .
118 118 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-01.c
119 119 Source: source/ft-app/ft-app-B1.0/wxp/wxp-02.c
119-0 . /*
119-1 . ----------------------------------------------------------------------------
119-2 . --| BEGIN PROLOGUE
119-3 . --|
119-4 . --| CLASSIFICATION: UNCLASSIFIED
119-5 . --|
119-6 . --| FILE NAME: wxp-02.c
119-7 . --|
119-8 . --| ABSTRACT:
119-9 . --| This file contains the 8 functions that do file wxp stuff.
119-10 . --|
119-11 . --| HISTORY:
119-12 . --| CCCQ_NAME:
119-13 . --| CCCQ_VER:
119-14 . --|
119-15 . --| END PROLOGUE
119-16 . ----------------------------------------------------------------------------
119-17 . */
119-18 .
119-19 . double C;
119-20 . #define B;
119-21 . #define C;
119-22 . #define A;
119-23 . #include D;
119-24 .
119-25 .
119-26 .
119-27 . /*
119-28 . -----------------------------------------------------------------------------
119-29 . --| NAME: wxp.2.1
119-30 . --|
119-31 . --| ABSTRACT:
119-32 . --| This function does wxp stuff.
119-33 . --|
119-34 . --| RETURNS:
119-35 . --| NONE.
119-36 . --|
119-37 . ----------------------------------------------------------------------------
119-38 . */
119-39 . static void wxp.2.1(void)
119-40 . {
119-41 . A = B/C;
119-42 . A = B*C;
119-43 . A = B/C;
119-44 .
119-45 . if (A == B)
119-46 . {
119-47 . A = B + C;
119-48 . D = E + F;
119-49 . }
119-50 .
119-51 . /* LE SV TOC-3015 this is a wxp-02.1.5 req to recover*/
119-52 . A = B/C;
119-53 .
119-54 . if (A gt B)
119-55 . {
119-56 . A = B + C;
119-57 . D = E + F;
119-58 . }
119-59 .
119-60 . A = B+C;
119-61 .
119-62 . if (A > = B)
119-63 . {
119-64 . A = B + C;
119-65 . D = E + F;
119-66 . }
119-67 .
119-68 . A = B+C;
119-69 .
119-70 . if (A < = B)
119-71 . {
119-72 . A = B + C;
119-73 . D = E + F;
119-74 . }
119-75 .
119-76 . /* LE SV TOC-3016 this is a wxp-02.1.11 req to convert*/
119-77 . A = B/C;
119-78 .
119-79 . if (A > B)
119-80 . {
119-81 . A = B + C;
119-82 . D = E + F;
119-83 . }
119-84 .
119-85 . A = B+C;
119-86 . A = B+C;
119-87 .
119-88 . switch (wxp stuff)
119-89 . {
119-90 . case one:
119-91 . {
119-92 . switch (nested)
119-93 . {
119-94 . case:
119-95 . X = Y + Z;
119-96 . case:
119-97 . X = Y + Z;
119-98 . default:
119-99 . SwError;
119-100 . }
119-101 . }
119-102 . case two:
119-103 . {
119-104 . run_this;
119-105 . break;
119-106 . }
119-107 . default:
119-108 . {
119-109 . SwError;
119-110 . }
119-111 . }
119-112 .
119-113 . A = B-C;
119-114 . A = B*C;
119-115 .
119-116 . if (A > B)
119-117 . {
119-118 . A = B + C;
119-119 . D = E + F;
119-120 . }
119-121 .
119-122 . A = B-C;
119-123 .
119-124 . if (A ne B)
119-125 . {
119-126 . A = B + C;
119-127 . D = E + F;
119-128 . }
119-129 .
119-130 . A = 0x0006;
119-131 . A = B+C;
119-132 . do forever;
119-133 . A = B*C;
119-134 .
119-135 . if (A eq B)
119-136 . {
119-137 . A = B + C;
119-138 . D = E + F;
119-139 . }
119-140 .
119-141 . A = B+C;
119-142 . A = B-C;
119-143 . /* LE SV TOC-3017 this is a wxp-02.1.25 req to increment*/
119-144 .
119-145 . if (A > = B)
119-146 . {
119-147 . A = B + C;
119-148 . D = E + F;
119-149 . }
119-150 .
119-151 . A = B/C;
119-152 . A = B-C;
119-153 . A = B*C;
119-154 . A = B/C;
119-155 .
119-156 . if (A lt B)
119-157 . {
119-158 . A = B + C;
119-159 . D = E + F;
119-160 . }
119-161 .
119-162 . A = B-C;
119-163 . /* LE SV TOC-3018 this is a wxp-02.1.32 req to detect error*/
119-164 . A = B*C;
119-165 . A = B*C;
119-166 .
119-167 . if (A lt B)
119-168 . {
119-169 . A = B + C;
119-170 . D = E + F;
119-171 . }
119-172 .
119-173 .
119-174 . switch (wxp stuff)
119-175 . {
119-176 . case one:
119-177 . {
119-178 . run_this;
119-179 . // missing break
119-180 . }
119-181 . case two:
119-182 . {
119-183 . run_this;
119-184 . break;
119-185 . }
119-186 . default:
119-187 . {
119-188 . SwError;
119-189 . }
119-190 . }
119-191 .
119-192 .
119-193 . if (A gt B)
119-194 . {
119-195 . A = B + C;
119-196 . D = E + F;
119-197 . }
119-198 .
119-199 . A = B/C;
119-200 . // max LOC 36
119-201 .
119-202 . }
119-203 .
119-204 .
119-205 . /*
119-206 . -----------------------------------------------------------------------------
119-207 . --| NAME: wxp.2.2
119-208 . --|
119-209 . --| ABSTRACT:
119-210 . --| This function does wxp stuff.
119-211 . --|
119-212 . --| RETURNS:
119-213 . --| NONE.
119-214 . --|
119-215 . ----------------------------------------------------------------------------
119-216 . */
119-217 . static void wxp.2.2(void)
119-218 . {
119-219 . A = B/C;
119-220 .
119-221 . if (veg)
119-222 . // missing curly brace
119-223 . variable = orange;
119-224 .
119-225 . A = B/C;
119-226 . A = B+C;
119-227 .
119-228 . if (A < B)
119-229 . {
119-230 . A = B + C;
119-231 . D = E + F;
119-232 . }
119-233 .
119-234 .
119-235 . if (A lt B)
119-236 . {
119-237 . A = B + C;
119-238 . D = E + F;
119-239 . }
119-240 .
119-241 . /* LE SV TOC-3019 this is a wxp-02.2.6 req to translate*/
119-242 . A = B/C;
119-243 . /* LE SV TOC-3020 this is a wxp-02.2.7 req to translate*/
119-244 . A = B+C;
119-245 .
119-246 . /*
119-247 . dead_code = B - C;
119-248 . dead_code = D - E;
119-249 . dead_code = F - G;
119-250 . */
119-251 .
119-252 .
119-253 . if (A > = B)
119-254 . {
119-255 . A = B + C;
119-256 . D = E + F;
119-257 . }
119-258 .
119-259 .
119-260 . if (A < = B)
119-261 . {
119-262 . A = B + C;
119-263 . D = E + F;
119-264 . }
119-265 .
119-266 . A = B-C;
119-267 . A = B*C;
119-268 .
119-269 . if (A < B)
119-270 . {
119-271 . A = B + C;
119-272 . D = E + F;
119-273 . }
119-274 .
119-275 . A = B-C;
119-276 . A = B*C;
119-277 . A = B-C;
119-278 . A = B/C;
119-279 . A = B+C;
119-280 .
119-281 . if (A ne B)
119-282 . {
119-283 . A = B + C;
119-284 . D = E + F;
119-285 . }
119-286 .
119-287 .
119-288 . if (A > = B)
119-289 . {
119-290 . A = B + C;
119-291 . D = E + F;
119-292 . }
119-293 .
119-294 . /* LE SV TOC-3021 this is a wxp-02.2.20 req to check pSOS*/
119-295 . A = B-C;
119-296 . A = B/C;
119-297 . A = B-C;
119-298 . A = B*C;
119-299 . A = B*C;
119-300 .
119-301 . if (A eq B)
119-302 . {
119-303 . A = B + C;
119-304 . D = E + F;
119-305 . }
119-306 .
119-307 .
119-308 . if (A le B)
119-309 . {
119-310 . A = B + C;
119-311 . D = E + F;
119-312 . }
119-313 .
119-314 . A = B*C;
119-315 .
119-316 . if (A != B)
119-317 . {
119-318 . A = B + C;
119-319 . D = E + F;
119-320 . }
119-321 .
119-322 .
119-323 . if (A eq B)
119-324 . {
119-325 . A = B + C;
119-326 . D = E + F;
119-327 . }
119-328 .
119-329 . /* LE SV TOC-3022 this is a wxp-02.2.30 req to compare*/
119-330 . A = B-C;
119-331 .
119-332 . if (A ne B)
119-333 . {
119-334 . A = B + C;
119-335 . D = E + F;
119-336 . }
119-337 .
119-338 . A = B+C;
119-339 .
119-340 . if (A gt B)
119-341 . {
119-342 . A = B + C;
119-343 . D = E + F;
119-344 . }
119-345 .
119-346 .
119-347 . if (A > B)
119-348 . {
119-349 . A = B + C;
119-350 . D = E + F;
119-351 . }
119-352 .
119-353 . /* LE SV TOC-3023 this is a wxp-02.2.35 req to assign*/
119-354 .
119-355 . if (A > B)
119-356 . {
119-357 . A = B + C;
119-358 . D = E + F;
119-359 . }
119-360 .
119-361 .
119-362 . /*
119-363 . dead_code = B - C;
119-364 . dead_code = D - E;
119-365 . dead_code = F - G;
119-366 . */
119-367 .
119-368 .
119-369 . if (A > = B)
119-370 . {
119-371 . A = B + C;
119-372 . D = E + F;
119-373 . }
119-374 .
119-375 . A = B+C;
119-376 .
119-377 . if (A > B)
119-378 . {
119-379 . A = B + C;
119-380 . D = E + F;
119-381 . }
119-382 .
119-383 . A = B+C;
119-384 . A = B-C;
119-385 . A = B-C;
119-386 .
119-387 . if (A lt B)
119-388 . {
119-389 . A = B + C;
119-390 . D = E + F;
119-391 . }
119-392 .
119-393 . A = B*C;
119-394 .
119-395 . switch (wxp stuff)
119-396 . {
119-397 . case one:
119-398 . {
119-399 . run_this;
119-400 . break;
119-401 . }
119-402 . case two:
119-403 . {
119-404 . run_this;
119-405 . break;
119-406 . }
119-407 . // missing default
119-408 . }
119-409 .
119-410 . A = B-C;
119-411 . A = B-C;
119-412 .
119-413 . if (A gt B)
119-414 . {
119-415 . A = B + C;
119-416 . D = E + F;
119-417 . }
119-418 .
119-419 .
119-420 . if (A == B)
119-421 . {
119-422 . A = B + C;
119-423 . D = E + F;
119-424 . }
119-425 .
119-426 . A = B+C;
119-427 . do forever;
119-428 . A = B-C;
119-429 .
119-430 . if (A gt B)
119-431 . {
119-432 . A = B + C;
119-433 . D = E + F;
119-434 . }
119-435 .
119-436 . A = B*C;
119-437 .
119-438 . if (A < B)
119-439 . {
119-440 . A = B + C;
119-441 . D = E + F;
119-442 . }
119-443 .
119-444 . A = B*C;
119-445 .
119-446 . if (A ge B)
119-447 . {
119-448 . A = B + C;
119-449 . D = E + F;
119-450 . }
119-451 .
119-452 .
119-453 . if (A le B)
119-454 . {
119-455 . A = B + C;
119-456 . D = E + F;
119-457 . }
119-458 .
119-459 . A = B-C;
119-460 . A = B*C;
119-461 .
119-462 . if (A < B)
119-463 . {
119-464 . A = B + C;
119-465 . D = E + F;
119-466 . }
119-467 .
119-468 .
119-469 . if (A lt B)
119-470 . {
119-471 . A = B + C;
119-472 . D = E + F;
119-473 . }
119-474 .
119-475 . A = B-C;
119-476 . A = B/C;
119-477 . /* LE SV TOC-3024 this is a wxp-02.2.62 req to inhibit*/
119-478 . A = B*C;
119-479 . A = B-C;
119-480 . A = B*C;
119-481 . A = B+C;
119-482 . A = B*C;
119-483 .
119-484 . if (A le B)
119-485 . {
119-486 . A = B + C;
119-487 . D = E + F;
119-488 . }
119-489 .
119-490 .
119-491 . if (A ne B)
119-492 . {
119-493 . A = B + C;
119-494 . D = E + F;
119-495 . }
119-496 .
119-497 . A = B+C;
119-498 . A = B/C;
119-499 . A = B/C;
119-500 . A = B-C;
119-501 . A = B*C;
119-502 . A = B/C;
119-503 .
119-504 . switch (wxp stuff)
119-505 . {
119-506 . case one:
119-507 . {
119-508 . run_this;
119-509 . break;
119-510 . }
119-511 . case two:
119-512 . {
119-513 . run_this;
119-514 . break;
119-515 . }
119-516 . default:
119-517 . {
119-518 . SwError;
119-519 . }
119-520 . }
119-521 .
119-522 .
119-523 . switch (wxp stuff)
119-524 . {
119-525 . case one:
119-526 . {
119-527 . switch (nested)
119-528 . {
119-529 . case:
119-530 . X = Y + Z;
119-531 . case:
119-532 . X = Y + Z;
119-533 . default:
119-534 . SwError;
119-535 . }
119-536 . }
119-537 . case two:
119-538 . {
119-539 . run_this;
119-540 . break;
119-541 . }
119-542 . default:
119-543 . {
119-544 . SwError;
119-545 . }
119-546 . }
119-547 .
119-548 . A = B/C;
119-549 . // max LOC 76
119-550 .
119-551 . }
119-552 .
119-553 .
119-554 . /*
119-555 . -----------------------------------------------------------------------------
119-556 . --| NAME: wxp.2.3
119-557 . --|
119-558 . --| ABSTRACT:
119-559 . --| This function does wxp stuff.
119-560 . --|
119-561 . --| RETURNS:
119-562 . --| NONE.
119-563 . --|
119-564 . ----------------------------------------------------------------------------
119-565 . */
119-566 . static void wxp.2.3(void)
119-567 . {
119-568 .
119-569 . if (A < = B)
119-570 . {
119-571 . A = B + C;
119-572 . D = E + F;
119-573 . }
119-574 .
119-575 . A = B+C;
119-576 . A = B*C;
119-577 . A = B/C;
119-578 . A = B/C;
119-579 . A = B-C;
119-580 . A = B*C;
119-581 . A = B+C;
119-582 . /* LE SV TOC-3025 this is a wxp-02.3.9 req to set Real Time Clock*/
119-583 . A = B-C;
119-584 .
119-585 . if (A < = B)
119-586 . {
119-587 . A = B + C;
119-588 . D = E + F;
119-589 . }
119-590 .
119-591 . A = B+C;
119-592 . A = B-C;
119-593 .
119-594 . if (A < B)
119-595 . {
119-596 . A = B + C;
119-597 . D = E + F;
119-598 . }
119-599 .
119-600 . A = 0x0002;
119-601 . A = B-C;
119-602 . A = B-C;
119-603 .
119-604 . if (A != B)
119-605 . {
119-606 . A = B + C;
119-607 . D = E + F;
119-608 . }
119-609 .
119-610 .
119-611 . if (A ne B)
119-612 . {
119-613 . A = B + C;
119-614 . D = E + F;
119-615 . }
119-616 .
119-617 . A = B*C;
119-618 . /* LE SV TOC-3026 this is a wxp-02.3.19 req to verify*/
119-619 . A = B/C;
119-620 . A = B/C;
119-621 . A = B+C;
119-622 . A = B-C;
119-623 . A = B-C;
119-624 . /* LE SV TOC-3027 this is a wxp-02.3.24 req to update*/
119-625 . A = B*C;
119-626 . A = B-C;
119-627 . A = B+C;
119-628 .
119-629 . if (A gt B)
119-630 . {
119-631 . A = B + C;
119-632 . D = E + F;
119-633 . }
119-634 .
119-635 . A = B/C;
119-636 .
119-637 . if (A == B)
119-638 . {
119-639 . A = B + C;
119-640 . D = E + F;
119-641 . }
119-642 .
119-643 . /* LE SV TOC-3028 this is a wxp-02.3.30 req to call isr*/
119-644 . A = B/C;
119-645 .
119-646 . if (A ne B)
119-647 . {
119-648 . A = B + C;
119-649 . D = E + F;
119-650 . }
119-651 .
119-652 . A = B+C;
119-653 . A = B+C;
119-654 . A = B+C;
119-655 . A = B/C;
119-656 . A = B+C;
119-657 .
119-658 . switch (wxp stuff)
119-659 . {
119-660 . case one:
119-661 . {
119-662 . switch (nested)
119-663 . {
119-664 . case:
119-665 . X = Y + Z;
119-666 . case:
119-667 . X = Y + Z;
119-668 . default:
119-669 . SwError;
119-670 . }
119-671 . }
119-672 . case two:
119-673 . {
119-674 . run_this;
119-675 . break;
119-676 . }
119-677 . default:
119-678 . {
119-679 . SwError;
119-680 . }
119-681 . }
119-682 .
119-683 . A = B+C;
119-684 . A = B/C;
119-685 . A = B*C;
119-686 . A = B+C;
119-687 . A = B+C;
119-688 . A = B+C;
119-689 . A = B-C;
119-690 . A = B/C;
119-691 .
119-692 . if (A lt B)
119-693 . {
119-694 . A = B + C;
119-695 . D = E + F;
119-696 . }
119-697 .
119-698 .
119-699 . if (A eq B)
119-700 . {
119-701 . A = B + C;
119-702 . D = E + F;
119-703 . }
119-704 .
119-705 .
119-706 . if (A gt B)
119-707 . {
119-708 . A = B + C;
119-709 . D = E + F;
119-710 . }
119-711 .
119-712 .
119-713 . if (A != B)
119-714 . {
119-715 . A = B + C;
119-716 . D = E + F;
119-717 . }
119-718 .
119-719 . A = B/C;
119-720 . A = B+C;
119-721 . A = B*C;
119-722 . // max LOC 51
119-723 .
119-724 . }
119-725 .
119-726 .
119-727 . /*
119-728 . -----------------------------------------------------------------------------
119-729 . --| NAME: wxp.2.4
119-730 . --|
119-731 . --| ABSTRACT:
119-732 . --| This function does wxp stuff.
119-733 . --|
119-734 . --| RETURNS:
119-735 . --| NONE.
119-736 . --|
119-737 . ----------------------------------------------------------------------------
119-738 . */
119-739 . static void wxp.2.4(void)
119-740 . {
119-741 .
119-742 . if (A eq B)
119-743 . {
119-744 . A = B + C;
119-745 . D = E + F;
119-746 . }
119-747 .
119-748 .
119-749 . if (A ge B)
119-750 . {
119-751 . A = B + C;
119-752 . D = E + F;
119-753 . }
119-754 .
119-755 . A = B*C;
119-756 .
119-757 . if (A ge B)
119-758 . {
119-759 . A = B + C;
119-760 . D = E + F;
119-761 . }
119-762 .
119-763 . A = 0x0001;
119-764 . A = B*C;
119-765 . A = B-C;
119-766 . A = B-C;
119-767 . A = B/C;
119-768 . A = B/C;
119-769 .
119-770 . if (A eq B)
119-771 . {
119-772 . A = B + C;
119-773 . D = E + F;
119-774 . }
119-775 .
119-776 . A = B-C;
119-777 . A = B*C;
119-778 . A = B-C;
119-779 . A = B/C;
119-780 .
119-781 . if (A < = B)
119-782 . {
119-783 . A = B + C;
119-784 . D = E + F;
119-785 . }
119-786 .
119-787 . A = B*C;
119-788 . A = B-C;
119-789 .
119-790 . if (A > B)
119-791 . {
119-792 . A = B + C;
119-793 . D = E + F;
119-794 . }
119-795 .
119-796 .
119-797 . if (A < = B)
119-798 . {
119-799 . A = B + C;
119-800 . D = E + F;
119-801 . }
119-802 .
119-803 . A = B+C;
119-804 .
119-805 . if (A != B)
119-806 . {
119-807 . A = B + C;
119-808 . D = E + F;
119-809 . }
119-810 .
119-811 . A = B+C;
119-812 .
119-813 . if (A ge B)
119-814 . {
119-815 . A = B + C;
119-816 . D = E + F;
119-817 . }
119-818 .
119-819 .
119-820 . if (A gt B)
119-821 . {
119-822 . A = B + C;
119-823 . D = E + F;
119-824 . }
119-825 .
119-826 . A = B*C;
119-827 . A = B/C;
119-828 .
119-829 . if (A le B)
119-830 . {
119-831 . A = B + C;
119-832 . D = E + F;
119-833 . }
119-834 .
119-835 . A = B/C;
119-836 .
119-837 . if (A < B)
119-838 . {
119-839 . A = B + C;
119-840 . D = E + F;
119-841 . }
119-842 .
119-843 .
119-844 . if (A ne B)
119-845 . {
119-846 . A = B + C;
119-847 . D = E + F;
119-848 . }
119-849 .
119-850 . A = B-C;
119-851 .
119-852 . if (A > = B)
119-853 . {
119-854 . A = B + C;
119-855 . D = E + F;
119-856 . }
119-857 .
119-858 .
119-859 . if (A gt B)
119-860 . {
119-861 . A = B + C;
119-862 . D = E + F;
119-863 . }
119-864 .
119-865 . A = B/C;
119-866 . A = B*C;
119-867 . A = B+C;
119-868 .
119-869 . switch (wxp stuff)
119-870 . {
119-871 . case one:
119-872 . {
119-873 . run_this;
119-874 . break;
119-875 . }
119-876 . case two:
119-877 . {
119-878 . run_this;
119-879 . break;
119-880 . }
119-881 . default:
119-882 . {
119-883 . SwError;
119-884 . }
119-885 . }
119-886 .
119-887 . A = B*C;
119-888 .
119-889 . if (A le B)
119-890 . {
119-891 . A = B + C;
119-892 . D = E + F;
119-893 . }
119-894 .
119-895 .
119-896 . if (A > = B)
119-897 . {
119-898 . A = B + C;
119-899 . D = E + F;
119-900 . }
119-901 .
119-902 . A = B-C;
119-903 .
119-904 . if (A ge B)
119-905 . {
119-906 . A = B + C;
119-907 . D = E + F;
119-908 . }
119-909 .
119-910 . A = B+C;
119-911 . A = B*C;
119-912 .
119-913 . if (A ne B)
119-914 . {
119-915 . A = B + C;
119-916 . D = E + F;
119-917 . }
119-918 .
119-919 . A = B*C;
119-920 .
119-921 . if (A == B)
119-922 . {
119-923 . A = B + C;
119-924 . D = E + F;
119-925 . }
119-926 .
119-927 . A = B+C;
119-928 . A = B+C;
119-929 .
119-930 . if (A eq B)
119-931 . {
119-932 . A = B + C;
119-933 . D = E + F;
119-934 . }
119-935 .
119-936 .
119-937 . if (A eq B)
119-938 . {
119-939 . A = B + C;
119-940 . D = E + F;
119-941 . }
119-942 .
119-943 . /* LE SV TOC-3029 this is a wxp-02.4.52 req to inhibit*/
119-944 .
119-945 . #ifdef LAZY
119-946 . // this is not nice
119-947 . A = B + C;
119-948 . A = B + C;
119-949 . #endif
119-950 .
119-951 . A = B/C;
119-952 . A = B-C;
119-953 .
119-954 . if (A > = B)
119-955 . {
119-956 . A = B + C;
119-957 . D = E + F;
119-958 . }
119-959 .
119-960 . A = B-C;
119-961 . A = B+C;
119-962 . A = B+C;
119-963 . A = B-C;
119-964 . A = B+C;
119-965 . A = B+C;
119-966 .
119-967 . if (A le B)
119-968 . {
119-969 . A = B + C;
119-970 . D = E + F;
119-971 . }
119-972 .
119-973 . A = B+C;
119-974 . A = 0x0001;
119-975 .
119-976 . switch (wxp stuff)
119-977 . {
119-978 . case:
119-979 . case:
119-980 . // stacked case statements but only if there is a new line in between
119-981 .
119-982 . case:
119-983 . case:
119-984 . case:
119-985 . {
119-986 . run_this;
119-987 . break;
119-988 . }
119-989 . default:
119-990 . {
119-991 . halt;
119-992 . }
119-993 . }
119-994 .
119-995 . A = B*C;
119-996 . A = B/C;
119-997 . A = 0x0006;
119-998 .
119-999 . if (A ge B)
119-1000 . {
119-1001 . A = B + C;
119-1002 . D = E + F;
119-1003 . }
119-1004 .
119-1005 .
119-1006 . /* dead_block = C * D;
119-1007 . dead_block = E * F; */
119-1008 .
119-1009 . A = B*C;
119-1010 . A = B+C;
119-1011 . /* LE SV TOC-3030 this is a wxp-02.4.68 req to check pSOS*/
119-1012 .
119-1013 . if (A == B)
119-1014 . {
119-1015 . A = B + C;
119-1016 . D = E + F;
119-1017 . }
119-1018 .
119-1019 .
119-1020 . switch (wxp stuff)
119-1021 . {
119-1022 . case one:
119-1023 . {
119-1024 . run_this;
119-1025 . break;
119-1026 . }
119-1027 . case two:
119-1028 . {
119-1029 . run_this;
119-1030 . break;
119-1031 . }
119-1032 . default:
119-1033 . {
119-1034 . SwError;
119-1035 . }
119-1036 . }
119-1037 .
119-1038 . // max LOC 69
119-1039 .
119-1040 . }
119-1041 .
119-1042 .
119-1043 . /*
119-1044 . -----------------------------------------------------------------------------
119-1045 . --| NAME: wxp.2.5
119-1046 . --|
119-1047 . --| ABSTRACT:
119-1048 . --| This function does wxp stuff.
119-1049 . --|
119-1050 . --| RETURNS:
119-1051 . --| NONE.
119-1052 . --|
119-1053 . ----------------------------------------------------------------------------
119-1054 . */
119-1055 . static void wxp.2.5(void)
119-1056 . {
119-1057 . A = B+C;
119-1058 . /* LE SV TOC-3031 this is a wxp-02.5.2 req to store*/
119-1059 .
119-1060 . if (A lt B)
119-1061 . {
119-1062 . A = B + C;
119-1063 . D = E + F;
119-1064 . }
119-1065 .
119-1066 . A = 0x0006;
119-1067 . A = B*C;
119-1068 .
119-1069 . if (A ge B)
119-1070 . {
119-1071 . A = B + C;
119-1072 . D = E + F;
119-1073 . }
119-1074 .
119-1075 . A = B-C;
119-1076 . A = B*C;
119-1077 . A = B+C;
119-1078 .
119-1079 . if (A < = B)
119-1080 . {
119-1081 . A = B + C;
119-1082 . D = E + F;
119-1083 . }
119-1084 .
119-1085 . A = B*C;
119-1086 .
119-1087 . if (A gt B)
119-1088 . {
119-1089 . A = B + C;
119-1090 . D = E + F;
119-1091 . }
119-1092 .
119-1093 .
119-1094 . if (A == B)
119-1095 . {
119-1096 . A = B + C;
119-1097 . D = E + F;
119-1098 . }
119-1099 .
119-1100 .
119-1101 . if (A lt B)
119-1102 . {
119-1103 . A = B + C;
119-1104 . D = E + F;
119-1105 . }
119-1106 .
119-1107 . A = B*C;
119-1108 . A = B*C;
119-1109 . do forever;
119-1110 . A = B*C;
119-1111 .
119-1112 . if (A != B)
119-1113 . {
119-1114 . A = B + C;
119-1115 . D = E + F;
119-1116 . }
119-1117 .
119-1118 . /* LE SV TOC-3032 this is a wxp-02.5.17 req to transform*/
119-1119 .
119-1120 . if (A != B)
119-1121 . {
119-1122 . A = B + C;
119-1123 . D = E + F;
119-1124 . }
119-1125 .
119-1126 . A = B/C;
119-1127 .
119-1128 . if (A ne B)
119-1129 . {
119-1130 . A = B + C;
119-1131 . D = E + F;
119-1132 . }
119-1133 .
119-1134 .
119-1135 . if (A != B)
119-1136 . {
119-1137 . A = B + C;
119-1138 . D = E + F;
119-1139 . }
119-1140 .
119-1141 . A = B+C;
119-1142 .
119-1143 . if (A eq B)
119-1144 . {
119-1145 . A = B + C;
119-1146 . D = E + F;
119-1147 . }
119-1148 .
119-1149 .
119-1150 . if (A ge B)
119-1151 . {
119-1152 . A = B + C;
119-1153 . D = E + F;
119-1154 . }
119-1155 .
119-1156 .
119-1157 . if (A == B)
119-1158 . {
119-1159 . A = B + C;
119-1160 . D = E + F;
119-1161 . }
119-1162 .
119-1163 . // max LOC 24
119-1164 .
119-1165 . }
119-1166 .
119-1167 .
119-1168 . /*
119-1169 . -----------------------------------------------------------------------------
119-1170 . --| NAME: wxp.2.6
119-1171 . --|
119-1172 . --| ABSTRACT:
119-1173 . --| This function does wxp stuff.
119-1174 . --|
119-1175 . --| RETURNS:
119-1176 . --| NONE.
119-1177 . --|
119-1178 . ----------------------------------------------------------------------------
119-1179 . */
119-1180 . static void wxp.2.6(void)
119-1181 . {
119-1182 . A = B+C;
119-1183 . A = B+C;
119-1184 .
119-1185 . switch (wxp stuff)
119-1186 . {
119-1187 . case one:
119-1188 . {
119-1189 . run_this;
119-1190 . break;
119-1191 . }
119-1192 . case two:
119-1193 . {
119-1194 . run_this;
119-1195 . break;
119-1196 . }
119-1197 . default:
119-1198 . {
119-1199 . SwError;
119-1200 . }
119-1201 . }
119-1202 .
119-1203 . A = B/C;
119-1204 . A = B*C;
119-1205 . A = B/C;
119-1206 . A = B/C;
119-1207 . A = B+C;
119-1208 . A = 0x0001;
119-1209 . A = B-C;
119-1210 . /* LE SV TOC-3033 this is a wxp-02.6.10 req to recover*/
119-1211 . A = B/C;
119-1212 . A = B*C;
119-1213 . A = B+C;
119-1214 . A = B/C;
119-1215 . A = B+C;
119-1216 .
119-1217 . if (A le B)
119-1218 . {
119-1219 . A = B + C;
119-1220 . D = E + F;
119-1221 . }
119-1222 .
119-1223 .
119-1224 . if (A != B)
119-1225 . {
119-1226 . A = B + C;
119-1227 . D = E + F;
119-1228 . }
119-1229 .
119-1230 . /* LE SV TOC-3034 this is a wxp-02.6.17 req to update*/
119-1231 .
119-1232 . if (A != B)
119-1233 . {
119-1234 . A = B + C;
119-1235 . D = E + F;
119-1236 . }
119-1237 .
119-1238 . A = B/C;
119-1239 . A = B-C;
119-1240 . A = B+C;
119-1241 .
119-1242 . if (A < = B)
119-1243 . {
119-1244 . A = B + C;
119-1245 . D = E + F;
119-1246 . }
119-1247 .
119-1248 . A = B*C;
119-1249 . A = 0x0004;
119-1250 . A = B/C;
119-1251 .
119-1252 . if (A > B)
119-1253 . {
119-1254 . A = B + C;
119-1255 . D = E + F;
119-1256 . }
119-1257 .
119-1258 . A = B/C;
119-1259 .
119-1260 . switch (wxp stuff)
119-1261 . {
119-1262 . case one:
119-1263 . {
119-1264 . run_this;
119-1265 . break;
119-1266 . }
119-1267 . case two:
119-1268 . {
119-1269 . run_this;
119-1270 . break;
119-1271 . }
119-1272 . default:
119-1273 . {
119-1274 . SwError;
119-1275 . }
119-1276 . }
119-1277 .
119-1278 . A = B-C;
119-1279 . A = B/C;
119-1280 . A = B+C;
119-1281 . A = B*C;
119-1282 . // max LOC 30
119-1283 .
119-1284 . }
119-1285 .
119-1286 .
119-1287 . /*
119-1288 . -----------------------------------------------------------------------------
119-1289 . --| NAME: wxp.2.7
119-1290 . --|
119-1291 . --| ABSTRACT:
119-1292 . --| This function does wxp stuff.
119-1293 . --|
119-1294 . --| RETURNS:
119-1295 . --| NONE.
119-1296 . --|
119-1297 . ----------------------------------------------------------------------------
119-1298 . */
119-1299 . static void wxp.2.7(void)
119-1300 . {
119-1301 . A = B-C;
119-1302 . A = B+C;
119-1303 . A = B+C;
119-1304 . A = B-C;
119-1305 .
119-1306 . if (A != B)
119-1307 . {
119-1308 . A = B + C;
119-1309 . D = E + F;
119-1310 . }
119-1311 .
119-1312 . A = B+C;
119-1313 . A = B*C;
119-1314 . A = 0x0003;
119-1315 . A = B*C;
119-1316 . A = B/C;
119-1317 .
119-1318 . if (A == B)
119-1319 . {
119-1320 . A = B + C;
119-1321 . D = E + F;
119-1322 . }
119-1323 .
119-1324 . A = B-C;
119-1325 .
119-1326 . if (A ge B)
119-1327 . {
119-1328 . A = B + C;
119-1329 . D = E + F;
119-1330 . }
119-1331 .
119-1332 .
119-1333 . if (A > = B)
119-1334 . {
119-1335 . A = B + C;
119-1336 . D = E + F;
119-1337 . }
119-1338 .
119-1339 . A = B*C;
119-1340 . A = B-C;
119-1341 . A = B+C;
119-1342 . A = B-C;
119-1343 . A = B+C;
119-1344 . /* LE SV TOC-3035 this is a wxp-02.7.19 req to translate*/
119-1345 .
119-1346 . if (A le B)
119-1347 . {
119-1348 . A = B + C;
119-1349 . D = E + F;
119-1350 . }
119-1351 .
119-1352 .
119-1353 . switch (wxp stuff)
119-1354 . {
119-1355 . case one:
119-1356 . {
119-1357 . run_this;
119-1358 . break;
119-1359 . }
119-1360 . case two:
119-1361 . {
119-1362 . run_this;
119-1363 . break;
119-1364 . }
119-1365 . default:
119-1366 . {
119-1367 . SwError;
119-1368 . }
119-1369 . }
119-1370 .
119-1371 . A = B*C;
119-1372 . A = B-C;
119-1373 . A = B*C;
119-1374 .
119-1375 . if (A gt B)
119-1376 . {
119-1377 . A = B + C;
119-1378 . D = E + F;
119-1379 . }
119-1380 .
119-1381 . A = B+C;
119-1382 . A = B*C;
119-1383 . A = B+C;
119-1384 . A = B*C;
119-1385 . A = B+C;
119-1386 .
119-1387 . if (A == B)
119-1388 . {
119-1389 . A = B + C;
119-1390 . D = E + F;
119-1391 . }
119-1392 .
119-1393 . A = B*C;
119-1394 .
119-1395 . if (A != B)
119-1396 . {
119-1397 . A = B + C;
119-1398 . D = E + F;
119-1399 . }
119-1400 .
119-1401 . A = B/C;
119-1402 . /* LE SV TOC-3036 this is a wxp-02.7.34 req to translate*/
119-1403 .
119-1404 . if (A < B)
119-1405 . {
119-1406 . A = B + C;
119-1407 . D = E + F;
119-1408 . }
119-1409 .
119-1410 . A = B-C;
119-1411 . A = B-C;
119-1412 . A = B/C;
119-1413 . A = B+C;
119-1414 . A = B*C;
119-1415 . A = B+C;
119-1416 . A = B-C;
119-1417 . A = B*C;
119-1418 . A = B*C;
119-1419 . A = B/C;
119-1420 .
119-1421 . if (A > B)
119-1422 . {
119-1423 . A = B + C;
119-1424 . D = E + F;
119-1425 . }
119-1426 .
119-1427 . A = B/C;
119-1428 . A = B+C;
119-1429 . A = B*C;
119-1430 . /* LE SV TOC-3037 this is a wxp-02.7.49 req to audit*/
119-1431 . A = B+C;
119-1432 . A = B/C;
119-1433 . A = B-C;
119-1434 . A = B+C;
119-1435 .
119-1436 . if (A gt B)
119-1437 . {
119-1438 . A = B + C;
119-1439 . D = E + F;
119-1440 . }
119-1441 .
119-1442 .
119-1443 . if (A == B)
119-1444 . {
119-1445 . A = B + C;
119-1446 . D = E + F;
119-1447 . }
119-1448 .
119-1449 . do forever;
119-1450 . A = B+C;
119-1451 . A = B+C;
119-1452 .
119-1453 . if (A eq B)
119-1454 . {
119-1455 . A = B + C;
119-1456 . D = E + F;
119-1457 . }
119-1458 .
119-1459 . A = B+C;
119-1460 . A = B+C;
119-1461 . A = B-C;
119-1462 . A = B-C;
119-1463 . A = B-C;
119-1464 . FreePtr = HmiStringPtr;
119-1465 .
119-1466 . if (A ne B)
119-1467 . {
119-1468 . A = B + C;
119-1469 . D = E + F;
119-1470 . }
119-1471 .
119-1472 . A = (int)B + C;
119-1473 . A = B-C;
119-1474 . A = B/C;
119-1475 . A = B/C;
119-1476 . A = B-C;
119-1477 . A = B*C;
119-1478 . A = B/C;
119-1479 . // max LOC 69
119-1480 .
119-1481 . }
119-1482 .
119-1483 .
119-1484 . /*
119-1485 . -----------------------------------------------------------------------------
119-1486 . --| NAME: wxp.2.8
119-1487 . --|
119-1488 . --| ABSTRACT:
119-1489 . --| This function does wxp stuff.
119-1490 . --|
119-1491 . --| RETURNS:
119-1492 . --| NONE.
119-1493 . --|
119-1494 . ----------------------------------------------------------------------------
119-1495 . */
119-1496 . static void wxp.2.8(void)
119-1497 . {
119-1498 . A = B+C;
119-1499 . A = B*C;
119-1500 . A = B-C;
119-1501 . A = B+C;
119-1502 .
119-1503 . if (A eq B)
119-1504 . {
119-1505 . A = B + C;
119-1506 . D = E + F;
119-1507 . }
119-1508 .
119-1509 . A = B*C;
119-1510 .
119-1511 . if (A lt B)
119-1512 . {
119-1513 . A = B + C;
119-1514 . D = E + F;
119-1515 . }
119-1516 .
119-1517 . /* LE SV TOC-3038 this is a wxp-02.8.8 req to disable*/
119-1518 .
119-1519 . switch (wxp stuff)
119-1520 . {
119-1521 . case:
119-1522 . case:
119-1523 . // stacked case statements but only if there is a new line in between
119-1524 .
119-1525 . case:
119-1526 . case:
119-1527 . case:
119-1528 . {
119-1529 . run_this;
119-1530 . break;
119-1531 . }
119-1532 . default:
119-1533 . {
119-1534 . halt;
119-1535 . }
119-1536 . }
119-1537 .
119-1538 . A = B/C;
119-1539 . /* LE SV TOC-3039 this is a wxp-02.8.9 req to increment*/
119-1540 . A = B/C;
119-1541 .
119-1542 . if (A gt B)
119-1543 . {
119-1544 . A = B + C;
119-1545 . D = E + F;
119-1546 . }
119-1547 .
119-1548 . A = B-C;
119-1549 . A = B/C;
119-1550 . A = B+C;
119-1551 . A = B-C;
119-1552 . A = B/C;
119-1553 . A = B-C;
119-1554 . A = B*C;
119-1555 . /* LE SV TOC-3040 this is a wxp-02.8.18 req to process*/
119-1556 . A = B*C;
119-1557 . A = B*C;
119-1558 . A = B+C;
119-1559 .
119-1560 . if (A lt B)
119-1561 . {
119-1562 . A = B + C;
119-1563 . D = E + F;
119-1564 . }
119-1565 .
119-1566 . A = B*C;
119-1567 . A = B-C;
119-1568 . A = 0x0009;
119-1569 . A = B/C;
119-1570 . A = B/C;
119-1571 . A = B/C;
119-1572 . A = B+C;
119-1573 . A = B+C;
119-1574 . A = B+C;
119-1575 .
119-1576 . if (A ge B)
119-1577 . {
119-1578 . A = B + C;
119-1579 . D = E + F;
119-1580 . }
119-1581 .
119-1582 . /* LE SV TOC-3041 this is a wxp-02.8.31 req to recover*/
119-1583 .
119-1584 . if (A gt B)
119-1585 . {
119-1586 . A = B + C;
119-1587 . D = E + F;
119-1588 . }
119-1589 .
119-1590 . A = B+C;
119-1591 .
119-1592 . if (A gt B)
119-1593 . {
119-1594 . A = B + C;
119-1595 . D = E + F;
119-1596 . }
119-1597 .
119-1598 . A = B+C;
119-1599 . /* LE SV TOC-3042 this is a wxp-02.8.35 req to set Real Time Clock*/
119-1600 . A = B-C;
119-1601 . A = B*C;
119-1602 . A = B-C;
119-1603 . A = B+C;
119-1604 .
119-1605 . /* dead_code = B + C;
119-1606 . dead_code = D + E;
119-1607 . dead_code = F + G; */
119-1608 .
119-1609 . A = B*C;
119-1610 . A = B*C;
119-1611 . A = B*C;
119-1612 .
119-1613 . if (A == B)
119-1614 . {
119-1615 . A = B + C;
119-1616 . D = E + F;
119-1617 . }
119-1618 .
119-1619 .
119-1620 . if (veg)
119-1621 . // missing curly brace
119-1622 . variable = orange;
119-1623 .
119-1624 . A = B-C;
119-1625 . A = B*C;
119-1626 . /* LE SV TOC-3043 this is a wxp-02.8.45 req to reject*/
119-1627 . A = B*C;
119-1628 . A = B*C;
119-1629 . A = B/C;
119-1630 .
119-1631 . if (A ne B)
119-1632 . {
119-1633 . A = B + C;
119-1634 . D = E + F;
119-1635 . }
119-1636 .
119-1637 .
119-1638 . if (A == B)
119-1639 . {
119-1640 . A = B + C;
119-1641 . D = E + F;
119-1642 . }
119-1643 .
119-1644 . A = B/C;
119-1645 . A = B-C;
119-1646 . A = B+C;
119-1647 . /* LE SV TOC-3044 this is a wxp-02.8.53 req to validate*/
119-1648 .
119-1649 . if (A ne B)
119-1650 . {
119-1651 . A = B + C;
119-1652 . D = E + F;
119-1653 . }
119-1654 .
119-1655 .
119-1656 . if (A > = B)
119-1657 . {
119-1658 . A = B + C;
119-1659 . D = E + F;
119-1660 . }
119-1661 .
119-1662 . A = B+C;
119-1663 . A = B+C;
119-1664 .
119-1665 . if (A gt B)
119-1666 . {
119-1667 . A = B + C;
119-1668 . D = E + F;
119-1669 . }
119-1670 .
119-1671 .
119-1672 . if (A ne B)
119-1673 . {
119-1674 . A = B + C;
119-1675 . D = E + F;
119-1676 . }
119-1677 .
119-1678 .
119-1679 . switch (wxp stuff)
119-1680 . {
119-1681 . case one:
119-1682 . {
119-1683 . run_this;
119-1684 . break;
119-1685 . }
119-1686 . case two:
119-1687 . {
119-1688 . run_this;
119-1689 . break;
119-1690 . }
119-1691 . default:
119-1692 . {
119-1693 . SwError;
119-1694 . }
119-1695 . }
119-1696 .
119-1697 . // max LOC 59
119-1698 .
119-1699 . }
119-1700 .
119 119 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-02.c
120 120 Source: source/ft-app/ft-app-B1.0/wxp/wxp-03.c
120-0 . /*
120-1 . ----------------------------------------------------------------------------
120-2 . --| BEGIN PROLOGUE
120-3 . --|
120-4 . --| CLASSIFICATION: UNCLASSIFIED
120-5 . --|
120-6 . --| FILE NAME: wxp-03.c
120-7 . --|
120-8 . --| ABSTRACT:
120-9 . --| This file contains the 1 functions that do file wxp stuff.
120-10 . --|
120-11 . --| HISTORY:
120-12 . --| CCCQ_NAME:
120-13 . --| CCCQ_VER:
120-14 . --|
120-15 . --| END PROLOGUE
120-16 . ----------------------------------------------------------------------------
120-17 . */
120-18 .
120-19 . float B;
120-20 . #include C;
120-21 .
120-22 .
120-23 .
120-24 . /*
120-25 . -----------------------------------------------------------------------------
120-26 . --| NAME: wxp.3.1
120-27 . --|
120-28 . --| ABSTRACT:
120-29 . --| This function does wxp stuff.
120-30 . --|
120-31 . --| RETURNS:
120-32 . --| NONE.
120-33 . --|
120-34 . ----------------------------------------------------------------------------
120-35 . */
120-36 . static void wxp.3.1(void)
120-37 . {
120-38 . /* LE SV TOC-3045 this is a wxp-03.1.1 req to translate*/
120-39 .
120-40 . if (A le B)
120-41 . {
120-42 . A = B + C;
120-43 . D = E + F;
120-44 . }
120-45 .
120-46 . A = B-C;
120-47 . A = B*C;
120-48 .
120-49 . switch (wxp stuff)
120-50 . {
120-51 . case one:
120-52 . {
120-53 . run_this;
120-54 . break;
120-55 . }
120-56 . case two:
120-57 . {
120-58 . run_this;
120-59 . break;
120-60 . }
120-61 . default:
120-62 . {
120-63 . SwError;
120-64 . }
120-65 . }
120-66 .
120-67 .
120-68 . if (A ne B)
120-69 . {
120-70 . A = B + C;
120-71 . D = E + F;
120-72 . }
120-73 .
120-74 . A = B*C;
120-75 . A = B-C;
120-76 . A = B*C;
120-77 . A = B+C;
120-78 .
120-79 . if (A < B)
120-80 . {
120-81 . A = B + C;
120-82 . D = E + F;
120-83 . }
120-84 .
120-85 . A = B*C;
120-86 . A = B+C;
120-87 .
120-88 . if (A > = B)
120-89 . {
120-90 . A = B + C;
120-91 . D = E + F;
120-92 . }
120-93 .
120-94 . A = B/C;
120-95 . A = B*C;
120-96 . A = B/C;
120-97 . /* LE SV TOC-3046 this is a wxp-03.1.17 req to translate*/
120-98 . A = B/C;
120-99 . A = B-C;
120-100 .
120-101 . if (A eq B)
120-102 . {
120-103 . A = B + C;
120-104 . D = E + F;
120-105 . }
120-106 .
120-107 .
120-108 . if (A gt B)
120-109 . {
120-110 . A = B + C;
120-111 . D = E + F;
120-112 . }
120-113 .
120-114 .
120-115 . if {
120-116 . X = Y + Z;
120-117 . }
120-118 . else {
120-119 . halt;
120-120 . }
120-121 .
120-122 . A = B-C;
120-123 . A = B/C;
120-124 . A = B+C;
120-125 . A = B-C;
120-126 . A = B*C;
120-127 . A = B/C;
120-128 . A = B*C;
120-129 . A = B*C;
120-130 .
120-131 . switch (wxp stuff)
120-132 . {
120-133 . case one:
120-134 . {
120-135 . run_this;
120-136 . break;
120-137 . }
120-138 . case two:
120-139 . {
120-140 . run_this;
120-141 . break;
120-142 . }
120-143 . default:
120-144 . {
120-145 . SwError;
120-146 . }
120-147 . }
120-148 .
120-149 . // (P) this is really improtant
120-150 . A = B/C;
120-151 . /* LE SV TOC-3047 this is a wxp-03.1.31 req to process*/
120-152 . A = B*C;
120-153 .
120-154 . if (A gt B)
120-155 . {
120-156 . A = B + C;
120-157 . D = E + F;
120-158 . }
120-159 .
120-160 . A = B/C;
120-161 .
120-162 . if (A < = B)
120-163 . {
120-164 . A = B + C;
120-165 . D = E + F;
120-166 . }
120-167 .
120-168 . A = B-C;
120-169 . A = B+C;
120-170 . // max LOC 36
120-171 .
120-172 . }
120-173 .
120 120 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-03.c
121 121 Source: source/ft-app/ft-app-B1.0/wxp/wxp-04.c
121-0 .
121-1 .
121-2 . #include D;
121-3 . #define C;
121-4 . #define A;
121-5 . #include A;
121-6 . int A;
121-7 . #include B;
121-8 . #define D;
121-9 .
121-10 .
121-11 .
121-12 . /*
121-13 . -----------------------------------------------------------------------------
121-14 . --| NAME: wxp.4.1
121-15 . --|
121-16 . --| ABSTRACT:
121-17 . --| This function does wxp stuff.
121-18 . --|
121-19 . --| RETURNS:
121-20 . --| NONE.
121-21 . --|
121-22 . ----------------------------------------------------------------------------
121-23 . */
121-24 . static void wxp.4.1(void)
121-25 . {
121-26 .
121-27 . if (A > B)
121-28 . {
121-29 . A = B + C;
121-30 . D = E + F;
121-31 . }
121-32 .
121-33 .
121-34 . if (A ge B)
121-35 . {
121-36 . A = B + C;
121-37 . D = E + F;
121-38 . }
121-39 .
121-40 . A = B-C;
121-41 . A = B+C;
121-42 .
121-43 . if (A eq B)
121-44 . {
121-45 . A = B + C;
121-46 . D = E + F;
121-47 . }
121-48 .
121-49 . goto error;
121-50 . A = B*C;
121-51 . A = B/C;
121-52 . send_buffer = (U16 *) malloc(size+1);
121-53 . A = B*C;
121-54 . A = B-C;
121-55 . A = B*C;
121-56 . A = B/C;
121-57 . A = B-C;
121-58 .
121-59 . if (A eq B)
121-60 . {
121-61 . A = B + C;
121-62 . D = E + F;
121-63 . }
121-64 .
121-65 . A = B/C;
121-66 . A = B/C;
121-67 . // max LOC 15
121-68 .
121-69 . }
121-70 .
121-71 .
121-72 . /*
121-73 . -----------------------------------------------------------------------------
121-74 . --| NAME: wxp.4.2
121-75 . --|
121-76 . --| ABSTRACT:
121-77 . --| This function does wxp stuff.
121-78 . --|
121-79 . --| RETURNS:
121-80 . --| NONE.
121-81 . --|
121-82 . ----------------------------------------------------------------------------
121-83 . */
121-84 . static void wxp.4.2(void)
121-85 . {
121-86 .
121-87 . if (A == B)
121-88 . {
121-89 . A = B + C;
121-90 . D = E + F;
121-91 . }
121-92 .
121-93 . A = B+C;
121-94 .
121-95 . switch (wxp stuff)
121-96 . {
121-97 . case one:
121-98 . {
121-99 . run_this;
121-100 . break;
121-101 . }
121-102 . case two:
121-103 . {
121-104 . run_this;
121-105 . break;
121-106 . }
121-107 . default:
121-108 . {
121-109 . SwError;
121-110 . }
121-111 . }
121-112 .
121-113 . A = B*C;
121-114 .
121-115 . if (A lt B)
121-116 . {
121-117 . A = B + C;
121-118 . D = E + F;
121-119 . }
121-120 .
121-121 .
121-122 . if (A le B)
121-123 . {
121-124 . A = B + C;
121-125 . D = E + F;
121-126 . }
121-127 .
121-128 . A = B*C;
121-129 . A = 0x0007;
121-130 . A = B/C;
121-131 . A = B*C;
121-132 .
121-133 . if (A != B)
121-134 . {
121-135 . A = B + C;
121-136 . D = E + F;
121-137 . }
121-138 .
121-139 .
121-140 . if (A < = B)
121-141 . {
121-142 . A = B + C;
121-143 . D = E + F;
121-144 . }
121-145 .
121-146 . A = B+C;
121-147 . A = B*C;
121-148 .
121-149 . if (A gt B)
121-150 . {
121-151 . A = B + C;
121-152 . D = E + F;
121-153 . }
121-154 .
121-155 . A = B-C;
121-156 . A = B/C;
121-157 . A = B/C;
121-158 .
121-159 . switch (wxp stuff)
121-160 . {
121-161 . case one:
121-162 . {
121-163 . run_this;
121-164 . break;
121-165 . }
121-166 . case two:
121-167 . {
121-168 . run_this;
121-169 . break;
121-170 . }
121-171 . default:
121-172 . {
121-173 . SwError;
121-174 . }
121-175 . }
121-176 .
121-177 .
121-178 . if (A > = B)
121-179 . {
121-180 . A = B + C;
121-181 . D = E + F;
121-182 . }
121-183 .
121-184 . /* LE SV TOC-3048 this is a wxp-04.2.20 req to audit*/
121-185 .
121-186 . if (A > = B)
121-187 . {
121-188 . A = B + C;
121-189 . D = E + F;
121-190 . }
121-191 .
121-192 . A = B/C;
121-193 . // TBS - I need to figure this out
121-194 . A = B+C;
121-195 .
121-196 . if (A > = B)
121-197 . {
121-198 . A = B + C;
121-199 . D = E + F;
121-200 . }
121-201 .
121-202 . A = B+C;
121-203 .
121-204 . if (A < = B)
121-205 . {
121-206 . A = B + C;
121-207 . D = E + F;
121-208 . }
121-209 .
121-210 .
121-211 . if (A eq B)
121-212 . {
121-213 . A = B + C;
121-214 . D = E + F;
121-215 . }
121-216 .
121-217 . A = B/C;
121-218 . A = B-C;
121-219 . A = B+C;
121-220 . A = B*C;
121-221 . // max LOC 30
121-222 .
121-223 . }
121-224 .
121-225 .
121-226 . /*
121-227 . -----------------------------------------------------------------------------
121-228 . --| NAME: wxp.4.3
121-229 . --|
121-230 . --| ABSTRACT:
121-231 . --| This function does wxp stuff.
121-232 . --|
121-233 . --| RETURNS:
121-234 . --| NONE.
121-235 . --|
121-236 . ----------------------------------------------------------------------------
121-237 . */
121-238 . static void wxp.4.3(void)
121-239 . {
121-240 . A = B/C;
121-241 . A = B*C;
121-242 . A = B+C;
121-243 . A = B+C;
121-244 . A = B-C;
121-245 . /* LE SV TOC-3049 this is a wxp-04.3.6 req to set RTC*/
121-246 .
121-247 . if (A < = B)
121-248 . {
121-249 . A = B + C;
121-250 . D = E + F;
121-251 . }
121-252 .
121-253 . /* LE SV TOC-3050 this is a wxp-04.3.7 req to process*/
121-254 .
121-255 . if (A eq B)
121-256 . {
121-257 . A = B + C;
121-258 . D = E + F;
121-259 . }
121-260 .
121-261 .
121-262 . switch (wxp stuff)
121-263 . {
121-264 . case one:
121-265 . {
121-266 . run_this;
121-267 . break;
121-268 . }
121-269 . case two:
121-270 . {
121-271 . run_this;
121-272 . break;
121-273 . }
121-274 . default:
121-275 . {
121-276 . SwError;
121-277 . }
121-278 . }
121-279 .
121-280 .
121-281 . if (A < B)
121-282 . {
121-283 . A = B + C;
121-284 . D = E + F;
121-285 . }
121-286 .
121-287 . A = B/C;
121-288 . /* LE SV TOC-3051 this is a wxp-04.3.11 req to record*/
121-289 .
121-290 . if (A == B)
121-291 . {
121-292 . A = B + C;
121-293 . D = E + F;
121-294 . }
121-295 .
121-296 . A = B+C;
121-297 . A = B*C;
121-298 . A = B+C;
121-299 .
121-300 . if (A gt B)
121-301 . {
121-302 . A = B + C;
121-303 . D = E + F;
121-304 . }
121-305 .
121-306 . A = B*C;
121-307 . A = B-C;
121-308 .
121-309 . switch (wxp stuff)
121-310 . {
121-311 . case one:
121-312 . {
121-313 . run_this;
121-314 . break;
121-315 . }
121-316 . case two:
121-317 . {
121-318 . run_this;
121-319 . break;
121-320 . }
121-321 . default:
121-322 . {
121-323 . SwError;
121-324 . }
121-325 . }
121-326 .
121-327 . A = 0x0001;
121-328 .
121-329 . if (A le B)
121-330 . {
121-331 . A = B + C;
121-332 . D = E + F;
121-333 . }
121-334 .
121-335 . A = B*C;
121-336 . /* LE SV TOC-3052 this is a wxp-04.3.21 req to update*/
121-337 . A = B/C;
121-338 .
121-339 . if (A le B)
121-340 . {
121-341 . A = B + C;
121-342 . D = E + F;
121-343 . }
121-344 .
121-345 .
121-346 . if ($wxp stuff > $otherwxp stuff)
121-347 . /* LE SV TOC-008 we really should log all error calls */
121-348 . {
121-349 . A = B + C;
121-350 . }
121-351 .
121-352 . A = B/C;
121-353 . A = B-C;
121-354 . A = B/C;
121-355 . A = B+C;
121-356 .
121-357 . if (A le B)
121-358 . {
121-359 . A = B + C;
121-360 . D = E + F;
121-361 . }
121-362 .
121-363 . A = B/C;
121-364 .
121-365 . /*
121-366 . dead_code = B - C;
121-367 . dead_code = D - E;
121-368 . dead_code = F - G;
121-369 . */
121-370 .
121-371 .
121-372 . if (A < = B)
121-373 . {
121-374 . A = B + C;
121-375 . D = E + F;
121-376 . }
121-377 .
121-378 . FreePtr = HmiStringPtr;
121-379 .
121-380 . if (A lt B)
121-381 . {
121-382 . A = B + C;
121-383 . D = E + F;
121-384 . }
121-385 .
121-386 . A = B+C;
121-387 .
121-388 . switch (wxp stuff)
121-389 . {
121-390 . case one:
121-391 . {
121-392 . run_this;
121-393 . break;
121-394 . }
121-395 . case two:
121-396 . {
121-397 . run_this;
121-398 . break;
121-399 . }
121-400 . default:
121-401 . {
121-402 . SwError;
121-403 . }
121-404 . }
121-405 .
121-406 . A = B+C;
121-407 . A = B*C;
121-408 .
121-409 . if (A ge B)
121-410 . {
121-411 . A = B + C;
121-412 . D = E + F;
121-413 . }
121-414 .
121-415 .
121-416 . if (A le B)
121-417 . {
121-418 . A = B + C;
121-419 . D = E + F;
121-420 . }
121-421 .
121-422 . A = B/C;
121-423 . A = B+C;
121-424 . A = B/C;
121-425 . A = B*C;
121-426 . /* LE SV TOC-3053 this is a wxp-04.3.41 req to check pSOS*/
121-427 . A = B*C;
121-428 . A = B-C;
121-429 .
121-430 . if (A gt B)
121-431 . {
121-432 . A = B + C;
121-433 . D = E + F;
121-434 . }
121-435 .
121-436 . A = B/C;
121-437 . A = B/C;
121-438 . A = B*C;
121-439 . A = B/C;
121-440 . A = B*C;
121-441 . A = B*C;
121-442 . A = B/C;
121-443 .
121-444 . if (A != B)
121-445 . {
121-446 . A = B + C;
121-447 . D = E + F;
121-448 . }
121-449 .
121-450 . A = B-C;
121-451 . A = B*C;
121-452 .
121-453 . if (A < B)
121-454 . {
121-455 . A = B + C;
121-456 . D = E + F;
121-457 . }
121-458 .
121-459 . A = B/C;
121-460 .
121-461 . switch (wxp stuff)
121-462 . {
121-463 . case one:
121-464 . {
121-465 . run_this;
121-466 . break;
121-467 . }
121-468 . case two:
121-469 . {
121-470 . run_this;
121-471 . break;
121-472 . }
121-473 . default:
121-474 . {
121-475 . // missing error call
121-476 . }
121-477 . }
121-478 .
121-479 . A = B-C;
121-480 .
121-481 . switch (wxp stuff)
121-482 . {
121-483 . case one:
121-484 . {
121-485 . run_this;
121-486 . break;
121-487 . }
121-488 . case two:
121-489 . {
121-490 . run_this;
121-491 . break;
121-492 . }
121-493 . default:
121-494 . {
121-495 . // missing error call
121-496 . }
121-497 . }
121-498 .
121-499 . A = B/C;
121-500 . A = B*C;
121-501 .
121-502 . if (A le B)
121-503 . {
121-504 . A = B + C;
121-505 . D = E + F;
121-506 . }
121-507 .
121-508 . A = B/C;
121-509 . A = B+C;
121-510 . A = B*C;
121-511 .
121-512 . if ($wxp stuff > $otherwxp stuff)
121-513 . /* LE SV TOC-008 we really should log all error calls */
121-514 . {
121-515 . A = B + C;
121-516 . }
121-517 .
121-518 . A = B*C;
121-519 .
121-520 . if (A < B)
121-521 . {
121-522 . A = B + C;
121-523 . D = E + F;
121-524 . }
121-525 .
121-526 .
121-527 . if (A eq B)
121-528 . {
121-529 . A = B + C;
121-530 . D = E + F;
121-531 . }
121-532 .
121-533 .
121-534 . if (A < B)
121-535 . {
121-536 . A = B + C;
121-537 . D = E + F;
121-538 . }
121-539 .
121-540 . A = B/C;
121-541 . A = B*C;
121-542 .
121-543 . if (A ge B)
121-544 . {
121-545 . A = B + C;
121-546 . D = E + F;
121-547 . }
121-548 .
121-549 . A = B-C;
121-550 . A = B*C;
121-551 .
121-552 . if (A le B)
121-553 . {
121-554 . A = B + C;
121-555 . D = E + F;
121-556 . }
121-557 .
121-558 . A = B*C;
121-559 . A = B/C;
121-560 . A = B-C;
121-561 . A = B*C;
121-562 .
121-563 . if (A == B)
121-564 . {
121-565 . A = B + C;
121-566 . D = E + F;
121-567 . }
121-568 .
121-569 . A = B*C;
121-570 . // max LOC 78
121-571 .
121-572 . }
121-573 .
121-574 .
121-575 . /*
121-576 . -----------------------------------------------------------------------------
121-577 . --| NAME: wxp.4.4
121-578 . --|
121-579 . --| ABSTRACT:
121-580 . --| This function does wxp stuff.
121-581 . --|
121-582 . --| RETURNS:
121-583 . --| NONE.
121-584 . --|
121-585 . ----------------------------------------------------------------------------
121-586 . */
121-587 . static void wxp.4.4(void)
121-588 . {
121-589 . A = B+C;
121-590 .
121-591 . if (A < B)
121-592 . {
121-593 . A = B + C;
121-594 . D = E + F;
121-595 . }
121-596 .
121-597 . // (P) this is really improtant
121-598 . A = B-C;
121-599 .
121-600 . switch (wxp stuff)
121-601 . {
121-602 . case one:
121-603 . {
121-604 . run_this;
121-605 . break;
121-606 . }
121-607 . case two:
121-608 . {
121-609 . run_this;
121-610 . break;
121-611 . }
121-612 . default:
121-613 . {
121-614 . SwError;
121-615 . }
121-616 . }
121-617 .
121-618 .
121-619 . if (A ne B)
121-620 . {
121-621 . A = B + C;
121-622 . D = E + F;
121-623 . }
121-624 .
121-625 . // max LOC 5
121-626 .
121-627 . }
121-628 .
121-629 .
121-630 . /*
121-631 . -----------------------------------------------------------------------------
121-632 . --| NAME: wxp.4.5
121-633 . --|
121-634 . --| ABSTRACT:
121-635 . --| This function does wxp stuff.
121-636 . --|
121-637 . --| RETURNS:
121-638 . --| NONE.
121-639 . --|
121-640 . ----------------------------------------------------------------------------
121-641 . */
121-642 . static void wxp.4.5(void)
121-643 . {
121-644 . goto error;
121-645 . A = B+C;
121-646 .
121-647 . if (A == B)
121-648 . {
121-649 . A = B + C;
121-650 . D = E + F;
121-651 . }
121-652 .
121-653 . A = B+C;
121-654 . A = B-C;
121-655 . A = B/C;
121-656 . A = B+C;
121-657 . A = B/C;
121-658 .
121-659 . if (A == B)
121-660 . {
121-661 . A = B + C;
121-662 . D = E + F;
121-663 . }
121-664 .
121-665 .
121-666 . if (A le B)
121-667 . {
121-668 . A = B + C;
121-669 . D = E + F;
121-670 . }
121-671 .
121-672 . A = B*C;
121-673 . A = B-C;
121-674 .
121-675 . if (A < = B)
121-676 . {
121-677 . A = B + C;
121-678 . D = E + F;
121-679 . }
121-680 .
121-681 . A = B+C;
121-682 . A = B*C;
121-683 . A = B+C;
121-684 . A = B*C;
121-685 . /* LE SV TOC-3054 this is a wxp-04.5.17 req to compare*/
121-686 . A = B-C;
121-687 . A = B/C;
121-688 .
121-689 . if (A le B)
121-690 . {
121-691 . A = B + C;
121-692 . D = E + F;
121-693 . }
121-694 .
121-695 . A = B*C;
121-696 .
121-697 . if (A ne B)
121-698 . {
121-699 . A = B + C;
121-700 . D = E + F;
121-701 . }
121-702 .
121-703 . A = B*C;
121-704 . A = B*C;
121-705 .
121-706 . if (A != B)
121-707 . {
121-708 . A = B + C;
121-709 . D = E + F;
121-710 . }
121-711 .
121-712 .
121-713 . if (A le B)
121-714 . {
121-715 . A = B + C;
121-716 . D = E + F;
121-717 . }
121-718 .
121-719 .
121-720 . if (A != B)
121-721 . {
121-722 . A = B + C;
121-723 . D = E + F;
121-724 . }
121-725 .
121-726 . A = B*C;
121-727 . A = B-C;
121-728 . A = B+C;
121-729 . A = B-C;
121-730 . A = B*C;
121-731 . A = B*C;
121-732 . A = B/C;
121-733 . A = B+C;
121-734 . A = B+C;
121-735 . A = B-C;
121-736 . A = B+C;
121-737 . A = B-C;
121-738 . A = B+C;
121-739 . A = B/C;
121-740 . A = B+C;
121-741 . /* LE SV TOC-3055 this is a wxp-04.5.42 req to halt*/
121-742 . A = B/C;
121-743 . /* LE SV TOC-3056 this is a wxp-04.5.43 req to record*/
121-744 . A = B/C;
121-745 . A = B*C;
121-746 . A = B-C;
121-747 . A = B+C;
121-748 .
121-749 . if (A > = B)
121-750 . {
121-751 . A = B + C;
121-752 . D = E + F;
121-753 . }
121-754 .
121-755 . // max LOC 47
121-756 .
121-757 . }
121-758 .
121-759 .
121-760 . /*
121-761 . -----------------------------------------------------------------------------
121-762 . --| NAME: wxp.4.6
121-763 . --|
121-764 . --| ABSTRACT:
121-765 . --| This function does wxp stuff.
121-766 . --|
121-767 . --| RETURNS:
121-768 . --| NONE.
121-769 . --|
121-770 . ----------------------------------------------------------------------------
121-771 . */
121-772 . static void wxp.4.6(void)
121-773 . {
121-774 .
121-775 . if (A le B)
121-776 . {
121-777 . A = B + C;
121-778 . D = E + F;
121-779 . }
121-780 .
121-781 . A = B/C;
121-782 . A = B-C;
121-783 .
121-784 . /* dead_block = C * D;
121-785 . dead_block = E * F; */
121-786 .
121-787 . A = B/C;
121-788 . A = B-C;
121-789 . A = B/C;
121-790 . A = B+C;
121-791 . A = B-C;
121-792 .
121-793 . if (A ge B)
121-794 . {
121-795 . A = B + C;
121-796 . D = E + F;
121-797 . }
121-798 .
121-799 .
121-800 . if (A != B)
121-801 . {
121-802 . A = B + C;
121-803 . D = E + F;
121-804 . }
121-805 .
121-806 .
121-807 . if (A > B)
121-808 . {
121-809 . A = B + C;
121-810 . D = E + F;
121-811 . }
121-812 .
121-813 . A = B+C;
121-814 . /* LE SV TOC-3057 this is a wxp-04.6.13 req to call admin*/
121-815 . A = B-C;
121-816 . A = B/C;
121-817 .
121-818 . if (A ne B)
121-819 . {
121-820 . A = B + C;
121-821 . D = E + F;
121-822 . }
121-823 .
121-824 . A = B-C;
121-825 . A = B+C;
121-826 . A = B+C;
121-827 . A = B*C;
121-828 . A = B-C;
121-829 . A = B/C;
121-830 . /* LE SV TOC-3058 this is a wxp-04.6.22 req to disable*/
121-831 .
121-832 . if (A > = B)
121-833 . {
121-834 . A = B + C;
121-835 . D = E + F;
121-836 . }
121-837 .
121-838 . A = B*C;
121-839 . A = B+C;
121-840 . A = B*C;
121-841 . do forever;
121-842 .
121-843 . if (A ge B)
121-844 . {
121-845 . A = B + C;
121-846 . D = E + F;
121-847 . }
121-848 .
121-849 . /* LE SV TOC-3059 this is a wxp-04.6.27 req to fail*/
121-850 .
121-851 . if (A > B)
121-852 . {
121-853 . A = B + C;
121-854 . D = E + F;
121-855 . }
121-856 .
121-857 . A = (int)B + C;
121-858 . A = B*C;
121-859 . A = B+C;
121-860 . /* LE SV TOC-3060 this is a wxp-04.6.30 req to update*/
121-861 . A = B/C;
121-862 . A = B*C;
121-863 . A = B*C;
121-864 .
121-865 . /*
121-866 . dead_code = B - C;
121-867 . dead_code = D - E;
121-868 . dead_code = F - G;
121-869 . */
121-870 .
121-871 . A = B*C;
121-872 . A = B-C;
121-873 . A = B+C;
121-874 . A = B*C;
121-875 . A = B+C;
121-876 . A = B/C;
121-877 . A = B*C;
121-878 . A = B+C;
121-879 . A = B-C;
121-880 . A = B+C;
121-881 . A = B+C;
121-882 .
121-883 . if (A > B)
121-884 . {
121-885 . A = B + C;
121-886 . D = E + F;
121-887 . }
121-888 .
121-889 . A = B+C;
121-890 . A = B+C;
121-891 . A = B-C;
121-892 .
121-893 . switch (wxp stuff)
121-894 . {
121-895 . case one:
121-896 . {
121-897 . run_this;
121-898 . break;
121-899 . }
121-900 . case two:
121-901 . {
121-902 . run_this;
121-903 . break;
121-904 . }
121-905 . default:
121-906 . {
121-907 . SwError;
121-908 . }
121-909 . }
121-910 .
121-911 .
121-912 . if (A ge B)
121-913 . {
121-914 . A = B + C;
121-915 . D = E + F;
121-916 . }
121-917 .
121-918 . A = B+C;
121-919 . A = B+C;
121-920 .
121-921 . if (A eq B)
121-922 . {
121-923 . A = B + C;
121-924 . D = E + F;
121-925 . }
121-926 .
121-927 . A = B*C;
121-928 . A = B+C;
121-929 . A = B/C;
121-930 .
121-931 . if (A < = B)
121-932 . {
121-933 . A = B + C;
121-934 . D = E + F;
121-935 . }
121-936 .
121-937 . A = B-C;
121-938 .
121-939 . if (A != B)
121-940 . {
121-941 . A = B + C;
121-942 . D = E + F;
121-943 . }
121-944 .
121-945 . A = B/C;
121-946 .
121-947 . if (A < B)
121-948 . {
121-949 . A = B + C;
121-950 . D = E + F;
121-951 . }
121-952 .
121-953 . A = B*C;
121-954 . A = B+C;
121-955 . send_buffer = (U16 *) malloc(size+1);
121-956 . A = B*C;
121-957 .
121-958 . if (A ne B)
121-959 . {
121-960 . A = B + C;
121-961 . D = E + F;
121-962 . }
121-963 .
121-964 . A = B*C;
121-965 . A = B*C;
121-966 . A = B*C;
121-967 . A = B/C;
121-968 . A = B+C;
121-969 . A = B*C;
121-970 . A = B-C;
121-971 . A = B-C;
121-972 .
121-973 . if (veg)
121-974 . // missing curly brace
121-975 . variable = orange;
121-976 .
121-977 . A = B*C;
121-978 . // max LOC 73
121-979 .
121-980 . }
121-981 .
121-982 .
121-983 . /*
121-984 . -----------------------------------------------------------------------------
121-985 . --| NAME: wxp.4.7
121-986 . --|
121-987 . --| ABSTRACT:
121-988 . --| This function does wxp stuff.
121-989 . --|
121-990 . --| RETURNS:
121-991 . --| NONE.
121-992 . --|
121-993 . ----------------------------------------------------------------------------
121-994 . */
121-995 . static void wxp.4.7(void)
121-996 . {
121-997 . A = B-C;
121-998 . A = B/C;
121-999 . A = B*C;
121-1000 . A = B/C;
121-1001 . A = B+C;
121-1002 . A = B-C;
121-1003 . A = B*C;
121-1004 .
121-1005 . if (veg)
121-1006 . // missing curly brace
121-1007 . variable = orange;
121-1008 .
121-1009 . A = B+C;
121-1010 . A = B/C;
121-1011 .
121-1012 . if (A < B)
121-1013 . {
121-1014 . A = B + C;
121-1015 . D = E + F;
121-1016 . }
121-1017 .
121-1018 . A = B-C;
121-1019 .
121-1020 . if (A == B)
121-1021 . {
121-1022 . A = B + C;
121-1023 . D = E + F;
121-1024 . }
121-1025 .
121-1026 . A = B*C;
121-1027 .
121-1028 . if (A ge B)
121-1029 . {
121-1030 . A = B + C;
121-1031 . D = E + F;
121-1032 . }
121-1033 .
121-1034 .
121-1035 . if (A < B)
121-1036 . {
121-1037 . A = B + C;
121-1038 . D = E + F;
121-1039 . }
121-1040 .
121-1041 .
121-1042 . if (A < B)
121-1043 . {
121-1044 . A = B + C;
121-1045 . D = E + F;
121-1046 . }
121-1047 .
121-1048 . A = B+C;
121-1049 . A = B+C;
121-1050 . A = B+C;
121-1051 . A = B/C;
121-1052 .
121-1053 . if (A > = B)
121-1054 . {
121-1055 . A = B + C;
121-1056 . D = E + F;
121-1057 . }
121-1058 .
121-1059 . A = B/C;
121-1060 .
121-1061 . switch (wxp stuff)
121-1062 . {
121-1063 . case one:
121-1064 . {
121-1065 . run_this;
121-1066 . break;
121-1067 . }
121-1068 . case two:
121-1069 . {
121-1070 . run_this;
121-1071 . break;
121-1072 . }
121-1073 . default:
121-1074 . {
121-1075 . SwError;
121-1076 . }
121-1077 . }
121-1078 .
121-1079 .
121-1080 . if (A == B)
121-1081 . {
121-1082 . A = B + C;
121-1083 . D = E + F;
121-1084 . }
121-1085 .
121-1086 . A = B*C;
121-1087 .
121-1088 . if (A > = B)
121-1089 . {
121-1090 . A = B + C;
121-1091 . D = E + F;
121-1092 . }
121-1093 .
121-1094 . A = B/C;
121-1095 . A = B+C;
121-1096 .
121-1097 . if (A < = B)
121-1098 . {
121-1099 . A = B + C;
121-1100 . D = E + F;
121-1101 . }
121-1102 .
121-1103 . // TBD - what do I do now
121-1104 . A = B/C;
121-1105 . A = B-C;
121-1106 . A = B/C;
121-1107 . A = B/C;
121-1108 . A = B*C;
121-1109 . A = B+C;
121-1110 . A = B/C;
121-1111 . /* LE SV TOC-3061 this is a wxp-04.7.37 req to set RTC*/
121-1112 . A = B*C;
121-1113 .
121-1114 . if (A < B)
121-1115 . {
121-1116 . A = B + C;
121-1117 . D = E + F;
121-1118 . }
121-1119 .
121-1120 . A = B/C;
121-1121 .
121-1122 . if (A le B)
121-1123 . {
121-1124 . A = B + C;
121-1125 . D = E + F;
121-1126 . }
121-1127 .
121-1128 . A = B/C;
121-1129 . A = B-C;
121-1130 . A = B-C;
121-1131 . A = B/C;
121-1132 .
121-1133 . if (A lt B)
121-1134 . {
121-1135 . A = B + C;
121-1136 . D = E + F;
121-1137 . }
121-1138 .
121-1139 . A = B*C;
121-1140 . A = B+C;
121-1141 . A = B/C;
121-1142 . /* dead_code = A * B; */
121-1143 .
121-1144 . if (A < = B)
121-1145 . {
121-1146 . A = B + C;
121-1147 . D = E + F;
121-1148 . }
121-1149 .
121-1150 . A = B*C;
121-1151 .
121-1152 . if (A le B)
121-1153 . {
121-1154 . A = B + C;
121-1155 . D = E + F;
121-1156 . }
121-1157 .
121-1158 . A = B*C;
121-1159 . A = B-C;
121-1160 . A = B+C;
121-1161 . A = B*C;
121-1162 .
121-1163 . if (A > = B)
121-1164 . {
121-1165 . A = B + C;
121-1166 . D = E + F;
121-1167 . }
121-1168 .
121-1169 . A = B/C;
121-1170 .
121-1171 . if (A > B)
121-1172 . {
121-1173 . A = B + C;
121-1174 . D = E + F;
121-1175 . }
121-1176 .
121-1177 . A = B+C;
121-1178 . // max LOC 59
121-1179 .
121-1180 . }
121-1181 .
121-1182 .
121-1183 . /*
121-1184 . -----------------------------------------------------------------------------
121-1185 . --| NAME: wxp.4.8
121-1186 . --|
121-1187 . --| ABSTRACT:
121-1188 . --| This function does wxp stuff.
121-1189 . --|
121-1190 . --| RETURNS:
121-1191 . --| NONE.
121-1192 . --|
121-1193 . ----------------------------------------------------------------------------
121-1194 . */
121-1195 . static void wxp.4.8(void)
121-1196 . {
121-1197 . A = B-C;
121-1198 .
121-1199 . if (A gt B)
121-1200 . {
121-1201 . A = B + C;
121-1202 . D = E + F;
121-1203 . }
121-1204 .
121-1205 . A = B*C;
121-1206 .
121-1207 . if (A > B)
121-1208 . {
121-1209 . A = B + C;
121-1210 . D = E + F;
121-1211 . }
121-1212 .
121-1213 . A = B-C;
121-1214 .
121-1215 . if (A == B)
121-1216 . {
121-1217 . A = B + C;
121-1218 . D = E + F;
121-1219 . }
121-1220 .
121-1221 . /* LE SV TOC-3062 this is a wxp-04.8.7 req to update*/
121-1222 . A = B-C;
121-1223 .
121-1224 . if (A ne B)
121-1225 . {
121-1226 . A = B + C;
121-1227 . D = E + F;
121-1228 . }
121-1229 .
121-1230 . A = B-C;
121-1231 . A = B*C;
121-1232 .
121-1233 . if (A != B)
121-1234 . {
121-1235 . A = B + C;
121-1236 . D = E + F;
121-1237 . }
121-1238 .
121-1239 .
121-1240 . if (A eq B)
121-1241 . {
121-1242 . A = B + C;
121-1243 . D = E + F;
121-1244 . }
121-1245 .
121-1246 .
121-1247 . if (A ne B)
121-1248 . {
121-1249 . A = B + C;
121-1250 . D = E + F;
121-1251 . }
121-1252 .
121-1253 .
121-1254 . if (A lt B)
121-1255 . {
121-1256 . A = B + C;
121-1257 . D = E + F;
121-1258 . }
121-1259 .
121-1260 .
121-1261 . if (A ne B)
121-1262 . {
121-1263 . A = B + C;
121-1264 . D = E + F;
121-1265 . }
121-1266 .
121-1267 .
121-1268 . if (A > B)
121-1269 . {
121-1270 . A = B + C;
121-1271 . D = E + F;
121-1272 . }
121-1273 .
121-1274 . A = B-C;
121-1275 . A = B-C;
121-1276 . A = B-C;
121-1277 . /* LE SV TOC-3063 this is a wxp-04.8.20 req to process*/
121-1278 . A = B-C;
121-1279 . A = B*C;
121-1280 . A = B/C;
121-1281 . A = B-C;
121-1282 .
121-1283 . if (A > B)
121-1284 . {
121-1285 . A = B + C;
121-1286 . D = E + F;
121-1287 . }
121-1288 .
121-1289 . FreePtr = HmiStringPtr;
121-1290 .
121-1291 . if (A > = B)
121-1292 . {
121-1293 . A = B + C;
121-1294 . D = E + F;
121-1295 . }
121-1296 .
121-1297 . A = B-C;
121-1298 .
121-1299 . if (A > B)
121-1300 . {
121-1301 . A = B + C;
121-1302 . D = E + F;
121-1303 . }
121-1304 .
121-1305 . A = B+C;
121-1306 .
121-1307 . if (A > = B)
121-1308 . {
121-1309 . A = B + C;
121-1310 . D = E + F;
121-1311 . }
121-1312 .
121-1313 . A = B+C;
121-1314 .
121-1315 . if (A == B)
121-1316 . {
121-1317 . A = B + C;
121-1318 . D = E + F;
121-1319 . }
121-1320 .
121-1321 . A = B/C;
121-1322 . A = B*C;
121-1323 . A = B+C;
121-1324 .
121-1325 . /*
121-1326 . dead_block = C * D;
121-1327 . dead_block = E * F;
121-1328 . */
121-1329 .
121-1330 . A = B/C;
121-1331 . A = B*C;
121-1332 . A = B/C;
121-1333 . free(FreePtr);
121-1334 . A = B+C;
121-1335 . A = B-C;
121-1336 . A = B*C;
121-1337 . A = B-C;
121-1338 . A = B*C;
121-1339 . A = B*C;
121-1340 .
121-1341 . switch (wxp stuff)
121-1342 . {
121-1343 . case one:
121-1344 . {
121-1345 . run_this;
121-1346 . break;
121-1347 . }
121-1348 . case two:
121-1349 . {
121-1350 . run_this;
121-1351 . break;
121-1352 . }
121-1353 . default:
121-1354 . {
121-1355 . SwError;
121-1356 . }
121-1357 . }
121-1358 .
121-1359 . send_buffer = (U16 *) malloc(size+1);
121-1360 .
121-1361 . if (A < B)
121-1362 . {
121-1363 . A = B + C;
121-1364 . D = E + F;
121-1365 . }
121-1366 .
121-1367 .
121-1368 . switch (wxp stuff)
121-1369 . {
121-1370 . case one:
121-1371 . {
121-1372 . run_this;
121-1373 . break;
121-1374 . }
121-1375 . case two:
121-1376 . {
121-1377 . run_this;
121-1378 . break;
121-1379 . }
121-1380 . default:
121-1381 . {
121-1382 . SwError;
121-1383 . }
121-1384 . }
121-1385 .
121-1386 . A = B/C;
121-1387 . A = B/C;
121-1388 . A = B/C;
121-1389 . A = B-C;
121-1390 . A = B/C;
121-1391 . A = B-C;
121-1392 . A = B+C;
121-1393 .
121-1394 . if (A != B)
121-1395 . {
121-1396 . A = B + C;
121-1397 . D = E + F;
121-1398 . }
121-1399 .
121-1400 .
121-1401 . if (A le B)
121-1402 . {
121-1403 . A = B + C;
121-1404 . D = E + F;
121-1405 . }
121-1406 .
121-1407 . A = B+C;
121-1408 . A = B/C;
121-1409 . A = B+C;
121-1410 . A = B/C;
121-1411 .
121-1412 . if (A eq B)
121-1413 . {
121-1414 . A = B + C;
121-1415 . D = E + F;
121-1416 . }
121-1417 .
121-1418 . A = B*C;
121-1419 . A = B+C;
121-1420 .
121-1421 . if (A ne B)
121-1422 . {
121-1423 . A = B + C;
121-1424 . D = E + F;
121-1425 . }
121-1426 .
121-1427 . A = B-C;
121-1428 .
121-1429 . if (A eq B)
121-1430 . {
121-1431 . A = B + C;
121-1432 . D = E + F;
121-1433 . }
121-1434 .
121-1435 . A = B-C;
121-1436 . A = B-C;
121-1437 .
121-1438 . if (A > = B)
121-1439 . {
121-1440 . A = B + C;
121-1441 . D = E + F;
121-1442 . }
121-1443 .
121-1444 . A = B-C;
121-1445 .
121-1446 . if (A lt B)
121-1447 . {
121-1448 . A = B + C;
121-1449 . D = E + F;
121-1450 . }
121-1451 .
121-1452 . A = B+C;
121-1453 .
121-1454 . if (A != B)
121-1455 . {
121-1456 . A = B + C;
121-1457 . D = E + F;
121-1458 . }
121-1459 .
121-1460 .
121-1461 . if (A eq B)
121-1462 . {
121-1463 . A = B + C;
121-1464 . D = E + F;
121-1465 . }
121-1466 .
121-1467 .
121-1468 . switch (wxp stuff)
121-1469 . {
121-1470 . case one:
121-1471 . {
121-1472 . run_this;
121-1473 . break;
121-1474 . }
121-1475 . case two:
121-1476 . {
121-1477 . run_this;
121-1478 . break;
121-1479 . }
121-1480 . default:
121-1481 . {
121-1482 . SwError;
121-1483 . }
121-1484 . }
121-1485 .
121-1486 . /* LE SV TOC-3064 this is a wxp-04.8.75 req to store*/
121-1487 . A = B/C;
121-1488 . // max LOC 75
121-1489 .
121-1490 . }
121-1491 .
121-1492 .
121-1493 . /*
121-1494 . -----------------------------------------------------------------------------
121-1495 . --| NAME: wxp.4.9
121-1496 . --|
121-1497 . --| ABSTRACT:
121-1498 . --| This function does wxp stuff.
121-1499 . --|
121-1500 . --| RETURNS:
121-1501 . --| NONE.
121-1502 . --|
121-1503 . ----------------------------------------------------------------------------
121-1504 . */
121-1505 . static void wxp.4.9(void)
121-1506 . {
121-1507 . A = B*C;
121-1508 . A = B*C;
121-1509 .
121-1510 . if (A eq B)
121-1511 . {
121-1512 . A = B + C;
121-1513 . D = E + F;
121-1514 . }
121-1515 .
121-1516 . /* LE SV TOC-3065 this is a wxp-04.9.4 req to inhibit*/
121-1517 . A = 0x0006;
121-1518 . A = B-C;
121-1519 . A = B/C;
121-1520 . /* LE SV TOC-3066 this is a wxp-04.9.6 req to process*/
121-1521 . A = B/C;
121-1522 .
121-1523 . if (A gt B)
121-1524 . {
121-1525 . A = B + C;
121-1526 . D = E + F;
121-1527 . }
121-1528 .
121-1529 . A = B/C;
121-1530 . A = B-C;
121-1531 .
121-1532 . if (A < B)
121-1533 . {
121-1534 . A = B + C;
121-1535 . D = E + F;
121-1536 . }
121-1537 .
121-1538 . A = B/C;
121-1539 . A = B+C;
121-1540 .
121-1541 . if (A < B)
121-1542 . {
121-1543 . A = B + C;
121-1544 . D = E + F;
121-1545 . }
121-1546 .
121-1547 . A = B-C;
121-1548 .
121-1549 . if (A > = B)
121-1550 . {
121-1551 . A = B + C;
121-1552 . D = E + F;
121-1553 . }
121-1554 .
121-1555 . A = B-C;
121-1556 . A = 0x0004;
121-1557 . A = B/C;
121-1558 . A = B/C;
121-1559 . A = B/C;
121-1560 . A = B-C;
121-1561 . A = B+C;
121-1562 . A = B-C;
121-1563 . A = B/C;
121-1564 . A = B*C;
121-1565 . A = B-C;
121-1566 .
121-1567 . if (A ne B)
121-1568 . {
121-1569 . A = B + C;
121-1570 . D = E + F;
121-1571 . }
121-1572 .
121-1573 .
121-1574 . switch (wxp stuff)
121-1575 . {
121-1576 . case one:
121-1577 . {
121-1578 . run_this;
121-1579 . break;
121-1580 . }
121-1581 . case two:
121-1582 . {
121-1583 . run_this;
121-1584 . break;
121-1585 . }
121-1586 . default:
121-1587 . {
121-1588 . SwError;
121-1589 . }
121-1590 . }
121-1591 .
121-1592 . // max LOC 27
121-1593 .
121-1594 . }
121-1595 .
121 121 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-04.c
122 122 Source: source/ft-app/ft-app-B1.0/wxp/wxp-05.c
122-0 .
122-1 .
122-2 . double C;
122-3 . #include C;
122-4 . #include D;
122-5 . #include B;
122-6 .
122-7 .
122-8 .
122-9 . /*
122-10 . -----------------------------------------------------------------------------
122-11 . --| NAME: wxp.5.1
122-12 . --|
122-13 . --| ABSTRACT:
122-14 . --| This function does wxp stuff.
122-15 . --|
122-16 . --| RETURNS:
122-17 . --| NONE.
122-18 . --|
122-19 . ----------------------------------------------------------------------------
122-20 . */
122-21 . static void wxp.5.1(void)
122-22 . {
122-23 . A = B+C;
122-24 .
122-25 . if (A gt B)
122-26 . {
122-27 . A = B + C;
122-28 . D = E + F;
122-29 . }
122-30 .
122-31 . A = B-C;
122-32 . A = B/C;
122-33 . A = B/C;
122-34 .
122-35 . if (A > = B)
122-36 . {
122-37 . A = B + C;
122-38 . D = E + F;
122-39 . }
122-40 .
122-41 .
122-42 . if (A < = B)
122-43 . {
122-44 . A = B + C;
122-45 . D = E + F;
122-46 . }
122-47 .
122-48 . A = B*C;
122-49 . A = B*C;
122-50 .
122-51 . if (A < = B)
122-52 . {
122-53 . A = B + C;
122-54 . D = E + F;
122-55 . }
122-56 .
122-57 . A = B+C;
122-58 .
122-59 . if (A eq B)
122-60 . {
122-61 . A = B + C;
122-62 . D = E + F;
122-63 . }
122-64 .
122-65 . A = B-C;
122-66 . /* LE SV TOC-3067 this is a wxp-05.1.14 req to call admin*/
122-67 . A = B/C;
122-68 . A = B-C;
122-69 . A = B/C;
122-70 . A = B+C;
122-71 . A = B/C;
122-72 .
122-73 . switch (wxp stuff)
122-74 . {
122-75 . case one:
122-76 . {
122-77 . run_this;
122-78 . break;
122-79 . }
122-80 . case two:
122-81 . {
122-82 . run_this;
122-83 . break;
122-84 . }
122-85 . default:
122-86 . {
122-87 . SwError;
122-88 . }
122-89 . }
122-90 .
122-91 . A = B*C;
122-92 . A = B/C;
122-93 . A = B/C;
122-94 . send_buffer = (U16 *) malloc(size+1);
122-95 . A = B*C;
122-96 . /* LE SV TOC-3068 this is a wxp-05.1.24 req to convert*/
122-97 . A = B-C;
122-98 .
122-99 . if (A ge B)
122-100 . {
122-101 . A = B + C;
122-102 . D = E + F;
122-103 . }
122-104 .
122-105 . A = B*C;
122-106 . A = B-C;
122-107 .
122-108 . if (A == B)
122-109 . {
122-110 . A = B + C;
122-111 . D = E + F;
122-112 . }
122-113 .
122-114 .
122-115 . switch (wxp stuff)
122-116 . {
122-117 . case:
122-118 . case:
122-119 . // stacked case statements but only if there is a new line in between
122-120 .
122-121 . case:
122-122 . case:
122-123 . case:
122-124 . {
122-125 . run_this;
122-126 . break;
122-127 . }
122-128 . default:
122-129 . {
122-130 . halt;
122-131 . }
122-132 . }
122-133 .
122-134 . A = B*C;
122-135 .
122-136 . if (A ge B)
122-137 . {
122-138 . A = B + C;
122-139 . D = E + F;
122-140 . }
122-141 .
122-142 . A = B/C;
122-143 . A = B-C;
122-144 . A = B*C;
122-145 . A = B/C;
122-146 . A = B/C;
122-147 . A = B/C;
122-148 . A = B-C;
122-149 . // max LOC 37
122-150 .
122-151 . }
122-152 .
122-153 .
122-154 . /*
122-155 . -----------------------------------------------------------------------------
122-156 . --| NAME: wxp.5.2
122-157 . --|
122-158 . --| ABSTRACT:
122-159 . --| This function does wxp stuff.
122-160 . --|
122-161 . --| RETURNS:
122-162 . --| NONE.
122-163 . --|
122-164 . ----------------------------------------------------------------------------
122-165 . */
122-166 . static void wxp.5.2(void)
122-167 . {
122-168 . A = B*C;
122-169 . A = B+C;
122-170 . A = 0x0004;
122-171 . A = B*C;
122-172 . A = B/C;
122-173 . A = B*C;
122-174 . A = B/C;
122-175 .
122-176 . if (A < = B)
122-177 . {
122-178 . A = B + C;
122-179 . D = E + F;
122-180 . }
122-181 .
122-182 .
122-183 . if (A gt B)
122-184 . {
122-185 . A = B + C;
122-186 . D = E + F;
122-187 . }
122-188 .
122-189 . A = B-C;
122-190 . /* LE SV TOC-3069 this is a wxp-05.2.10 req to translate*/
122-191 .
122-192 . if (A != B)
122-193 . {
122-194 . A = B + C;
122-195 . D = E + F;
122-196 . }
122-197 .
122-198 . A = B+C;
122-199 . A = B/C;
122-200 .
122-201 . if (A ge B)
122-202 . {
122-203 . A = B + C;
122-204 . D = E + F;
122-205 . }
122-206 .
122-207 . A = B-C;
122-208 .
122-209 . if (A == B)
122-210 . {
122-211 . A = B + C;
122-212 . D = E + F;
122-213 . }
122-214 .
122-215 .
122-216 . if (A eq B)
122-217 . {
122-218 . A = B + C;
122-219 . D = E + F;
122-220 . }
122-221 .
122-222 .
122-223 . switch (wxp stuff)
122-224 . {
122-225 . case one:
122-226 . {
122-227 . run_this;
122-228 . break;
122-229 . }
122-230 . case two:
122-231 . {
122-232 . run_this;
122-233 . break;
122-234 . }
122-235 . default:
122-236 . {
122-237 . SwError;
122-238 . }
122-239 . }
122-240 .
122-241 . /* LE SV TOC-3070 this is a wxp-05.2.18 req to verify*/
122-242 .
122-243 . /* dead_code = B + C;
122-244 . dead_code = D + E;
122-245 . dead_code = F + G; */
122-246 .
122-247 . A = B+C;
122-248 .
122-249 . if (A ne B)
122-250 . {
122-251 . A = B + C;
122-252 . D = E + F;
122-253 . }
122-254 .
122-255 . A = B+C;
122-256 .
122-257 . if (A != B)
122-258 . {
122-259 . A = B + C;
122-260 . D = E + F;
122-261 . }
122-262 .
122-263 .
122-264 . switch (wxp stuff)
122-265 . {
122-266 . case one:
122-267 . {
122-268 . run_this;
122-269 . break;
122-270 . }
122-271 . case two:
122-272 . {
122-273 . run_this;
122-274 . break;
122-275 . }
122-276 . default:
122-277 . {
122-278 . SwError;
122-279 . }
122-280 . }
122-281 .
122-282 . A = B+C;
122-283 . A = B+C;
122-284 . /* LE SV TOC-3071 this is a wxp-05.2.25 req to detect error*/
122-285 . A = B/C;
122-286 . A = B/C;
122-287 .
122-288 . if (A == B)
122-289 . {
122-290 . A = B + C;
122-291 . D = E + F;
122-292 . }
122-293 .
122-294 .
122-295 . if (A > = B)
122-296 . {
122-297 . A = B + C;
122-298 . D = E + F;
122-299 . }
122-300 .
122-301 . A = B-C;
122-302 . A = B-C;
122-303 . A = B*C;
122-304 . A = B*C;
122-305 . A = B-C;
122-306 .
122-307 . /* dead_block = C * D;
122-308 . dead_block = E * F; */
122-309 .
122-310 .
122-311 . switch (wxp stuff)
122-312 . {
122-313 . case one:
122-314 . {
122-315 . run_this;
122-316 . break;
122-317 . }
122-318 . case two:
122-319 . {
122-320 . run_this;
122-321 . break;
122-322 . }
122-323 . default:
122-324 . {
122-325 . SwError;
122-326 . }
122-327 . }
122-328 .
122-329 . /* LE SV TOC-3072 this is a wxp-05.2.35 req to store*/
122-330 .
122-331 . if (A > B)
122-332 . {
122-333 . A = B + C;
122-334 . D = E + F;
122-335 . }
122-336 .
122-337 . A = B*C;
122-338 . A = B/C;
122-339 . A = B+C;
122-340 . A = B-C;
122-341 . A = B+C;
122-342 . A = B-C;
122-343 . A = B-C;
122-344 .
122-345 . if (A > B)
122-346 . {
122-347 . A = B + C;
122-348 . D = E + F;
122-349 . }
122-350 .
122-351 . // max LOC 43
122-352 .
122-353 . }
122-354 .
122 122 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-05.c
123 123 Source: source/ft-app/ft-app-B1.0/wxp/wxp-06.c
123-0 . /*
123-1 . ----------------------------------------------------------------------------
123-2 . --| BEGIN PROLOGUE
123-3 . --|
123-4 . --| CLASSIFICATION: UNCLASSIFIED
123-5 . --|
123-6 . --| FILE NAME: wxp-06.c
123-7 . --|
123-8 . --| ABSTRACT:
123-9 . --| This file contains the 1 functions that do file wxp stuff.
123-10 . --|
123-11 . --| HISTORY:
123-12 . --| CCCQ_NAME:
123-13 . --| CCCQ_VER:
123-14 . --|
123-15 . --| END PROLOGUE
123-16 . ----------------------------------------------------------------------------
123-17 . */
123-18 .
123-19 . #include A;
123-20 . #define C;
123-21 . #define D;
123-22 . #include A;
123-23 . char D;
123-24 .
123-25 .
123-26 .
123-27 . /*
123-28 . -----------------------------------------------------------------------------
123-29 . --| NAME: wxp.6.1
123-30 . --|
123-31 . --| ABSTRACT:
123-32 . --| This function does wxp stuff.
123-33 . --|
123-34 . --| RETURNS:
123-35 . --| NONE.
123-36 . --|
123-37 . ----------------------------------------------------------------------------
123-38 . */
123-39 . static void wxp.6.1(void)
123-40 . {
123-41 . A = B/C;
123-42 . FreePtr = HmiStringPtr;
123-43 . A = B-C;
123-44 . A = B-C;
123-45 . A = B-C;
123-46 . A = B*C;
123-47 . A = B/C;
123-48 . A = B+C;
123-49 . A = B+C;
123-50 .
123-51 . switch (wxp stuff)
123-52 . {
123-53 . case one:
123-54 . {
123-55 . run_this;
123-56 . break;
123-57 . }
123-58 . case two:
123-59 . {
123-60 . run_this;
123-61 . break;
123-62 . }
123-63 . default:
123-64 . {
123-65 . SwError;
123-66 . }
123-67 . }
123-68 .
123-69 .
123-70 . if (A == B)
123-71 . {
123-72 . A = B + C;
123-73 . D = E + F;
123-74 . }
123-75 .
123-76 .
123-77 . if (A < = B)
123-78 . {
123-79 . A = B + C;
123-80 . D = E + F;
123-81 . }
123-82 .
123-83 . A = 0x0002;
123-84 . A = B-C;
123-85 .
123-86 . if (A != B)
123-87 . {
123-88 . A = B + C;
123-89 . D = E + F;
123-90 . }
123-91 .
123-92 .
123-93 . if (A le B)
123-94 . {
123-95 . A = B + C;
123-96 . D = E + F;
123-97 . }
123-98 .
123-99 . /* LE SV TOC-3073 this is a wxp-06.1.15 req to reject*/
123-100 . A = B/C;
123-101 .
123-102 . if (A gt B)
123-103 . {
123-104 . A = B + C;
123-105 . D = E + F;
123-106 . }
123-107 .
123-108 .
123-109 . if (A > B)
123-110 . {
123-111 . A = B + C;
123-112 . D = E + F;
123-113 . }
123-114 .
123-115 . A = B+C;
123-116 . A = B+C;
123-117 . A = B*C;
123-118 . /* LE SV TOC-3074 this is a wxp-06.1.21 req to verify*/
123-119 .
123-120 . if (A < = B)
123-121 . {
123-122 . A = B + C;
123-123 . D = E + F;
123-124 . }
123-125 .
123-126 . A = B-C;
123-127 . A = B+C;
123-128 . A = B*C;
123-129 . A = B+C;
123-130 .
123-131 . if (A lt B)
123-132 . {
123-133 . A = B + C;
123-134 . D = E + F;
123-135 . }
123-136 .
123-137 . A = B/C;
123-138 . A = B*C;
123-139 . A = B-C;
123-140 .
123-141 . if (A le B)
123-142 . {
123-143 . A = B + C;
123-144 . D = E + F;
123-145 . }
123-146 .
123-147 . // max LOC 30
123-148 .
123-149 . }
123-150 .
123 123 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-06.c
124 124 Source: source/ft-app/ft-app-B1.0/wxp/wxp-07.c
124-0 .
124-1 .
124-2 . float B;
124-3 . #define B;
124-4 . #include B;
124-5 .
124-6 .
124-7 .
124-8 . /*
124-9 . -----------------------------------------------------------------------------
124-10 . --| NAME: wxp.7.1
124-11 . --|
124-12 . --| ABSTRACT:
124-13 . --| This function does wxp stuff.
124-14 . --|
124-15 . --| RETURNS:
124-16 . --| NONE.
124-17 . --|
124-18 . ----------------------------------------------------------------------------
124-19 . */
124-20 . static void wxp.7.1(void)
124-21 . {
124-22 . A = B-C;
124-23 .
124-24 . if (A != B)
124-25 . {
124-26 . A = B + C;
124-27 . D = E + F;
124-28 . }
124-29 .
124-30 . A = 0x0006;
124-31 . A = B*C;
124-32 . /* LE SV TOC-3075 this is a wxp-07.1.4 req to translate*/
124-33 . A = B+C;
124-34 . A = B+C;
124-35 .
124-36 . switch (wxp stuff)
124-37 . {
124-38 . case one:
124-39 . {
124-40 . run_this;
124-41 . break;
124-42 . }
124-43 . case two:
124-44 . {
124-45 . run_this;
124-46 . break;
124-47 . }
124-48 . default:
124-49 . {
124-50 . SwError;
124-51 . }
124-52 . }
124-53 .
124-54 .
124-55 . switch (wxp stuff)
124-56 . {
124-57 . case one:
124-58 . {
124-59 . run_this;
124-60 . break;
124-61 . }
124-62 . case two:
124-63 . {
124-64 . run_this;
124-65 . break;
124-66 . }
124-67 . default:
124-68 . {
124-69 . SwError;
124-70 . }
124-71 . }
124-72 .
124-73 . A = B+C;
124-74 . A = B/C;
124-75 . /* LE SV TOC-3076 this is a wxp-07.1.10 req to detect error*/
124-76 . A = B*C;
124-77 .
124-78 . if (A lt B)
124-79 . {
124-80 . A = B + C;
124-81 . D = E + F;
124-82 . }
124-83 .
124-84 . A = B/C;
124-85 . A = B*C;
124-86 . A = B/C;
124-87 .
124-88 . switch (wxp stuff)
124-89 . {
124-90 . case one:
124-91 . {
124-92 . run_this;
124-93 . break;
124-94 . }
124-95 . case two:
124-96 . {
124-97 . run_this;
124-98 . break;
124-99 . }
124-100 . default:
124-101 . {
124-102 . SwError;
124-103 . }
124-104 . }
124-105 .
124-106 . A = B*C;
124-107 . A = B-C;
124-108 .
124-109 . if (A ne B)
124-110 . {
124-111 . A = B + C;
124-112 . D = E + F;
124-113 . }
124-114 .
124-115 . A = B-C;
124-116 .
124-117 . if (A > B)
124-118 . {
124-119 . A = B + C;
124-120 . D = E + F;
124-121 . }
124-122 .
124-123 .
124-124 . if (A ne B)
124-125 . {
124-126 . A = B + C;
124-127 . D = E + F;
124-128 . }
124-129 .
124-130 .
124-131 . if (A > B)
124-132 . {
124-133 . A = B + C;
124-134 . D = E + F;
124-135 . }
124-136 .
124-137 . A = B+C;
124-138 .
124-139 . switch (wxp stuff)
124-140 . {
124-141 . case one:
124-142 . {
124-143 . run_this;
124-144 . break;
124-145 . }
124-146 . case two:
124-147 . {
124-148 . run_this;
124-149 . break;
124-150 . }
124-151 . default:
124-152 . {
124-153 . SwError;
124-154 . }
124-155 . }
124-156 .
124-157 . rcv_buffer = (U16 *) alloc(size+1);
124-158 . A = B+C;
124-159 . A = B+C;
124-160 . A = B/C;
124-161 . A = B/C;
124-162 . A = B*C;
124-163 . A = B*C;
124-164 .
124-165 . if (A > B)
124-166 . {
124-167 . A = B + C;
124-168 . D = E + F;
124-169 . }
124-170 .
124-171 .
124-172 . switch (wxp stuff)
124-173 . {
124-174 . case one:
124-175 . {
124-176 . run_this;
124-177 . break;
124-178 . }
124-179 . case two:
124-180 . {
124-181 . run_this;
124-182 . break;
124-183 . }
124-184 . default:
124-185 . {
124-186 . SwError;
124-187 . }
124-188 . }
124-189 .
124-190 . A = B-C;
124-191 . A = B*C;
124-192 . A = B/C;
124-193 . /* LE SV TOC-3077 this is a wxp-07.1.36 req to increment*/
124-194 . A = B-C;
124-195 . A = B-C;
124-196 . A = B+C;
124-197 . A = B-C;
124-198 . A = B*C;
124-199 . /* LE SV TOC-3078 this is a wxp-07.1.41 req to halt*/
124-200 . A = B-C;
124-201 . A = B*C;
124-202 . A = B/C;
124-203 . A = B-C;
124-204 . A = B/C;
124-205 . A = B-C;
124-206 . A = B/C;
124-207 . A = B/C;
124-208 . A = B+C;
124-209 . A = B/C;
124-210 .
124-211 . if (A > B)
124-212 . {
124-213 . A = B + C;
124-214 . D = E + F;
124-215 . }
124-216 .
124-217 . A = B-C;
124-218 . A = B-C;
124-219 . A = B-C;
124-220 .
124-221 . if (A ge B)
124-222 . {
124-223 . A = B + C;
124-224 . D = E + F;
124-225 . }
124-226 .
124-227 .
124-228 . if (A ge B)
124-229 . {
124-230 . A = B + C;
124-231 . D = E + F;
124-232 . }
124-233 .
124-234 . A = B/C;
124-235 . A = B*C;
124-236 .
124-237 . if (A le B)
124-238 . {
124-239 . A = B + C;
124-240 . D = E + F;
124-241 . }
124-242 .
124-243 . A = B/C;
124-244 . /* LE SV TOC-3079 this is a wxp-07.1.61 req to halt*/
124-245 .
124-246 . if (A > B)
124-247 . {
124-248 . A = B + C;
124-249 . D = E + F;
124-250 . }
124-251 .
124-252 .
124-253 . if (A lt B)
124-254 . {
124-255 . A = B + C;
124-256 . D = E + F;
124-257 . }
124-258 .
124-259 . A = B/C;
124-260 . A = B-C;
124-261 . A = B*C;
124-262 .
124-263 . if (A < = B)
124-264 . {
124-265 . A = B + C;
124-266 . D = E + F;
124-267 . }
124-268 .
124-269 . A = B-C;
124-270 .
124-271 . if (A != B)
124-272 . {
124-273 . A = B + C;
124-274 . D = E + F;
124-275 . }
124-276 .
124-277 . A = B+C;
124-278 . A = B*C;
124-279 . A = B/C;
124-280 .
124-281 . if (A gt B)
124-282 . {
124-283 . A = B + C;
124-284 . D = E + F;
124-285 . }
124-286 .
124-287 . A = B/C;
124-288 . /* LE SV TOC-3080 this is a wxp-07.1.74 req to increment*/
124-289 .
124-290 . if (A < B)
124-291 . {
124-292 . A = B + C;
124-293 . D = E + F;
124-294 . }
124-295 .
124-296 . A = B+C;
124-297 . A = B/C;
124-298 . // max LOC 76
124-299 .
124-300 . }
124-301 .
124-302 .
124-303 . /*
124-304 . -----------------------------------------------------------------------------
124-305 . --| NAME: wxp.7.2
124-306 . --|
124-307 . --| ABSTRACT:
124-308 . --| This function does wxp stuff.
124-309 . --|
124-310 . --| RETURNS:
124-311 . --| NONE.
124-312 . --|
124-313 . ----------------------------------------------------------------------------
124-314 . */
124-315 . static void wxp.7.2(void)
124-316 . {
124-317 . A = B+C;
124-318 .
124-319 . if (A < = B)
124-320 . {
124-321 . A = B + C;
124-322 . D = E + F;
124-323 . }
124-324 .
124-325 . A = B-C;
124-326 . A = B-C;
124-327 . A = B+C;
124-328 .
124-329 . if (A == B)
124-330 . {
124-331 . A = B + C;
124-332 . D = E + F;
124-333 . }
124-334 .
124-335 .
124-336 . if (A ne B)
124-337 . {
124-338 . A = B + C;
124-339 . D = E + F;
124-340 . }
124-341 .
124-342 . A = B*C;
124-343 . A = B/C;
124-344 .
124-345 . if (A eq B)
124-346 . {
124-347 . A = B + C;
124-348 . D = E + F;
124-349 . }
124-350 .
124-351 .
124-352 . if (A ne B)
124-353 . {
124-354 . A = B + C;
124-355 . D = E + F;
124-356 . }
124-357 .
124-358 . A = B*C;
124-359 . A = B/C;
124-360 . A = B-C;
124-361 .
124-362 . if (A ne B)
124-363 . {
124-364 . A = B + C;
124-365 . D = E + F;
124-366 . }
124-367 .
124-368 . /* LE SV TOC-3081 this is a wxp-07.2.16 req to transform*/
124-369 . A = B+C;
124-370 . A = B/C;
124-371 . A = B-C;
124-372 .
124-373 . if (A != B)
124-374 . {
124-375 . A = B + C;
124-376 . D = E + F;
124-377 . }
124-378 .
124-379 . A = 0x0004;
124-380 .
124-381 . switch (wxp stuff)
124-382 . {
124-383 . case one:
124-384 . {
124-385 . run_this;
124-386 . break;
124-387 . }
124-388 . case two:
124-389 . {
124-390 . run_this;
124-391 . break;
124-392 . }
124-393 . default:
124-394 . {
124-395 . SwError;
124-396 . }
124-397 . }
124-398 .
124-399 . A = B-C;
124-400 . A = B*C;
124-401 . A = B-C;
124-402 .
124-403 . if (A < B)
124-404 . {
124-405 . A = B + C;
124-406 . D = E + F;
124-407 . }
124-408 .
124-409 .
124-410 . if (A > = B)
124-411 . {
124-412 . A = B + C;
124-413 . D = E + F;
124-414 . }
124-415 .
124-416 .
124-417 . if (A > = B)
124-418 . {
124-419 . A = B + C;
124-420 . D = E + F;
124-421 . }
124-422 .
124-423 . A = B/C;
124-424 .
124-425 . if (A < B)
124-426 . {
124-427 . A = B + C;
124-428 . D = E + F;
124-429 . }
124-430 .
124-431 . /* LE SV TOC-3082 this is a wxp-07.2.29 req to translate*/
124-432 .
124-433 . if (A gt B)
124-434 . {
124-435 . A = B + C;
124-436 . D = E + F;
124-437 . }
124-438 .
124-439 .
124-440 . if (A ne B)
124-441 . {
124-442 . A = B + C;
124-443 . D = E + F;
124-444 . }
124-445 .
124-446 . A = B-C;
124-447 . A = B-C;
124-448 . A = B*C;
124-449 . FreePtr = HmiStringPtr;
124-450 .
124-451 . if (A > = B)
124-452 . {
124-453 . A = B + C;
124-454 . D = E + F;
124-455 . }
124-456 .
124-457 . A = B+C;
124-458 . A = B-C;
124-459 . A = B-C;
124-460 . /* LE SV TOC-3083 this is a wxp-07.2.38 req to set RTC*/
124-461 . A = B-C;
124-462 . A = B-C;
124-463 . A = B-C;
124-464 . A = B+C;
124-465 .
124-466 . if (A gt B)
124-467 . {
124-468 . A = B + C;
124-469 . D = E + F;
124-470 . }
124-471 .
124-472 . A = B+C;
124-473 .
124-474 . if (A > B)
124-475 . {
124-476 . A = B + C;
124-477 . D = E + F;
124-478 . }
124-479 .
124-480 .
124-481 . if (A gt B)
124-482 . {
124-483 . A = B + C;
124-484 . D = E + F;
124-485 . }
124-486 .
124-487 .
124-488 . if (A != B)
124-489 . {
124-490 . A = B + C;
124-491 . D = E + F;
124-492 . }
124-493 .
124-494 . A = B+C;
124-495 . A = B-C;
124-496 . A = B-C;
124-497 . A = B-C;
124-498 .
124-499 . if (A == B)
124-500 . {
124-501 . A = B + C;
124-502 . D = E + F;
124-503 . }
124-504 .
124-505 . // max LOC 51
124-506 .
124-507 . }
124-508 .
124-509 .
124-510 . /*
124-511 . -----------------------------------------------------------------------------
124-512 . --| NAME: wxp.7.3
124-513 . --|
124-514 . --| ABSTRACT:
124-515 . --| This function does wxp stuff.
124-516 . --|
124-517 . --| RETURNS:
124-518 . --| NONE.
124-519 . --|
124-520 . ----------------------------------------------------------------------------
124-521 . */
124-522 . static void wxp.7.3(void)
124-523 . {
124-524 . A = B+C;
124-525 . A = B/C;
124-526 . A = B*C;
124-527 . A = B+C;
124-528 . A = B+C;
124-529 .
124-530 . if (A == B)
124-531 . {
124-532 . A = B + C;
124-533 . D = E + F;
124-534 . }
124-535 .
124-536 . A = B*C;
124-537 . /* LE SV TOC-3084 this is a wxp-07.3.8 req to call admin*/
124-538 .
124-539 . if (A ge B)
124-540 . {
124-541 . A = B + C;
124-542 . D = E + F;
124-543 . }
124-544 .
124-545 . send_buffer = (U16 *) malloc(size+1);
124-546 . A = B+C;
124-547 . A = B*C;
124-548 . A = B+C;
124-549 . A = B/C;
124-550 . A = B*C;
124-551 . A = B-C;
124-552 . A = B/C;
124-553 . A = B-C;
124-554 . A = B/C;
124-555 . A = B+C;
124-556 . A = B+C;
124-557 . A = B+C;
124-558 . /* LE SV TOC-3085 this is a wxp-07.3.21 req to transform*/
124-559 .
124-560 . if (A eq B)
124-561 . {
124-562 . A = B + C;
124-563 . D = E + F;
124-564 . }
124-565 .
124-566 . A = 0x0006;
124-567 .
124-568 . if (A lt B)
124-569 . {
124-570 . A = B + C;
124-571 . D = E + F;
124-572 . }
124-573 .
124-574 . A = B*C;
124-575 .
124-576 . if (A ne B)
124-577 . {
124-578 . A = B + C;
124-579 . D = E + F;
124-580 . }
124-581 .
124-582 . A = B-C;
124-583 .
124-584 . /* dead_block = C * D;
124-585 . dead_block = E * F; */
124-586 .
124-587 . A = B-C;
124-588 .
124-589 . if (A le B)
124-590 . {
124-591 . A = B + C;
124-592 . D = E + F;
124-593 . }
124-594 .
124-595 . A = B/C;
124-596 . A = B-C;
124-597 . A = B/C;
124-598 . A = B+C;
124-599 .
124-600 . if (A > = B)
124-601 . {
124-602 . A = B + C;
124-603 . D = E + F;
124-604 . }
124-605 .
124-606 . // max LOC 32
124-607 .
124-608 . }
124-609 .
124-610 .
124-611 . /*
124-612 . -----------------------------------------------------------------------------
124-613 . --| NAME: wxp.7.4
124-614 . --|
124-615 . --| ABSTRACT:
124-616 . --| This function does wxp stuff.
124-617 . --|
124-618 . --| RETURNS:
124-619 . --| NONE.
124-620 . --|
124-621 . ----------------------------------------------------------------------------
124-622 . */
124-623 . static void wxp.7.4(void)
124-624 . {
124-625 . A = B*C;
124-626 . A = B/C;
124-627 . A = B/C;
124-628 . A = B*C;
124-629 . /* LE SV TOC-3086 this is a wxp-07.4.5 req to detect error*/
124-630 . A = B*C;
124-631 .
124-632 . switch (wxp stuff)
124-633 . {
124-634 . case one:
124-635 . {
124-636 . run_this;
124-637 . break;
124-638 . }
124-639 . case two:
124-640 . {
124-641 . run_this;
124-642 . break;
124-643 . }
124-644 . // missing default
124-645 . }
124-646 .
124-647 .
124-648 . switch (wxp stuff)
124-649 . {
124-650 . case one:
124-651 . {
124-652 . run_this;
124-653 . break;
124-654 . }
124-655 . case two:
124-656 . {
124-657 . run_this;
124-658 . break;
124-659 . }
124-660 . default:
124-661 . {
124-662 . SwError;
124-663 . }
124-664 . }
124-665 .
124-666 . A = B+C;
124-667 . A = B*C;
124-668 . A = B*C;
124-669 . A = B*C;
124-670 .
124-671 . if (A le B)
124-672 . {
124-673 . A = B + C;
124-674 . D = E + F;
124-675 . }
124-676 .
124-677 . A = B*C;
124-678 .
124-679 . if (A lt B)
124-680 . {
124-681 . A = B + C;
124-682 . D = E + F;
124-683 . }
124-684 .
124-685 . A = B+C;
124-686 . A = B-C;
124-687 . A = B-C;
124-688 . A = B*C;
124-689 . A = B/C;
124-690 . A = B-C;
124-691 . A = B/C;
124-692 . A = B-C;
124-693 . A = B-C;
124-694 . A = B+C;
124-695 . A = B/C;
124-696 .
124-697 . if (A < B)
124-698 . {
124-699 . A = B + C;
124-700 . D = E + F;
124-701 . }
124-702 .
124-703 .
124-704 . if (A le B)
124-705 . {
124-706 . A = B + C;
124-707 . D = E + F;
124-708 . }
124-709 .
124-710 . A = B-C;
124-711 .
124-712 . if (A lt B)
124-713 . {
124-714 . A = B + C;
124-715 . D = E + F;
124-716 . }
124-717 .
124-718 . A = B-C;
124-719 . A = B+C;
124-720 .
124-721 . if (A ne B)
124-722 . {
124-723 . A = B + C;
124-724 . D = E + F;
124-725 . }
124-726 .
124-727 .
124-728 . if (A != B)
124-729 . {
124-730 . A = B + C;
124-731 . D = E + F;
124-732 . }
124-733 .
124-734 . A = B+C;
124-735 . A = B/C;
124-736 . /* LE SV TOC-3087 this is a wxp-07.4.35 req to process*/
124-737 . A = B-C;
124-738 .
124-739 . if (A le B)
124-740 . {
124-741 . A = B + C;
124-742 . D = E + F;
124-743 . }
124-744 .
124-745 . A = B-C;
124-746 . A = B/C;
124-747 . A = B*C;
124-748 . A = B*C;
124-749 . // TBD - what do I do now
124-750 . A = B*C;
124-751 .
124-752 . if (A > = B)
124-753 . {
124-754 . A = B + C;
124-755 . D = E + F;
124-756 . }
124-757 .
124-758 . // max LOC 42
124-759 .
124-760 . }
124-761 .
124 124 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-07.c
125 125 Source: source/ft-app/ft-app-B1.0/wxp/wxp-08.c
125-0 . /*
125-1 . ----------------------------------------------------------------------------
125-2 . --| BEGIN PROLOGUE
125-3 . --|
125-4 . --| CLASSIFICATION: UNCLASSIFIED
125-5 . --|
125-6 . --| FILE NAME: wxp-08.c
125-7 . --|
125-8 . --| ABSTRACT:
125-9 . --| This file contains the 4 functions that do file wxp stuff.
125-10 . --|
125-11 . --| HISTORY:
125-12 . --| CCCQ_NAME:
125-13 . --| CCCQ_VER:
125-14 . --|
125-15 . --| END PROLOGUE
125-16 . ----------------------------------------------------------------------------
125-17 . */
125-18 .
125-19 . #include C;
125-20 . #include B;
125-21 . #define D;
125-22 .
125-23 .
125-24 .
125-25 . /*
125-26 . -----------------------------------------------------------------------------
125-27 . --| NAME: wxp.8.1
125-28 . --|
125-29 . --| ABSTRACT:
125-30 . --| This function does wxp stuff.
125-31 . --|
125-32 . --| RETURNS:
125-33 . --| NONE.
125-34 . --|
125-35 . ----------------------------------------------------------------------------
125-36 . */
125-37 . static void wxp.8.1(void)
125-38 . {
125-39 . A = B-C;
125-40 . A = B/C;
125-41 . A = B*C;
125-42 . A = B/C;
125-43 . /* LE SV TOC-3088 this is a wxp-08.1.5 req to set RTC*/
125-44 .
125-45 . if (A == B)
125-46 . {
125-47 . A = B + C;
125-48 . D = E + F;
125-49 . }
125-50 .
125-51 . A = B+C;
125-52 . // max LOC 6
125-53 .
125-54 . }
125-55 .
125-56 .
125-57 . /*
125-58 . -----------------------------------------------------------------------------
125-59 . --| NAME: wxp.8.2
125-60 . --|
125-61 . --| ABSTRACT:
125-62 . --| This function does wxp stuff.
125-63 . --|
125-64 . --| RETURNS:
125-65 . --| NONE.
125-66 . --|
125-67 . ----------------------------------------------------------------------------
125-68 . */
125-69 . static void wxp.8.2(void)
125-70 . {
125-71 . A = B+C;
125-72 . A = B*C;
125-73 . A = B*C;
125-74 . A = B+C;
125-75 . A = B*C;
125-76 . A = B*C;
125-77 . A = B+C;
125-78 .
125-79 . if (A ge B)
125-80 . {
125-81 . A = B + C;
125-82 . D = E + F;
125-83 . }
125-84 .
125-85 .
125-86 . if (A ge B)
125-87 . {
125-88 . A = B + C;
125-89 . D = E + F;
125-90 . }
125-91 .
125-92 . A = B*C;
125-93 . A = B+C;
125-94 .
125-95 . if (A < B)
125-96 . {
125-97 . A = B + C;
125-98 . D = E + F;
125-99 . }
125-100 .
125-101 . A = B/C;
125-102 . A = B+C;
125-103 . A = B-C;
125-104 . // max LOC 15
125-105 .
125-106 . }
125-107 .
125-108 .
125-109 . /*
125-110 . -----------------------------------------------------------------------------
125-111 . --| NAME: wxp.8.3
125-112 . --|
125-113 . --| ABSTRACT:
125-114 . --| This function does wxp stuff.
125-115 . --|
125-116 . --| RETURNS:
125-117 . --| NONE.
125-118 . --|
125-119 . ----------------------------------------------------------------------------
125-120 . */
125-121 . static void wxp.8.3(void)
125-122 . {
125-123 . A = B*C;
125-124 .
125-125 . if (A == B)
125-126 . {
125-127 . A = B + C;
125-128 . D = E + F;
125-129 . }
125-130 .
125-131 . A = B/C;
125-132 . A = B-C;
125-133 . A = B+C;
125-134 . A = B+C;
125-135 . A = B*C;
125-136 . A = B-C;
125-137 . A = B/C;
125-138 . A = B/C;
125-139 .
125-140 . if (A < B)
125-141 . {
125-142 . A = B + C;
125-143 . D = E + F;
125-144 . }
125-145 .
125-146 . A = B/C;
125-147 . A = B-C;
125-148 . A = B/C;
125-149 . A = B-C;
125-150 .
125-151 . if (A eq B)
125-152 . {
125-153 . A = B + C;
125-154 . D = E + F;
125-155 . }
125-156 .
125-157 . A = B-C;
125-158 . A = B+C;
125-159 . A = B+C;
125-160 . A = B+C;
125-161 .
125-162 . if (A < B)
125-163 . {
125-164 . A = B + C;
125-165 . D = E + F;
125-166 . }
125-167 .
125-168 . A = B-C;
125-169 . A = B/C;
125-170 . A = B/C;
125-171 .
125-172 . switch (wxp stuff)
125-173 . {
125-174 . case one:
125-175 . {
125-176 . run_this;
125-177 . break;
125-178 . }
125-179 . case two:
125-180 . {
125-181 . run_this;
125-182 . break;
125-183 . }
125-184 . default:
125-185 . {
125-186 . SwError;
125-187 . }
125-188 . }
125-189 .
125-190 .
125-191 . if (A ge B)
125-192 . {
125-193 . A = B + C;
125-194 . D = E + F;
125-195 . }
125-196 .
125-197 . A = B/C;
125-198 . /* LE SV TOC-3089 this is a wxp-08.3.28 req to halt*/
125-199 . A = B*C;
125-200 . A = B+C;
125-201 .
125-202 . if (A > B)
125-203 . {
125-204 . A = B + C;
125-205 . D = E + F;
125-206 . }
125-207 .
125-208 . A = B*C;
125-209 . A = B/C;
125-210 . A = B-C;
125-211 . // max LOC 33
125-212 .
125-213 . }
125-214 .
125-215 .
125-216 . /*
125-217 . -----------------------------------------------------------------------------
125-218 . --| NAME: wxp.8.4
125-219 . --|
125-220 . --| ABSTRACT:
125-221 . --| This function does wxp stuff.
125-222 . --|
125-223 . --| RETURNS:
125-224 . --| NONE.
125-225 . --|
125-226 . ----------------------------------------------------------------------------
125-227 . */
125-228 . static void wxp.8.4(void)
125-229 . {
125-230 . A = B+C;
125-231 .
125-232 . if (A gt B)
125-233 . {
125-234 . A = B + C;
125-235 . D = E + F;
125-236 . }
125-237 .
125-238 .
125-239 . if (A eq B)
125-240 . {
125-241 . A = B + C;
125-242 . D = E + F;
125-243 . }
125-244 .
125-245 .
125-246 . if (A < B)
125-247 . {
125-248 . A = B + C;
125-249 . D = E + F;
125-250 . }
125-251 .
125-252 . A = B/C;
125-253 . A = B-C;
125-254 . A = B/C;
125-255 . A = B+C;
125-256 . A = B/C;
125-257 . A = B/C;
125-258 .
125-259 . if (A ge B)
125-260 . {
125-261 . A = B + C;
125-262 . D = E + F;
125-263 . }
125-264 .
125-265 . A = B*C;
125-266 .
125-267 . if (A le B)
125-268 . {
125-269 . A = B + C;
125-270 . D = E + F;
125-271 . }
125-272 .
125-273 . A = B-C;
125-274 . /* LE SV TOC-3090 this is a wxp-08.4.15 req to assign*/
125-275 .
125-276 . if (A == B)
125-277 . {
125-278 . A = B + C;
125-279 . D = E + F;
125-280 . }
125-281 .
125-282 . A = B*C;
125-283 . A = B+C;
125-284 .
125-285 . if (A ge B)
125-286 . {
125-287 . A = B + C;
125-288 . D = E + F;
125-289 . }
125-290 .
125-291 . A = B/C;
125-292 . A = B/C;
125-293 . A = B/C;
125-294 . A = B+C;
125-295 . A = B*C;
125-296 .
125-297 . switch (wxp stuff)
125-298 . {
125-299 . case one:
125-300 . {
125-301 . switch (nested)
125-302 . {
125-303 . case:
125-304 . X = Y + Z;
125-305 . case:
125-306 . X = Y + Z;
125-307 . default:
125-308 . SwError;
125-309 . }
125-310 . }
125-311 . case two:
125-312 . {
125-313 . run_this;
125-314 . break;
125-315 . }
125-316 . default:
125-317 . {
125-318 . SwError;
125-319 . }
125-320 . }
125-321 .
125-322 .
125-323 . if (A lt B)
125-324 . {
125-325 . A = B + C;
125-326 . D = E + F;
125-327 . }
125-328 .
125-329 . A = B*C;
125-330 . A = B*C;
125-331 .
125-332 . if (A > B)
125-333 . {
125-334 . A = B + C;
125-335 . D = E + F;
125-336 . }
125-337 .
125-338 . A = B*C;
125-339 . A = B+C;
125-340 . A = B*C;
125-341 . A = B-C;
125-342 . A = B*C;
125-343 . A = B+C;
125-344 . A = B-C;
125-345 . A = B/C;
125-346 . // max LOC 35
125-347 .
125-348 . }
125-349 .
125 125 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-08.c
126 126 Source: source/ft-app/ft-app-B1.0/wxp/wxp-09.c
126-0 . /*
126-1 . ----------------------------------------------------------------------------
126-2 . --| BEGIN PROLOGUE
126-3 . --|
126-4 . --| CLASSIFICATION: UNCLASSIFIED
126-5 . --|
126-6 . --| FILE NAME: wxp-09.c
126-7 . --|
126-8 . --| ABSTRACT:
126-9 . --| This file contains the 2 functions that do file wxp stuff.
126-10 . --|
126-11 . --| HISTORY:
126-12 . --| CCCQ_NAME:
126-13 . --| CCCQ_VER:
126-14 . --|
126-15 . --| END PROLOGUE
126-16 . ----------------------------------------------------------------------------
126-17 . */
126-18 .
126-19 . double C;
126-20 . float B;
126-21 . #include B;
126-22 . #define A;
126-23 .
126-24 .
126-25 .
126-26 . /*
126-27 . -----------------------------------------------------------------------------
126-28 . --| NAME: wxp.9.1
126-29 . --|
126-30 . --| ABSTRACT:
126-31 . --| This function does wxp stuff.
126-32 . --|
126-33 . --| RETURNS:
126-34 . --| NONE.
126-35 . --|
126-36 . ----------------------------------------------------------------------------
126-37 . */
126-38 . static void wxp.9.1(void)
126-39 . {
126-40 .
126-41 . if (A lt B)
126-42 . {
126-43 . A = B + C;
126-44 . D = E + F;
126-45 . }
126-46 .
126-47 .
126-48 . if (A == B)
126-49 . {
126-50 . A = B + C;
126-51 . D = E + F;
126-52 . }
126-53 .
126-54 . A = B/C;
126-55 .
126-56 . if (A eq B)
126-57 . {
126-58 . A = B + C;
126-59 . D = E + F;
126-60 . }
126-61 .
126-62 .
126-63 . /*
126-64 . dead_code = B - C;
126-65 . dead_code = D - E;
126-66 . dead_code = F - G;
126-67 . */
126-68 .
126-69 . A = B*C;
126-70 . A = B*C;
126-71 . do forever;
126-72 . A = B-C;
126-73 .
126-74 . if (A < = B)
126-75 . {
126-76 . A = B + C;
126-77 . D = E + F;
126-78 . }
126-79 .
126-80 . A = B-C;
126-81 . A = B-C;
126-82 . A = B-C;
126-83 .
126-84 . if (A != B)
126-85 . {
126-86 . A = B + C;
126-87 . D = E + F;
126-88 . }
126-89 .
126-90 . A = B-C;
126-91 . A = B+C;
126-92 .
126-93 . /*
126-94 . dead_block = C * D;
126-95 . dead_block = E * F;
126-96 . */
126-97 .
126-98 .
126-99 . if (A le B)
126-100 . {
126-101 . A = B + C;
126-102 . D = E + F;
126-103 . }
126-104 .
126-105 . A = B+C;
126-106 . A = B/C;
126-107 . A = B/C;
126-108 . A = B+C;
126-109 . A = B/C;
126-110 .
126-111 . switch (wxp stuff)
126-112 . {
126-113 . case one:
126-114 . {
126-115 . switch (nested)
126-116 . {
126-117 . case:
126-118 . X = Y + Z;
126-119 . case:
126-120 . X = Y + Z;
126-121 . default:
126-122 . SwError;
126-123 . }
126-124 . }
126-125 . case two:
126-126 . {
126-127 . run_this;
126-128 . break;
126-129 . }
126-130 . default:
126-131 . {
126-132 . SwError;
126-133 . }
126-134 . }
126-135 .
126-136 .
126-137 . if (A lt B)
126-138 . {
126-139 . A = B + C;
126-140 . D = E + F;
126-141 . }
126-142 .
126-143 . A = B/C;
126-144 . A = 0x0009;
126-145 . A = B+C;
126-146 . A = B+C;
126-147 . A = B/C;
126-148 . do forever;
126-149 .
126-150 . switch (wxp stuff)
126-151 . {
126-152 . case one:
126-153 . {
126-154 . run_this;
126-155 . break;
126-156 . }
126-157 . case two:
126-158 . {
126-159 . run_this;
126-160 . break;
126-161 . }
126-162 . default:
126-163 . {
126-164 . SwError;
126-165 . }
126-166 . }
126-167 .
126-168 . A = B-C;
126-169 . // max LOC 27
126-170 .
126-171 . }
126-172 .
126-173 .
126-174 . /*
126-175 . -----------------------------------------------------------------------------
126-176 . --| NAME: wxp.9.2
126-177 . --|
126-178 . --| ABSTRACT:
126-179 . --| This function does wxp stuff.
126-180 . --|
126-181 . --| RETURNS:
126-182 . --| NONE.
126-183 . --|
126-184 . ----------------------------------------------------------------------------
126-185 . */
126-186 . static void wxp.9.2(void)
126-187 . {
126-188 . A = B-C;
126-189 . A = B-C;
126-190 . A = B+C;
126-191 . A = B*C;
126-192 . A = B*C;
126-193 . A = B/C;
126-194 . A = B/C;
126-195 . A = B*C;
126-196 .
126-197 . if (A == B)
126-198 . {
126-199 . A = B + C;
126-200 . D = E + F;
126-201 . }
126-202 .
126-203 .
126-204 . if (A == B)
126-205 . {
126-206 . A = B + C;
126-207 . D = E + F;
126-208 . }
126-209 .
126-210 . A = B/C;
126-211 . A = B-C;
126-212 .
126-213 . switch (wxp stuff)
126-214 . {
126-215 . case one:
126-216 . {
126-217 . run_this;
126-218 . break;
126-219 . }
126-220 . case two:
126-221 . {
126-222 . run_this;
126-223 . break;
126-224 . }
126-225 . default:
126-226 . {
126-227 . SwError;
126-228 . }
126-229 . }
126-230 .
126-231 . A = B*C;
126-232 . A = B-C;
126-233 . A = B*C;
126-234 . A = B*C;
126-235 . A = B-C;
126-236 . A = B+C;
126-237 . A = B*C;
126-238 .
126-239 . if (A eq B)
126-240 . {
126-241 . A = B + C;
126-242 . D = E + F;
126-243 . }
126-244 .
126-245 .
126-246 . if (A gt B)
126-247 . {
126-248 . A = B + C;
126-249 . D = E + F;
126-250 . }
126-251 .
126-252 . A = B+C;
126-253 .
126-254 . if (A > = B)
126-255 . {
126-256 . A = B + C;
126-257 . D = E + F;
126-258 . }
126-259 .
126-260 .
126-261 . if (A > = B)
126-262 . {
126-263 . A = B + C;
126-264 . D = E + F;
126-265 . }
126-266 .
126-267 .
126-268 . switch (wxp stuff)
126-269 . {
126-270 . case one:
126-271 . {
126-272 . run_this;
126-273 . break;
126-274 . }
126-275 . case two:
126-276 . {
126-277 . run_this;
126-278 . break;
126-279 . }
126-280 . default:
126-281 . {
126-282 . SwError;
126-283 . }
126-284 . }
126-285 .
126-286 . A = B-C;
126-287 .
126-288 . if (A lt B)
126-289 . {
126-290 . A = B + C;
126-291 . D = E + F;
126-292 . }
126-293 .
126-294 . /* LE SV TOC-3091 this is a wxp-09.2.29 req to check unix*/
126-295 . A = B-C;
126-296 . A = B+C;
126-297 .
126-298 . if (A != B)
126-299 . {
126-300 . A = B + C;
126-301 . D = E + F;
126-302 . }
126-303 .
126-304 . A = B-C;
126-305 . A = B/C;
126-306 .
126-307 . if (A gt B)
126-308 . {
126-309 . A = B + C;
126-310 . D = E + F;
126-311 . }
126-312 .
126-313 . A = B+C;
126-314 .
126-315 . if (A < = B)
126-316 . {
126-317 . A = B + C;
126-318 . D = E + F;
126-319 . }
126-320 .
126-321 . A = B+C;
126-322 . A = B+C;
126-323 . A = B+C;
126-324 . A = B*C;
126-325 . A = B*C;
126-326 . A = B/C;
126-327 .
126-328 . if (A ge B)
126-329 . {
126-330 . A = B + C;
126-331 . D = E + F;
126-332 . }
126-333 .
126-334 .
126-335 . if (A eq B)
126-336 . {
126-337 . A = B + C;
126-338 . D = E + F;
126-339 . }
126-340 .
126-341 . A = B+C;
126-342 . A = B+C;
126-343 .
126-344 . switch (wxp stuff)
126-345 . {
126-346 . case one:
126-347 . {
126-348 . run_this;
126-349 . break;
126-350 . }
126-351 . case two:
126-352 . {
126-353 . run_this;
126-354 . break;
126-355 . }
126-356 . default:
126-357 . {
126-358 . SwError;
126-359 . }
126-360 . }
126-361 .
126-362 . A = B-C;
126-363 . A = B/C;
126-364 . A = 0x0007;
126-365 .
126-366 . if (A ge B)
126-367 . {
126-368 . A = B + C;
126-369 . D = E + F;
126-370 . }
126-371 .
126-372 . A = B/C;
126-373 . A = B+C;
126-374 . FreePtr = HmiStringPtr;
126-375 .
126-376 . if (A eq B)
126-377 . {
126-378 . A = B + C;
126-379 . D = E + F;
126-380 . }
126-381 .
126-382 . A = B-C;
126-383 .
126-384 . if (A ne B)
126-385 . {
126-386 . A = B + C;
126-387 . D = E + F;
126-388 . }
126-389 .
126-390 . A = B/C;
126-391 . A = B+C;
126-392 .
126-393 . if (A gt B)
126-394 . {
126-395 . A = B + C;
126-396 . D = E + F;
126-397 . }
126-398 .
126-399 . A = B-C;
126-400 . A = B*C;
126-401 . A = B*C;
126-402 . A = B-C;
126-403 . A = B-C;
126-404 . A = B-C;
126-405 .
126-406 . /*
126-407 . dead_block = C * D;
126-408 . dead_block = E * F;
126-409 . */
126-410 .
126-411 . A = B/C;
126-412 . A = B+C;
126-413 . A = B/C;
126-414 . A = B*C;
126-415 . A = B*C;
126-416 . A = B*C;
126-417 .
126-418 . if (A < = B)
126-419 . {
126-420 . A = B + C;
126-421 . D = E + F;
126-422 . }
126-423 .
126-424 . A = B/C;
126-425 . // max LOC 72
126-426 .
126-427 . }
126-428 .
126 126 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-09.c
127 127 Source: source/ft-app/ft-app-B1.0/wxp/wxp-10.c
127-0 . /*
127-1 . ----------------------------------------------------------------------------
127-2 . --| BEGIN PROLOGUE
127-3 . --|
127-4 . --| CLASSIFICATION: UNCLASSIFIED
127-5 . --|
127-6 . --| FILE NAME: wxp-10.c
127-7 . --|
127-8 . --| ABSTRACT:
127-9 . --| This file contains the 4 functions that do file wxp stuff.
127-10 . --|
127-11 . --| HISTORY:
127-12 . --| CCCQ_NAME:
127-13 . --| CCCQ_VER:
127-14 . --|
127-15 . --| END PROLOGUE
127-16 . ----------------------------------------------------------------------------
127-17 . */
127-18 .
127-19 . #include A;
127-20 . #include D;
127-21 . char D;
127-22 . #include C;
127-23 . char D;
127-24 . #include C;
127-25 . char D;
127-26 . #include C;
127-27 .
127-28 .
127-29 .
127-30 . /*
127-31 . -----------------------------------------------------------------------------
127-32 . --| NAME: wxp.10.1
127-33 . --|
127-34 . --| ABSTRACT:
127-35 . --| This function does wxp stuff.
127-36 . --|
127-37 . --| RETURNS:
127-38 . --| NONE.
127-39 . --|
127-40 . ----------------------------------------------------------------------------
127-41 . */
127-42 . static void wxp.10.1(void)
127-43 . {
127-44 . A = B+C;
127-45 . A = B*C;
127-46 . A = B+C;
127-47 . A = B/C;
127-48 . A = B-C;
127-49 . FreePtr = HmiStringPtr;
127-50 .
127-51 . switch (wxp stuff)
127-52 . {
127-53 . case one:
127-54 . {
127-55 . run_this;
127-56 . break;
127-57 . }
127-58 . case two:
127-59 . {
127-60 . run_this;
127-61 . break;
127-62 . }
127-63 . default:
127-64 . {
127-65 . SwError;
127-66 . }
127-67 . }
127-68 .
127-69 . A = B-C;
127-70 .
127-71 . switch (wxp stuff)
127-72 . {
127-73 . case one:
127-74 . {
127-75 . run_this;
127-76 . break;
127-77 . }
127-78 . case two:
127-79 . {
127-80 . run_this;
127-81 . break;
127-82 . }
127-83 . default:
127-84 . {
127-85 . SwError;
127-86 . }
127-87 . }
127-88 .
127-89 . A = B/C;
127-90 . A = B*C;
127-91 . A = B+C;
127-92 .
127-93 . if (A != B)
127-94 . {
127-95 . A = B + C;
127-96 . D = E + F;
127-97 . }
127-98 .
127-99 . A = B+C;
127-100 .
127-101 . if (A < = B)
127-102 . {
127-103 . A = B + C;
127-104 . D = E + F;
127-105 . }
127-106 .
127-107 . A = B+C;
127-108 . // (P) this is really improtant
127-109 . A = B*C;
127-110 . A = 0x0004;
127-111 .
127-112 . if (A ge B)
127-113 . {
127-114 . A = B + C;
127-115 . D = E + F;
127-116 . }
127-117 .
127-118 .
127-119 . if (A > B)
127-120 . {
127-121 . A = B + C;
127-122 . D = E + F;
127-123 . }
127-124 .
127-125 . A = B-C;
127-126 . A = B/C;
127-127 . A = B*C;
127-128 . A = B/C;
127-129 .
127-130 . if (A < B)
127-131 . {
127-132 . A = B + C;
127-133 . D = E + F;
127-134 . }
127-135 .
127-136 .
127-137 . if (A == B)
127-138 . {
127-139 . A = B + C;
127-140 . D = E + F;
127-141 . }
127-142 .
127-143 . A = B+C;
127-144 . A = B+C;
127-145 . A = B*C;
127-146 . A = 0x0008;
127-147 .
127-148 . if (A le B)
127-149 . {
127-150 . A = B + C;
127-151 . D = E + F;
127-152 . }
127-153 .
127-154 .
127-155 . if (A gt B)
127-156 . {
127-157 . A = B + C;
127-158 . D = E + F;
127-159 . }
127-160 .
127-161 .
127-162 . if (A ge B)
127-163 . {
127-164 . A = B + C;
127-165 . D = E + F;
127-166 . }
127-167 .
127-168 .
127-169 . if (A le B)
127-170 . {
127-171 . A = B + C;
127-172 . D = E + F;
127-173 . }
127-174 .
127-175 .
127-176 . if (A le B)
127-177 . {
127-178 . A = B + C;
127-179 . D = E + F;
127-180 . }
127-181 .
127-182 .
127-183 . if (A gt B)
127-184 . {
127-185 . A = B + C;
127-186 . D = E + F;
127-187 . }
127-188 .
127-189 .
127-190 . if (A > = B)
127-191 . {
127-192 . A = B + C;
127-193 . D = E + F;
127-194 . }
127-195 .
127-196 . A = B/C;
127-197 . A = B+C;
127-198 . A = B*C;
127-199 . A = B*C;
127-200 . A = B/C;
127-201 . /* LE SV TOC-3092 this is a wxp-10.1.40 req to compare*/
127-202 . A = B*C;
127-203 . A = B*C;
127-204 . A = B-C;
127-205 . A = B+C;
127-206 .
127-207 . if (A lt B)
127-208 . {
127-209 . A = B + C;
127-210 . D = E + F;
127-211 . }
127-212 .
127-213 . A = B+C;
127-214 . A = B/C;
127-215 . A = B+C;
127-216 . A = B*C;
127-217 .
127-218 . if (A < = B)
127-219 . {
127-220 . A = B + C;
127-221 . D = E + F;
127-222 . }
127-223 .
127-224 .
127-225 . if (A ne B)
127-226 . {
127-227 . A = B + C;
127-228 . D = E + F;
127-229 . }
127-230 .
127-231 . A = B*C;
127-232 . A = B*C;
127-233 .
127-234 . if (A ne B)
127-235 . {
127-236 . A = B + C;
127-237 . D = E + F;
127-238 . }
127-239 .
127-240 . A = B+C;
127-241 . A = B-C;
127-242 . A = B-C;
127-243 . // max LOC 56
127-244 .
127-245 . }
127-246 .
127-247 .
127-248 . /*
127-249 . -----------------------------------------------------------------------------
127-250 . --| NAME: wxp.10.2
127-251 . --|
127-252 . --| ABSTRACT:
127-253 . --| This function does wxp stuff.
127-254 . --|
127-255 . --| RETURNS:
127-256 . --| NONE.
127-257 . --|
127-258 . ----------------------------------------------------------------------------
127-259 . */
127-260 . static void wxp.10.2(void)
127-261 . {
127-262 .
127-263 . if (A < B)
127-264 . {
127-265 . A = B + C;
127-266 . D = E + F;
127-267 . }
127-268 .
127-269 .
127-270 . if (A ne B)
127-271 . {
127-272 . A = B + C;
127-273 . D = E + F;
127-274 . }
127-275 .
127-276 . A = B/C;
127-277 .
127-278 . if (A eq B)
127-279 . {
127-280 . A = B + C;
127-281 . D = E + F;
127-282 . }
127-283 .
127-284 .
127-285 . if (A < = B)
127-286 . {
127-287 . A = B + C;
127-288 . D = E + F;
127-289 . }
127-290 .
127-291 .
127-292 . if (A lt B)
127-293 . {
127-294 . A = B + C;
127-295 . D = E + F;
127-296 . }
127-297 .
127-298 .
127-299 . if (A > = B)
127-300 . {
127-301 . A = B + C;
127-302 . D = E + F;
127-303 . }
127-304 .
127-305 . // max LOC 7
127-306 .
127-307 . }
127-308 .
127-309 .
127-310 . /*
127-311 . -----------------------------------------------------------------------------
127-312 . --| NAME: wxp.10.3
127-313 . --|
127-314 . --| ABSTRACT:
127-315 . --| This function does wxp stuff.
127-316 . --|
127-317 . --| RETURNS:
127-318 . --| NONE.
127-319 . --|
127-320 . ----------------------------------------------------------------------------
127-321 . */
127-322 . static void wxp.10.3(void)
127-323 . {
127-324 .
127-325 . if (A != B)
127-326 . {
127-327 . A = B + C;
127-328 . D = E + F;
127-329 . }
127-330 .
127-331 .
127-332 . if (A > = B)
127-333 . {
127-334 . A = B + C;
127-335 . D = E + F;
127-336 . }
127-337 .
127-338 . A = B+C;
127-339 . // max LOC 3
127-340 .
127-341 . }
127-342 .
127-343 .
127-344 . /*
127-345 . -----------------------------------------------------------------------------
127-346 . --| NAME: wxp.10.4
127-347 . --|
127-348 . --| ABSTRACT:
127-349 . --| This function does wxp stuff.
127-350 . --|
127-351 . --| RETURNS:
127-352 . --| NONE.
127-353 . --|
127-354 . ----------------------------------------------------------------------------
127-355 . */
127-356 . static void wxp.10.4(void)
127-357 . {
127-358 . /* LE SV TOC-3093 this is a wxp-10.4.1 req to check unix*/
127-359 . A = B-C;
127-360 .
127-361 . if (A > B)
127-362 . {
127-363 . A = B + C;
127-364 . D = E + F;
127-365 . }
127-366 .
127-367 .
127-368 . if (A == B)
127-369 . {
127-370 . A = B + C;
127-371 . D = E + F;
127-372 . }
127-373 .
127-374 . A = B/C;
127-375 .
127-376 . if (A > = B)
127-377 . {
127-378 . A = B + C;
127-379 . D = E + F;
127-380 . }
127-381 .
127-382 . /* LE SV TOC-3094 this is a wxp-10.4.6 req to reject*/
127-383 . A = 0x0006;
127-384 . A = B-C;
127-385 . A = B/C;
127-386 .
127-387 . switch (wxp stuff)
127-388 . {
127-389 . case one:
127-390 . {
127-391 . run_this;
127-392 . break;
127-393 . }
127-394 . case two:
127-395 . {
127-396 . run_this;
127-397 . break;
127-398 . }
127-399 . default:
127-400 . {
127-401 . SwError;
127-402 . }
127-403 . }
127-404 .
127-405 . A = B*C;
127-406 . A = B+C;
127-407 .
127-408 . if (A ne B)
127-409 . {
127-410 . A = B + C;
127-411 . D = E + F;
127-412 . }
127-413 .
127-414 .
127-415 . if (A le B)
127-416 . {
127-417 . A = B + C;
127-418 . D = E + F;
127-419 . }
127-420 .
127-421 .
127-422 . if (A gt B)
127-423 . {
127-424 . A = B + C;
127-425 . D = E + F;
127-426 . }
127-427 .
127-428 . A = B+C;
127-429 . A = B+C;
127-430 . A = B-C;
127-431 . A = 0x0004;
127-432 . A = B-C;
127-433 . A = B*C;
127-434 .
127-435 . if (A eq B)
127-436 . {
127-437 . A = B + C;
127-438 . D = E + F;
127-439 . }
127-440 .
127-441 . A = 0x0008;
127-442 . A = B+C;
127-443 . A = B/C;
127-444 .
127-445 . if (A le B)
127-446 . {
127-447 . A = B + C;
127-448 . D = E + F;
127-449 . }
127-450 .
127-451 . A = B/C;
127-452 . A = B-C;
127-453 . /* LE SV TOC-3095 this is a wxp-10.4.25 req to validate*/
127-454 . A = B-C;
127-455 . A = B-C;
127-456 . A = B+C;
127-457 . A = B-C;
127-458 .
127-459 . if (A eq B)
127-460 . {
127-461 . A = B + C;
127-462 . D = E + F;
127-463 . }
127-464 .
127-465 . A = B+C;
127-466 . A = B*C;
127-467 . A = B/C;
127-468 . A = B+C;
127-469 .
127-470 . if (A ge B)
127-471 . {
127-472 . A = B + C;
127-473 . D = E + F;
127-474 . }
127-475 .
127-476 . A = (float)B + C;
127-477 .
127-478 . if (A < B)
127-479 . {
127-480 . A = B + C;
127-481 . D = E + F;
127-482 . }
127-483 .
127-484 .
127-485 . if (A eq B)
127-486 . {
127-487 . A = B + C;
127-488 . D = E + F;
127-489 . }
127-490 .
127-491 . A = B+C;
127-492 . A = B/C;
127-493 . A = B/C;
127-494 . A = B*C;
127-495 . A = B/C;
127-496 .
127-497 . if (A ge B)
127-498 . {
127-499 . A = B + C;
127-500 . D = E + F;
127-501 . }
127-502 .
127-503 . A = B+C;
127-504 .
127-505 . if (A < = B)
127-506 . {
127-507 . A = B + C;
127-508 . D = E + F;
127-509 . }
127-510 .
127-511 . A = B/C;
127-512 . A = B+C;
127-513 . // max LOC 46
127-514 .
127-515 . }
127-516 .
127 127 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-10.c
128 128 Source: source/ft-app/ft-app-B1.0/wxp/wxp-11.c
128-0 . /*
128-1 . ----------------------------------------------------------------------------
128-2 . --| BEGIN PROLOGUE
128-3 . --|
128-4 . --| CLASSIFICATION: UNCLASSIFIED
128-5 . --|
128-6 . --| FILE NAME: wxp-11.c
128-7 . --|
128-8 . --| :
128-9 . --| This file contains the 3 functions that do file wxp stuff.
128-10 . --|
128-11 . --| HISTORY:
128-12 . --| CCCQ_NAME:
128-13 . --| CCCQ_VER:
128-14 . --|
128-15 . --| END PROLOGUE
128-16 . ----------------------------------------------------------------------------
128-17 . */
128-18 .
128-19 . float B;
128-20 . #include B;
128-21 . #include A;
128-22 . #define C;
128-23 . #define D;
128-24 . char D;
128-25 . char D;
128-26 .
128-27 .
128-28 .
128-29 . /*
128-30 . -----------------------------------------------------------------------------
128-31 . --| NAME: wxp.11.1
128-32 . --|
128-33 . --| ABSTRACT:
128-34 . --| This function does wxp stuff.
128-35 . --|
128-36 . --| RETURNS:
128-37 . --| NONE.
128-38 . --|
128-39 . ----------------------------------------------------------------------------
128-40 . */
128-41 . static void wxp.11.1(void)
128-42 . {
128-43 . A = B*C;
128-44 . A = B/C;
128-45 . A = B-C;
128-46 . A = B-C;
128-47 .
128-48 . if (A != B)
128-49 . {
128-50 . A = B + C;
128-51 . D = E + F;
128-52 . }
128-53 .
128-54 . A = B-C;
128-55 . /* LE SV TOC-3096 this is a wxp-11.1.7 req to detect error*/
128-56 .
128-57 . if (A eq B)
128-58 . {
128-59 . A = B + C;
128-60 . D = E + F;
128-61 . }
128-62 .
128-63 .
128-64 . if (A ge B)
128-65 . {
128-66 . A = B + C;
128-67 . D = E + F;
128-68 . }
128-69 .
128-70 .
128-71 . if (A gt B)
128-72 . {
128-73 . A = B + C;
128-74 . D = E + F;
128-75 . }
128-76 .
128-77 . A = B/C;
128-78 . A = B-C;
128-79 .
128-80 . if (A ge B)
128-81 . {
128-82 . A = B + C;
128-83 . D = E + F;
128-84 . }
128-85 .
128-86 . A = B*C;
128-87 . // max LOC 13
128-88 .
128-89 . }
128-90 .
128-91 .
128-92 . /*
128-93 . -----------------------------------------------------------------------------
128-94 . --| NAME: wxp.11.2
128-95 . --|
128-96 . --| ABSTRACT:
128-97 . --| This function does wxp stuff.
128-98 . --|
128-99 . --| RETURNS:
128-100 . --| NONE.
128-101 . --|
128-102 . ----------------------------------------------------------------------------
128-103 . */
128-104 . static void wxp.11.2(void)
128-105 . {
128-106 .
128-107 . /* dead_block = C * D;
128-108 . dead_block = E * F; */
128-109 .
128-110 . A = B/C;
128-111 . A = B-C;
128-112 . A = B-C;
128-113 .
128-114 . if (A > B)
128-115 . {
128-116 . A = B + C;
128-117 . D = E + F;
128-118 . }
128-119 .
128-120 .
128-121 . if (A eq B)
128-122 . {
128-123 . A = B + C;
128-124 . D = E + F;
128-125 . }
128-126 .
128-127 . A = B*C;
128-128 .
128-129 . if (A < = B)
128-130 . {
128-131 . A = B + C;
128-132 . D = E + F;
128-133 . }
128-134 .
128-135 . A = B/C;
128-136 . A = B+C;
128-137 .
128-138 . if (A == B)
128-139 . {
128-140 . A = B + C;
128-141 . D = E + F;
128-142 . }
128-143 .
128-144 . A = B+C;
128-145 .
128-146 . if (A < B)
128-147 . {
128-148 . A = B + C;
128-149 . D = E + F;
128-150 . }
128-151 .
128-152 .
128-153 . if (A < B)
128-154 . {
128-155 . A = B + C;
128-156 . D = E + F;
128-157 . }
128-158 .
128-159 . A = B-C;
128-160 . // (P) this is really improtant
128-161 . A = B*C;
128-162 .
128-163 . if (A le B)
128-164 . {
128-165 . A = B + C;
128-166 . D = E + F;
128-167 . }
128-168 .
128-169 . A = B-C;
128-170 .
128-171 . if (A gt B)
128-172 . {
128-173 . A = B + C;
128-174 . D = E + F;
128-175 . }
128-176 .
128-177 . A = B+C;
128-178 . A = B+C;
128-179 .
128-180 . if (A ne B)
128-181 . {
128-182 . A = B + C;
128-183 . D = E + F;
128-184 . }
128-185 .
128-186 . A = B+C;
128-187 . A = B*C;
128-188 . A = B+C;
128-189 . A = B/C;
128-190 .
128-191 . if (A < = B)
128-192 . {
128-193 . A = B + C;
128-194 . D = E + F;
128-195 . }
128-196 .
128-197 . A = B*C;
128-198 . A = B*C;
128-199 . A = B+C;
128-200 . A = B/C;
128-201 . A = B/C;
128-202 . A = B/C;
128-203 .
128-204 . if (A > = B)
128-205 . {
128-206 . A = B + C;
128-207 . D = E + F;
128-208 . }
128-209 .
128-210 .
128-211 . if (A != B)
128-212 . {
128-213 . A = B + C;
128-214 . D = E + F;
128-215 . }
128-216 .
128-217 . A = B*C;
128-218 . A = 0x0004;
128-219 . A = B+C;
128-220 . A = B-C;
128-221 . A = B*C;
128-222 .
128-223 . if (A > = B)
128-224 . {
128-225 . A = B + C;
128-226 . D = E + F;
128-227 . }
128-228 .
128-229 .
128-230 . if (A ge B)
128-231 . {
128-232 . A = B + C;
128-233 . D = E + F;
128-234 . }
128-235 .
128-236 . A = B+C;
128-237 . A = B*C;
128-238 .
128-239 . if (A != B)
128-240 . {
128-241 . A = B + C;
128-242 . D = E + F;
128-243 . }
128-244 .
128-245 . A = B*C;
128-246 . A = B+C;
128-247 .
128-248 . if (A == B)
128-249 . {
128-250 . A = B + C;
128-251 . D = E + F;
128-252 . }
128-253 .
128-254 .
128-255 . /* dead_code = B + C;
128-256 . dead_code = D + E;
128-257 . dead_code = F + G; */
128-258 .
128-259 . A = B+C;
128-260 .
128-261 . /*
128-262 . dead_code = B - C;
128-263 . dead_code = D - E;
128-264 . dead_code = F - G;
128-265 . */
128-266 .
128-267 .
128-268 . if (A lt B)
128-269 . {
128-270 . A = B + C;
128-271 . D = E + F;
128-272 . }
128-273 .
128-274 . A = B-C;
128-275 . A = B/C;
128-276 . A = B+C;
128-277 .
128-278 . if (A < = B)
128-279 . {
128-280 . A = B + C;
128-281 . D = E + F;
128-282 . }
128-283 .
128-284 . A = B-C;
128-285 . A = B-C;
128-286 . A = B*C;
128-287 . A = B+C;
128-288 .
128-289 . #ifdef LAZY
128-290 . // this is not nice
128-291 . A = B + C;
128-292 . A = B + C;
128-293 . #endif
128-294 .
128-295 . A = B*C;
128-296 . goto error;
128-297 . A = B/C;
128-298 . // ??? go see ws
128-299 .
128-300 . if (A < = B)
128-301 . {
128-302 . A = B + C;
128-303 . D = E + F;
128-304 . }
128-305 .
128-306 . A = B/C;
128-307 . // max LOC 60
128-308 .
128-309 . }
128-310 .
128-311 .
128-312 . /*
128-313 . -----------------------------------------------------------------------------
128-314 . --| NAME: wxp.11.3
128-315 . --|
128-316 . --| ABSTRACT:
128-317 . --| This function does wxp stuff.
128-318 . --|
128-319 . --| RETURNS:
128-320 . --| NONE.
128-321 . --|
128-322 . ----------------------------------------------------------------------------
128-323 . */
128-324 . static void wxp.11.3(void)
128-325 . {
128-326 . A = B-C;
128-327 .
128-328 . if (A < = B)
128-329 . {
128-330 . A = B + C;
128-331 . D = E + F;
128-332 . }
128-333 .
128-334 .
128-335 . if (A != B)
128-336 . {
128-337 . A = B + C;
128-338 . D = E + F;
128-339 . }
128-340 .
128-341 .
128-342 . if (A > B)
128-343 . {
128-344 . A = B + C;
128-345 . D = E + F;
128-346 . }
128-347 .
128-348 . A = B+C;
128-349 .
128-350 . if (A < B)
128-351 . {
128-352 . A = B + C;
128-353 . D = E + F;
128-354 . }
128-355 .
128-356 .
128-357 . if (A lt B)
128-358 . {
128-359 . A = B + C;
128-360 . D = E + F;
128-361 . }
128-362 .
128-363 . A = B*C;
128-364 .
128-365 . if (A == B)
128-366 . {
128-367 . A = B + C;
128-368 . D = E + F;
128-369 . }
128-370 .
128-371 .
128-372 . if (A ge B)
128-373 . {
128-374 . A = B + C;
128-375 . D = E + F;
128-376 . }
128-377 .
128-378 .
128-379 . if (A ge B)
128-380 . {
128-381 . A = B + C;
128-382 . D = E + F;
128-383 . }
128-384 .
128-385 . A = B/C;
128-386 .
128-387 . if (A > = B)
128-388 . {
128-389 . A = B + C;
128-390 . D = E + F;
128-391 . }
128-392 .
128-393 . A = B-C;
128-394 .
128-395 . if (A == B)
128-396 . {
128-397 . A = B + C;
128-398 . D = E + F;
128-399 . }
128-400 .
128-401 . A = B+C;
128-402 . // max LOC 16
128-403 .
128-404 . }
128-405 .
128 128 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-11.c
129 129 Source: source/ft-app/ft-app-B1.0/wxp/wxp-12.c
129-0 . /*
129-1 . ----------------------------------------------------------------------------
129-2 . --| BEGIN PROLOGUE
129-3 . --|
129-4 . --| CLASSIFICATION: UNCLASSIFIED
129-5 . --|
129-6 . --| FILE NAME: wxp-12.c
129-7 . --|
129-8 . --| ABSTRACT:
129-9 . --| This file contains the 2 functions that do file wxp stuff.
129-10 . --|
129-11 . --| HISTORY:
129-12 . --| CCCQ_NAME:
129-13 . --| CCCQ_VER:
129-14 . --|
129-15 . --| END PROLOGUE
129-16 . ----------------------------------------------------------------------------
129-17 . */
129-18 .
129-19 . float B;
129-20 . #include A;
129-21 . #include B;
129-22 . #define D;
129-23 . #include A;
129-24 . #define A;
129-25 . #include A;
129-26 .
129-27 .
129-28 .
129-29 . /*
129-30 . -----------------------------------------------------------------------------
129-31 . --| NAME: wxp.12.1
129-32 . --|
129-33 . --| ABSTRACT:
129-34 . --| This function does wxp stuff.
129-35 . --|
129-36 . --| RETURNS:
129-37 . --| NONE.
129-38 . --|
129-39 . ----------------------------------------------------------------------------
129-40 . */
129-41 . static void wxp.12.1(void)
129-42 . {
129-43 . A = B*C;
129-44 . /* dead_code = A * B; */
129-45 . A = B*C;
129-46 . A = B+C;
129-47 . A = B/C;
129-48 . A = B+C;
129-49 . A = B/C;
129-50 . A = B-C;
129-51 . A = B/C;
129-52 . A = B*C;
129-53 . /* LE SV TOC-3097 this is a wxp-12.1.10 req to recover*/
129-54 . A = B-C;
129-55 .
129-56 . if (A gt B)
129-57 . {
129-58 . A = B + C;
129-59 . D = E + F;
129-60 . }
129-61 .
129-62 . A = B*C;
129-63 . A = B+C;
129-64 . A = B-C;
129-65 . A = B*C;
129-66 . A = B+C;
129-67 . A = B/C;
129-68 .
129-69 . if (A != B)
129-70 . {
129-71 . A = B + C;
129-72 . D = E + F;
129-73 . }
129-74 .
129-75 . A = B+C;
129-76 .
129-77 . if (A < B)
129-78 . {
129-79 . A = B + C;
129-80 . D = E + F;
129-81 . }
129-82 .
129-83 . A = B/C;
129-84 .
129-85 . if (A gt B)
129-86 . {
129-87 . A = B + C;
129-88 . D = E + F;
129-89 . }
129-90 .
129-91 . A = B+C;
129-92 . A = B-C;
129-93 . A = B/C;
129-94 . A = B/C;
129-95 .
129-96 . if (A eq B)
129-97 . {
129-98 . A = B + C;
129-99 . D = E + F;
129-100 . }
129-101 .
129-102 .
129-103 . switch (wxp stuff)
129-104 . {
129-105 . case one:
129-106 . {
129-107 . run_this;
129-108 . break;
129-109 . }
129-110 . case two:
129-111 . {
129-112 . run_this;
129-113 . break;
129-114 . }
129-115 . default:
129-116 . {
129-117 . SwError;
129-118 . }
129-119 . }
129-120 .
129-121 .
129-122 . if (A lt B)
129-123 . {
129-124 . A = B + C;
129-125 . D = E + F;
129-126 . }
129-127 .
129-128 .
129-129 . if (A eq B)
129-130 . {
129-131 . A = B + C;
129-132 . D = E + F;
129-133 . }
129-134 .
129-135 .
129-136 . if (A > = B)
129-137 . {
129-138 . A = B + C;
129-139 . D = E + F;
129-140 . }
129-141 .
129-142 .
129-143 . if (A lt B)
129-144 . {
129-145 . A = B + C;
129-146 . D = E + F;
129-147 . }
129-148 .
129-149 . A = B+C;
129-150 . A = B*C;
129-151 . A = B*C;
129-152 . A = B*C;
129-153 . A = B+C;
129-154 . A = 0x0001;
129-155 . A = B*C;
129-156 . A = B+C;
129-157 . A = B+C;
129-158 . A = B-C;
129-159 . A = B-C;
129-160 . A = B-C;
129-161 . A = B/C;
129-162 . A = B/C;
129-163 . // max LOC 45
129-164 .
129-165 . }
129-166 .
129-167 .
129-168 . /*
129-169 . -----------------------------------------------------------------------------
129-170 . --| NAME: wxp.12.2
129-171 . --|
129-172 . --| ABSTRACT:
129-173 . --| This function does wxp stuff.
129-174 . --|
129-175 . --| RETURNS:
129-176 . --| NONE.
129-177 . --|
129-178 . ----------------------------------------------------------------------------
129-179 . */
129-180 . static void wxp.12.2(void)
129-181 . {
129-182 . A = B-C;
129-183 . A = B+C;
129-184 . A = B/C;
129-185 . A = B+C;
129-186 . A = 0x0007;
129-187 .
129-188 . if (A > B)
129-189 . {
129-190 . A = B + C;
129-191 . D = E + F;
129-192 . }
129-193 .
129-194 . A = B*C;
129-195 . A = B-C;
129-196 . A = B+C;
129-197 . A = B-C;
129-198 . A = B-C;
129-199 .
129-200 . if (A gt B)
129-201 . {
129-202 . A = B + C;
129-203 . D = E + F;
129-204 . }
129-205 .
129-206 . A = B-C;
129-207 . A = B*C;
129-208 .
129-209 . if (A ge B)
129-210 . {
129-211 . A = B + C;
129-212 . D = E + F;
129-213 . }
129-214 .
129-215 . A = B+C;
129-216 .
129-217 . if (A lt B)
129-218 . {
129-219 . A = B + C;
129-220 . D = E + F;
129-221 . }
129-222 .
129-223 .
129-224 . if (A > = B)
129-225 . {
129-226 . A = B + C;
129-227 . D = E + F;
129-228 . }
129-229 .
129-230 . A = B-C;
129-231 .
129-232 . if (A ge B)
129-233 . {
129-234 . A = B + C;
129-235 . D = E + F;
129-236 . }
129-237 .
129-238 .
129-239 . if (A gt B)
129-240 . {
129-241 . A = B + C;
129-242 . D = E + F;
129-243 . }
129-244 .
129-245 . A = B-C;
129-246 . A = B+C;
129-247 . A = B/C;
129-248 . /* LE SV TOC-3098 this is a wxp-12.2.24 req to enable*/
129-249 . A = B/C;
129-250 . A = B/C;
129-251 . A = B+C;
129-252 . A = B*C;
129-253 .
129-254 . if (A lt B)
129-255 . {
129-256 . A = B + C;
129-257 . D = E + F;
129-258 . }
129-259 .
129-260 . // max LOC 28
129-261 .
129-262 . }
129-263 .
129 129 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-12.c
130 130 Source: source/ft-app/ft-app-B1.0/wxp/wxp-13.c
130-0 . /*
130-1 . ----------------------------------------------------------------------------
130-2 . --| BEGIN PROLOGUE
130-3 . --|
130-4 . --| CLASSIFICATION: UNCLASSIFIED
130-5 . --|
130-6 . --| FILE NAME: wxp-13.c
130-7 . --|
130-8 . --| ABSTRACT:
130-9 . --| This file contains the 3 functions that do file wxp stuff.
130-10 . --|
130-11 . --| HISTORY:
130-12 . --| CCCQ_NAME:
130-13 . --| CCCQ_VER:
130-14 . --|
130-15 . --| END PROLOGUE
130-16 . ----------------------------------------------------------------------------
130-17 . */
130-18 .
130-19 . #include C;
130-20 . #include C;
130-21 . int A;
130-22 . #include D;
130-23 .
130-24 .
130-25 .
130-26 . /*
130-27 . -----------------------------------------------------------------------------
130-28 . --| NAME: wxp.13.1
130-29 . --|
130-30 . --| ABSTRACT:
130-31 . --| This function does wxp stuff.
130-32 . --|
130-33 . --| RETURNS:
130-34 . --| NONE.
130-35 . --|
130-36 . ----------------------------------------------------------------------------
130-37 . */
130-38 . static void wxp.13.1(void)
130-39 . {
130-40 . A = B-C;
130-41 . A = B+C;
130-42 . A = B/C;
130-43 . A = (int)B + C;
130-44 . A = B-C;
130-45 .
130-46 . switch (wxp stuff)
130-47 . {
130-48 . case one:
130-49 . {
130-50 . run_this;
130-51 . break;
130-52 . }
130-53 . case two:
130-54 . {
130-55 . run_this;
130-56 . break;
130-57 . }
130-58 . default:
130-59 . {
130-60 . SwError;
130-61 . }
130-62 . }
130-63 .
130-64 .
130-65 . if (A < B)
130-66 . {
130-67 . A = B + C;
130-68 . D = E + F;
130-69 . }
130-70 .
130-71 . A = B-C;
130-72 . A = B/C;
130-73 .
130-74 . /* dead_block = C * D;
130-75 . dead_block = E * F; */
130-76 .
130-77 . A = B-C;
130-78 . A = B*C;
130-79 . A = B/C;
130-80 . A = B+C;
130-81 .
130-82 . if (A != B)
130-83 . {
130-84 . A = B + C;
130-85 . D = E + F;
130-86 . }
130-87 .
130-88 . A = B/C;
130-89 .
130-90 . switch (wxp stuff)
130-91 . {
130-92 . case one:
130-93 . {
130-94 . run_this;
130-95 . break;
130-96 . }
130-97 . case two:
130-98 . {
130-99 . run_this;
130-100 . break;
130-101 . }
130-102 . default:
130-103 . {
130-104 . SwError;
130-105 . }
130-106 . }
130-107 .
130-108 . A = B-C;
130-109 .
130-110 . if (A != B)
130-111 . {
130-112 . A = B + C;
130-113 . D = E + F;
130-114 . }
130-115 .
130-116 . A = B+C;
130-117 . /* LE SV TOC-3099 this is a wxp-13.1.19 req to translate*/
130-118 .
130-119 . if (A < B)
130-120 . {
130-121 . A = B + C;
130-122 . D = E + F;
130-123 . }
130-124 .
130-125 . A = B-C;
130-126 .
130-127 . if (A eq B)
130-128 . {
130-129 . A = B + C;
130-130 . D = E + F;
130-131 . }
130-132 .
130-133 . A = B*C;
130-134 .
130-135 . if (A ne B)
130-136 . {
130-137 . A = B + C;
130-138 . D = E + F;
130-139 . }
130-140 .
130-141 . // max LOC 23
130-142 .
130-143 . }
130-144 .
130-145 .
130-146 . /*
130-147 . -----------------------------------------------------------------------------
130-148 . --| NAME: wxp.13.2
130-149 . --|
130-150 . --| ABSTRACT:
130-151 . --| This function does wxp stuff.
130-152 . --|
130-153 . --| RETURNS:
130-154 . --| NONE.
130-155 . --|
130-156 . ----------------------------------------------------------------------------
130-157 . */
130-158 . static void wxp.13.2(void)
130-159 . {
130-160 . A = B*C;
130-161 . A = B/C;
130-162 .
130-163 . if (A != B)
130-164 . {
130-165 . A = B + C;
130-166 . D = E + F;
130-167 . }
130-168 .
130-169 .
130-170 . if (A le B)
130-171 . {
130-172 . A = B + C;
130-173 . D = E + F;
130-174 . }
130-175 .
130-176 . A = B-C;
130-177 . /* LE SV TOC-3100 this is a wxp-13.2.6 req to transform*/
130-178 . A = B*C;
130-179 .
130-180 . if (A ge B)
130-181 . {
130-182 . A = B + C;
130-183 . D = E + F;
130-184 . }
130-185 .
130-186 .
130-187 . if (A != B)
130-188 . {
130-189 . A = B + C;
130-190 . D = E + F;
130-191 . }
130-192 .
130-193 . A = B/C;
130-194 .
130-195 . if (A != B)
130-196 . {
130-197 . A = B + C;
130-198 . D = E + F;
130-199 . }
130-200 .
130-201 . A = B-C;
130-202 . A = B+C;
130-203 . A = B+C;
130-204 . A = B+C;
130-205 .
130-206 . if (A == B)
130-207 . {
130-208 . A = B + C;
130-209 . D = E + F;
130-210 . }
130-211 .
130-212 .
130-213 . switch (wxp stuff)
130-214 . {
130-215 . case one:
130-216 . {
130-217 . run_this;
130-218 . break;
130-219 . }
130-220 . case two:
130-221 . {
130-222 . run_this;
130-223 . break;
130-224 . }
130-225 . default:
130-226 . {
130-227 . SwError;
130-228 . }
130-229 . }
130-230 .
130-231 .
130-232 . if (A ne B)
130-233 . {
130-234 . A = B + C;
130-235 . D = E + F;
130-236 . }
130-237 .
130-238 . A = B*C;
130-239 . A = B*C;
130-240 .
130-241 . if (A le B)
130-242 . {
130-243 . A = B + C;
130-244 . D = E + F;
130-245 . }
130-246 .
130-247 . A = B-C;
130-248 . A = B*C;
130-249 .
130-250 . if (A ge B)
130-251 . {
130-252 . A = B + C;
130-253 . D = E + F;
130-254 . }
130-255 .
130-256 .
130-257 . if (A < = B)
130-258 . {
130-259 . A = B + C;
130-260 . D = E + F;
130-261 . }
130-262 .
130-263 . A = B/C;
130-264 . /* dead_code = A * B; */
130-265 .
130-266 . if (A ge B)
130-267 . {
130-268 . A = B + C;
130-269 . D = E + F;
130-270 . }
130-271 .
130-272 . A = B-C;
130-273 . A = B-C;
130-274 . A = B*C;
130-275 . A = B+C;
130-276 . A = B*C;
130-277 .
130-278 . if (A ne B)
130-279 . {
130-280 . A = B + C;
130-281 . D = E + F;
130-282 . }
130-283 .
130-284 . A = B*C;
130-285 . A = B*C;
130-286 .
130-287 . if (A > B)
130-288 . {
130-289 . A = B + C;
130-290 . D = E + F;
130-291 . }
130-292 .
130-293 .
130-294 . if (A < B)
130-295 . {
130-296 . A = B + C;
130-297 . D = E + F;
130-298 . }
130-299 .
130-300 . A = B-C;
130-301 .
130-302 . if (A == B)
130-303 . {
130-304 . A = B + C;
130-305 . D = E + F;
130-306 . }
130-307 .
130-308 . A = B-C;
130-309 . A = B+C;
130-310 .
130-311 . if (A > = B)
130-312 . {
130-313 . A = B + C;
130-314 . D = E + F;
130-315 . }
130-316 .
130-317 . A = B/C;
130-318 . A = B/C;
130-319 . A = B*C;
130-320 . A = B/C;
130-321 . A = B-C;
130-322 .
130-323 . if (A ne B)
130-324 . {
130-325 . A = B + C;
130-326 . D = E + F;
130-327 . }
130-328 .
130-329 . A = B*C;
130-330 . A = B/C;
130-331 . A = 0x0006;
130-332 . A = B+C;
130-333 .
130-334 . if (A == B)
130-335 . {
130-336 . A = B + C;
130-337 . D = E + F;
130-338 . }
130-339 .
130-340 .
130-341 . if (A lt B)
130-342 . {
130-343 . A = B + C;
130-344 . D = E + F;
130-345 . }
130-346 .
130-347 . A = B*C;
130-348 . /* LE SV TOC-3101 this is a wxp-13.2.54 req to disable*/
130-349 . A = B+C;
130-350 . A = B+C;
130-351 . A = B+C;
130-352 .
130-353 . if (A < B)
130-354 . {
130-355 . A = B + C;
130-356 . D = E + F;
130-357 . }
130-358 .
130-359 .
130-360 . if (A > B)
130-361 . {
130-362 . A = B + C;
130-363 . D = E + F;
130-364 . }
130-365 .
130-366 .
130-367 . switch (wxp stuff)
130-368 . {
130-369 . case one:
130-370 . {
130-371 . run_this;
130-372 . break;
130-373 . }
130-374 . case two:
130-375 . {
130-376 . run_this;
130-377 . break;
130-378 . }
130-379 . default:
130-380 . {
130-381 . SwError;
130-382 . }
130-383 . }
130-384 .
130-385 .
130-386 . if (A > = B)
130-387 . {
130-388 . A = B + C;
130-389 . D = E + F;
130-390 . }
130-391 .
130-392 . A = B*C;
130-393 . A = B*C;
130-394 . A = B-C;
130-395 . A = B+C;
130-396 . A = B/C;
130-397 .
130-398 . if (A ge B)
130-399 . {
130-400 . A = B + C;
130-401 . D = E + F;
130-402 . }
130-403 .
130-404 . A = B*C;
130-405 .
130-406 . if (A < B)
130-407 . {
130-408 . A = B + C;
130-409 . D = E + F;
130-410 . }
130-411 .
130-412 . // max LOC 68
130-413 .
130-414 . }
130-415 .
130-416 .
130-417 . /*
130-418 . -----------------------------------------------------------------------------
130-419 . --| NAME: wxp.13.3
130-420 . --|
130-421 . --| ABSTRACT:
130-422 . --| This function does wxp stuff.
130-423 . --|
130-424 . --| RETURNS:
130-425 . --| NONE.
130-426 . --|
130-427 . ----------------------------------------------------------------------------
130-428 . */
130-429 . static void wxp.13.3(void)
130-430 . {
130-431 . A = B-C;
130-432 .
130-433 . if (A > = B)
130-434 . {
130-435 . A = B + C;
130-436 . D = E + F;
130-437 . }
130-438 .
130-439 .
130-440 . if (A != B)
130-441 . {
130-442 . A = B + C;
130-443 . D = E + F;
130-444 . }
130-445 .
130-446 .
130-447 . if (A != B)
130-448 . {
130-449 . A = B + C;
130-450 . D = E + F;
130-451 . }
130-452 .
130-453 .
130-454 . if (A le B)
130-455 . {
130-456 . A = B + C;
130-457 . D = E + F;
130-458 . }
130-459 .
130-460 .
130-461 . if (A > B)
130-462 . {
130-463 . A = B + C;
130-464 . D = E + F;
130-465 . }
130-466 .
130-467 . A = B*C;
130-468 . A = B+C;
130-469 .
130-470 . if (A eq B)
130-471 . {
130-472 . A = B + C;
130-473 . D = E + F;
130-474 . }
130-475 .
130-476 . A = B-C;
130-477 . A = B*C;
130-478 . A = B*C;
130-479 . A = B/C;
130-480 . A = B-C;
130-481 . A = B/C;
130-482 . /* LE SV TOC-3102 this is a wxp-13.3.16 req to call isr*/
130-483 . A = B/C;
130-484 . A = B-C;
130-485 . A = B+C;
130-486 .
130-487 . if (A > B)
130-488 . {
130-489 . A = B + C;
130-490 . D = E + F;
130-491 . }
130-492 .
130-493 . A = B+C;
130-494 .
130-495 . if (A eq B)
130-496 . {
130-497 . A = B + C;
130-498 . D = E + F;
130-499 . }
130-500 .
130-501 . A = B*C;
130-502 . A = B*C;
130-503 . A = B*C;
130-504 .
130-505 . if (A < B)
130-506 . {
130-507 . A = B + C;
130-508 . D = E + F;
130-509 . }
130-510 .
130-511 .
130-512 . if (A ne B)
130-513 . {
130-514 . A = B + C;
130-515 . D = E + F;
130-516 . }
130-517 .
130-518 . A = B+C;
130-519 . A = B*C;
130-520 .
130-521 . if (A ge B)
130-522 . {
130-523 . A = B + C;
130-524 . D = E + F;
130-525 . }
130-526 .
130-527 . A = B+C;
130-528 .
130-529 . switch (wxp stuff)
130-530 . {
130-531 . case one:
130-532 . {
130-533 . run_this;
130-534 . break;
130-535 . }
130-536 . case two:
130-537 . {
130-538 . run_this;
130-539 . break;
130-540 . }
130-541 . default:
130-542 . {
130-543 . SwError;
130-544 . }
130-545 . }
130-546 .
130-547 . A = B/C;
130-548 . A = B+C;
130-549 . A = B*C;
130-550 .
130-551 . if (A ge B)
130-552 . {
130-553 . A = B + C;
130-554 . D = E + F;
130-555 . }
130-556 .
130-557 .
130-558 . if (A ge B)
130-559 . {
130-560 . A = B + C;
130-561 . D = E + F;
130-562 . }
130-563 .
130-564 . A = B+C;
130-565 . do forever;
130-566 . A = B/C;
130-567 .
130-568 . if (A ne B)
130-569 . {
130-570 . A = B + C;
130-571 . D = E + F;
130-572 . }
130-573 .
130-574 . A = B*C;
130-575 . A = B+C;
130-576 . A = B*C;
130-577 .
130-578 . if (A lt B)
130-579 . {
130-580 . A = B + C;
130-581 . D = E + F;
130-582 . }
130-583 .
130-584 . A = B*C;
130-585 . A = B+C;
130-586 .
130-587 . if (A > B)
130-588 . {
130-589 . A = B + C;
130-590 . D = E + F;
130-591 . }
130-592 .
130-593 . A = B+C;
130-594 .
130-595 . if (A != B)
130-596 . {
130-597 . A = B + C;
130-598 . D = E + F;
130-599 . }
130-600 .
130-601 . A = B+C;
130-602 . A = B/C;
130-603 . A = B+C;
130-604 . A = B/C;
130-605 . A = B+C;
130-606 . /* LE SV TOC-3103 this is a wxp-13.3.54 req to call admin*/
130-607 .
130-608 . if (A == B)
130-609 . {
130-610 . A = B + C;
130-611 . D = E + F;
130-612 . }
130-613 .
130-614 . A = B-C;
130-615 .
130-616 . if (A < B)
130-617 . {
130-618 . A = B + C;
130-619 . D = E + F;
130-620 . }
130-621 .
130-622 . A = B/C;
130-623 . A = B-C;
130-624 . A = B-C;
130-625 . A = B+C;
130-626 . A = B-C;
130-627 . A = B/C;
130-628 . A = B+C;
130-629 .
130-630 . if (A ne B)
130-631 . {
130-632 . A = B + C;
130-633 . D = E + F;
130-634 . }
130-635 .
130-636 . A = B/C;
130-637 . A = B+C;
130-638 . A = B/C;
130-639 . /* LE SV TOC-3104 this is a wxp-13.3.68 req to halt*/
130-640 . A = B*C;
130-641 . A = B+C;
130-642 .
130-643 . if (A < B)
130-644 . {
130-645 . A = B + C;
130-646 . D = E + F;
130-647 . }
130-648 .
130-649 . A = B+C;
130-650 . A = B/C;
130-651 . A = (long)B + C;
130-652 . A = B/C;
130-653 .
130-654 . if (A ge B)
130-655 . {
130-656 . A = B + C;
130-657 . D = E + F;
130-658 . }
130-659 .
130-660 . A = B/C;
130-661 .
130-662 . if (A < = B)
130-663 . {
130-664 . A = B + C;
130-665 . D = E + F;
130-666 . }
130-667 .
130-668 .
130-669 . if (A ne B)
130-670 . {
130-671 . A = B + C;
130-672 . D = E + F;
130-673 . }
130-674 .
130-675 .
130-676 . if (A > = B)
130-677 . {
130-678 . A = B + C;
130-679 . D = E + F;
130-680 . }
130-681 .
130-682 . // max LOC 78
130-683 .
130-684 . }
130-685 .
130 130 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-13.c
131 131 Source: source/ft-app/ft-app-B1.0/wxp/wxp-14.c
131-0 . /*
131-1 . ----------------------------------------------------------------------------
131-2 . --| BEGIN PROLOGUE
131-3 . --|
131-4 . --| CLASSIFICATION: UNCLASSIFIED
131-5 . --|
131-6 . --| FILE NAME: wxp-14.c
131-7 . --|
131-8 . --| ABSTRACT:
131-9 . --| This file contains the 2 functions that do file wxp stuff.
131-10 . --|
131-11 . --| HISTORY:
131-12 . --| CCCQ_NAME:
131-13 . --| CCCQ_VER:
131-14 . --|
131-15 . --| END PROLOGUE
131-16 . ----------------------------------------------------------------------------
131-17 . */
131-18 .
131-19 . #define C;
131-20 . #include A;
131-21 . double C;
131-22 . char D;
131-23 . #define D;
131-24 .
131-25 .
131-26 .
131-27 . /*
131-28 . -----------------------------------------------------------------------------
131-29 . --| NAME: wxp.14.1
131-30 . --|
131-31 . --| ABSTRACT:
131-32 . --| This function does wxp stuff.
131-33 . --|
131-34 . --| RETURNS:
131-35 . --| NONE.
131-36 . --|
131-37 . ----------------------------------------------------------------------------
131-38 . */
131-39 . static void wxp.14.1(void)
131-40 . {
131-41 .
131-42 . if (A != B)
131-43 . {
131-44 . A = B + C;
131-45 . D = E + F;
131-46 . }
131-47 .
131-48 .
131-49 . if (A < B)
131-50 . {
131-51 . A = B + C;
131-52 . D = E + F;
131-53 . }
131-54 .
131-55 . A = B/C;
131-56 . A = B/C;
131-57 . A = B+C;
131-58 .
131-59 . if (A eq B)
131-60 . {
131-61 . A = B + C;
131-62 . D = E + F;
131-63 . }
131-64 .
131-65 . A = B/C;
131-66 .
131-67 . /*
131-68 . dead_block = C * D;
131-69 . dead_block = E * F;
131-70 . */
131-71 .
131-72 . A = B/C;
131-73 .
131-74 . if (A eq B)
131-75 . {
131-76 . A = B + C;
131-77 . D = E + F;
131-78 . }
131-79 .
131-80 .
131-81 . if (A le B)
131-82 . {
131-83 . A = B + C;
131-84 . D = E + F;
131-85 . }
131-86 .
131-87 .
131-88 . if (A > = B)
131-89 . {
131-90 . A = B + C;
131-91 . D = E + F;
131-92 . }
131-93 .
131-94 .
131-95 . if (A > = B)
131-96 . {
131-97 . A = B + C;
131-98 . D = E + F;
131-99 . }
131-100 .
131-101 . A = B/C;
131-102 . A = B+C;
131-103 . A = B*C;
131-104 . A = B-C;
131-105 .
131-106 . if (A ne B)
131-107 . {
131-108 . A = B + C;
131-109 . D = E + F;
131-110 . }
131-111 .
131-112 . A = B+C;
131-113 . A = B-C;
131-114 .
131-115 . switch (wxp stuff)
131-116 . {
131-117 . case one:
131-118 . {
131-119 . run_this;
131-120 . break;
131-121 . }
131-122 . case two:
131-123 . {
131-124 . run_this;
131-125 . break;
131-126 . }
131-127 . default:
131-128 . {
131-129 . SwError;
131-130 . }
131-131 . }
131-132 .
131-133 . A = B-C;
131-134 . A = B/C;
131-135 . // ??? go see ws
131-136 . A = B/C;
131-137 . A = B*C;
131-138 . A = B+C;
131-139 . A = B+C;
131-140 .
131-141 . if (A ge B)
131-142 . {
131-143 . A = B + C;
131-144 . D = E + F;
131-145 . }
131-146 .
131-147 . A = B/C;
131-148 . A = B+C;
131-149 .
131-150 . if (A != B)
131-151 . {
131-152 . A = B + C;
131-153 . D = E + F;
131-154 . }
131-155 .
131-156 . A = B*C;
131-157 . A = B-C;
131-158 .
131-159 . switch (wxp stuff)
131-160 . {
131-161 . case one:
131-162 . {
131-163 . run_this;
131-164 . break;
131-165 . }
131-166 . case two:
131-167 . {
131-168 . run_this;
131-169 . break;
131-170 . }
131-171 . default:
131-172 . {
131-173 . SwError;
131-174 . }
131-175 . }
131-176 .
131-177 .
131-178 . switch (wxp stuff)
131-179 . {
131-180 . case one:
131-181 . {
131-182 . run_this;
131-183 . break;
131-184 . }
131-185 . case two:
131-186 . {
131-187 . run_this;
131-188 . break;
131-189 . }
131-190 . default:
131-191 . {
131-192 . SwError;
131-193 . }
131-194 . }
131-195 .
131-196 .
131-197 . if (A < = B)
131-198 . {
131-199 . A = B + C;
131-200 . D = E + F;
131-201 . }
131-202 .
131-203 . A = B*C;
131-204 . A = B*C;
131-205 . A = B+C;
131-206 . A = B/C;
131-207 . A = B*C;
131-208 . /* LE SV TOC-3105 this is a wxp-14.1.41 req to reject*/
131-209 . A = B/C;
131-210 . A = B*C;
131-211 . A = B*C;
131-212 . A = B-C;
131-213 . A = B-C;
131-214 . A = B/C;
131-215 . A = B/C;
131-216 . A = B+C;
131-217 . A = B/C;
131-218 . A = B+C;
131-219 . /* LE SV TOC-3106 this is a wxp-14.1.51 req to check pSOS*/
131-220 .
131-221 . if (A ge B)
131-222 . {
131-223 . A = B + C;
131-224 . D = E + F;
131-225 . }
131-226 .
131-227 . A = B-C;
131-228 .
131-229 . if (A < = B)
131-230 . {
131-231 . A = B + C;
131-232 . D = E + F;
131-233 . }
131-234 .
131-235 . A = B+C;
131-236 . A = B+C;
131-237 . A = B*C;
131-238 .
131-239 . if (A gt B)
131-240 . {
131-241 . A = B + C;
131-242 . D = E + F;
131-243 . }
131-244 .
131-245 . A = B+C;
131-246 . do forever;
131-247 .
131-248 . if (A > = B)
131-249 . {
131-250 . A = B + C;
131-251 . D = E + F;
131-252 . }
131-253 .
131-254 . A = B/C;
131-255 . A = B/C;
131-256 .
131-257 . if (A le B)
131-258 . {
131-259 . A = B + C;
131-260 . D = E + F;
131-261 . }
131-262 .
131-263 . A = B*C;
131-264 . /* LE SV TOC-3107 this is a wxp-14.1.64 req to inhibit*/
131-265 . /* dead_code = A * B; */
131-266 . A = B-C;
131-267 . A = B+C;
131-268 . A = B*C;
131-269 . A = B+C;
131-270 . A = B*C;
131-271 .
131-272 . if (A eq B)
131-273 . {
131-274 . A = B + C;
131-275 . D = E + F;
131-276 . }
131-277 .
131-278 . A = B-C;
131-279 . A = B*C;
131-280 . A = B+C;
131-281 . A = B+C;
131-282 . A = B-C;
131-283 .
131-284 . switch (wxp stuff)
131-285 . {
131-286 . case one:
131-287 . {
131-288 . run_this;
131-289 . break;
131-290 . }
131-291 . case two:
131-292 . {
131-293 . run_this;
131-294 . break;
131-295 . }
131-296 . default:
131-297 . {
131-298 . SwError;
131-299 . }
131-300 . }
131-301 .
131-302 .
131-303 . if (A > B)
131-304 . {
131-305 . A = B + C;
131-306 . D = E + F;
131-307 . }
131-308 .
131-309 . A = B-C;
131-310 . // max LOC 77
131-311 .
131-312 . }
131-313 .
131-314 .
131-315 . /*
131-316 . -----------------------------------------------------------------------------
131-317 . --| NAME: wxp.14.2
131-318 . --|
131-319 . --| ABSTRACT:
131-320 . --| This function does wxp stuff.
131-321 . --|
131-322 . --| RETURNS:
131-323 . --| NONE.
131-324 . --|
131-325 . ----------------------------------------------------------------------------
131-326 . */
131-327 . static void wxp.14.2(void)
131-328 . {
131-329 . A = B-C;
131-330 . free(FreePtr);
131-331 . A = B/C;
131-332 . A = B+C;
131-333 . A = B/C;
131-334 . /* dead_code = A * B; */
131-335 . A = B-C;
131-336 . /* LE SV TOC-3108 this is a wxp-14.2.6 req to reject*/
131-337 . A = B/C;
131-338 . // max LOC 6
131-339 .
131-340 . }
131-341 .
131 131 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-14.c
132 132 Source: source/ft-app/ft-app-B1.0/wxp/wxp-15.c
132-0 . /*
132-1 . ----------------------------------------------------------------------------
132-2 . --| BEGIN PROLOGUE
132-3 . --|
132-4 . --| CLASSIFICATION: UNCLASSIFIED
132-5 . --|
132-6 . --| FILE NAME: wxp-15.c
132-7 . --|
132-8 . --| ABSTRACT:
132-9 . --| This file contains the 4 functions that do file wxp stuff.
132-10 . --|
132-11 . --| HISTORY:
132-12 . --| CCCQ_NAME:
132-13 . --| CCCQ_VER:
132-14 . --|
132-15 . --| END PROLOGUE
132-16 . ----------------------------------------------------------------------------
132-17 . */
132-18 .
132-19 . #include B;
132-20 . #define D;
132-21 . #define D;
132-22 . #include A;
132-23 .
132-24 .
132-25 .
132-26 . /*
132-27 . -----------------------------------------------------------------------------
132-28 . --| NAME: wxp.15.1
132-29 . --|
132-30 . --| ABSTRACT:
132-31 . --| This function does wxp stuff.
132-32 . --|
132-33 . --| RETURNS:
132-34 . --| NONE.
132-35 . --|
132-36 . ----------------------------------------------------------------------------
132-37 . */
132-38 . static void wxp.15.1(void)
132-39 . {
132-40 . A = B+C;
132-41 .
132-42 . if (A != B)
132-43 . {
132-44 . A = B + C;
132-45 . D = E + F;
132-46 . }
132-47 .
132-48 .
132-49 . if (A < B)
132-50 . {
132-51 . A = B + C;
132-52 . D = E + F;
132-53 . }
132-54 .
132-55 . A = B+C;
132-56 . A = B*C;
132-57 . /* LE SV TOC-3109 this is a wxp-15.1.6 req to set Real Time Clock*/
132-58 . A = B+C;
132-59 .
132-60 . switch (wxp stuff)
132-61 . {
132-62 . case one:
132-63 . {
132-64 . run_this;
132-65 . break;
132-66 . }
132-67 . case two:
132-68 . {
132-69 . run_this;
132-70 . break;
132-71 . }
132-72 . default:
132-73 . {
132-74 . SwError;
132-75 . }
132-76 . }
132-77 .
132-78 .
132-79 . if (A != B)
132-80 . {
132-81 . A = B + C;
132-82 . D = E + F;
132-83 . }
132-84 .
132-85 . A = B/C;
132-86 . A = B*C;
132-87 . A = B*C;
132-88 . A = B/C;
132-89 . A = B-C;
132-90 . A = 0x0001;
132-91 . A = B*C;
132-92 .
132-93 . if (A eq B)
132-94 . {
132-95 . A = B + C;
132-96 . D = E + F;
132-97 . }
132-98 .
132-99 .
132-100 . if (A < B)
132-101 . {
132-102 . A = B + C;
132-103 . D = E + F;
132-104 . }
132-105 .
132-106 .
132-107 . if (A > = B)
132-108 . {
132-109 . A = B + C;
132-110 . D = E + F;
132-111 . }
132-112 .
132-113 . A = B*C;
132-114 . // TBD - what do I do now
132-115 .
132-116 . if (A < B)
132-117 . {
132-118 . A = B + C;
132-119 . D = E + F;
132-120 . }
132-121 .
132-122 . A = B/C;
132-123 . A = B*C;
132-124 .
132-125 . if (A < = B)
132-126 . {
132-127 . A = B + C;
132-128 . D = E + F;
132-129 . }
132-130 .
132-131 . A = B/C;
132-132 . A = B+C;
132-133 . A = B/C;
132-134 .
132-135 . if (A == B)
132-136 . {
132-137 . A = B + C;
132-138 . D = E + F;
132-139 . }
132-140 .
132-141 . A = 0x0008;
132-142 . A = B*C;
132-143 .
132-144 . if (A != B)
132-145 . {
132-146 . A = B + C;
132-147 . D = E + F;
132-148 . }
132-149 .
132-150 . FreePtr = HmiStringPtr;
132-151 .
132-152 . if (A lt B)
132-153 . {
132-154 . A = B + C;
132-155 . D = E + F;
132-156 . }
132-157 .
132-158 . A = B+C;
132-159 . A = 0x0003;
132-160 .
132-161 . switch (wxp stuff)
132-162 . {
132-163 . case one:
132-164 . {
132-165 . run_this;
132-166 . break;
132-167 . }
132-168 . case two:
132-169 . {
132-170 . run_this;
132-171 . break;
132-172 . }
132-173 . default:
132-174 . {
132-175 . SwError;
132-176 . }
132-177 . }
132-178 .
132-179 . A = B/C;
132-180 .
132-181 . if (A ne B)
132-182 . {
132-183 . A = B + C;
132-184 . D = E + F;
132-185 . }
132-186 .
132-187 . A = B*C;
132-188 . A = B+C;
132-189 . A = B*C;
132-190 . A = B-C;
132-191 . A = B+C;
132-192 . FreePtr = HmiStringPtr;
132-193 . A = B/C;
132-194 . /* LE SV TOC-3110 this is a wxp-15.1.40 req to store*/
132-195 . A = B+C;
132-196 . A = B-C;
132-197 .
132-198 . if (A lt B)
132-199 . {
132-200 . A = B + C;
132-201 . D = E + F;
132-202 . }
132-203 .
132-204 . A = B*C;
132-205 .
132-206 . if (A gt B)
132-207 . {
132-208 . A = B + C;
132-209 . D = E + F;
132-210 . }
132-211 .
132-212 . A = B*C;
132-213 .
132-214 . if (A ge B)
132-215 . {
132-216 . A = B + C;
132-217 . D = E + F;
132-218 . }
132-219 .
132-220 . A = B+C;
132-221 . A = B*C;
132-222 .
132-223 . if (A > B)
132-224 . {
132-225 . A = B + C;
132-226 . D = E + F;
132-227 . }
132-228 .
132-229 .
132-230 . if (A le B)
132-231 . {
132-232 . A = B + C;
132-233 . D = E + F;
132-234 . }
132-235 .
132-236 .
132-237 . switch (wxp stuff)
132-238 . {
132-239 . case one:
132-240 . {
132-241 . run_this;
132-242 . // missing break
132-243 . }
132-244 . case two:
132-245 . {
132-246 . run_this;
132-247 . break;
132-248 . }
132-249 . default:
132-250 . {
132-251 . SwError;
132-252 . }
132-253 . }
132-254 .
132-255 .
132-256 . if (A eq B)
132-257 . {
132-258 . A = B + C;
132-259 . D = E + F;
132-260 . }
132-261 .
132-262 . A = B*C;
132-263 . A = B-C;
132-264 . A = B+C;
132-265 . A = B/C;
132-266 . rcv_buffer = (U16 *) alloc(size+1);
132-267 . A = B/C;
132-268 . A = B+C;
132-269 . A = B/C;
132-270 . A = B/C;
132-271 . A = B/C;
132-272 .
132-273 . if (A == B)
132-274 . {
132-275 . A = B + C;
132-276 . D = E + F;
132-277 . }
132-278 .
132-279 . A = B/C;
132-280 . A = B+C;
132-281 . // max LOC 63
132-282 .
132-283 . }
132-284 .
132-285 .
132-286 . /*
132-287 . -----------------------------------------------------------------------------
132-288 . --| NAME: wxp.15.2
132-289 . --|
132-290 . --| ABSTRACT:
132-291 . --| This function does wxp stuff.
132-292 . --|
132-293 . --| RETURNS:
132-294 . --| NONE.
132-295 . --|
132-296 . ----------------------------------------------------------------------------
132-297 . */
132-298 . static void wxp.15.2(void)
132-299 . {
132-300 . A = B+C;
132-301 . A = B-C;
132-302 . A = B/C;
132-303 . A = B/C;
132-304 .
132-305 . if (A < B)
132-306 . {
132-307 . A = B + C;
132-308 . D = E + F;
132-309 . }
132-310 .
132-311 .
132-312 . if (A lt B)
132-313 . {
132-314 . A = B + C;
132-315 . D = E + F;
132-316 . }
132-317 .
132-318 . A = B*C;
132-319 . A = (float)B + C;
132-320 . A = B*C;
132-321 . A = B+C;
132-322 . A = B*C;
132-323 . A = B*C;
132-324 . A = B+C;
132-325 . A = B*C;
132-326 . A = 0x0001;
132-327 . A = B*C;
132-328 .
132-329 . if (A le B)
132-330 . {
132-331 . A = B + C;
132-332 . D = E + F;
132-333 . }
132-334 .
132-335 .
132-336 . if (A < B)
132-337 . {
132-338 . A = B + C;
132-339 . D = E + F;
132-340 . }
132-341 .
132-342 . A = B*C;
132-343 . A = B/C;
132-344 .
132-345 . if (A le B)
132-346 . {
132-347 . A = B + C;
132-348 . D = E + F;
132-349 . }
132-350 .
132-351 .
132-352 . if (A < = B)
132-353 . {
132-354 . A = B + C;
132-355 . D = E + F;
132-356 . }
132-357 .
132-358 . A = B-C;
132-359 . A = B-C;
132-360 .
132-361 . if (A le B)
132-362 . {
132-363 . A = B + C;
132-364 . D = E + F;
132-365 . }
132-366 .
132-367 . A = B*C;
132-368 . A = B+C;
132-369 . A = B*C;
132-370 . A = B/C;
132-371 .
132-372 . switch (wxp stuff)
132-373 . {
132-374 . case one:
132-375 . {
132-376 . run_this;
132-377 . break;
132-378 . }
132-379 . case two:
132-380 . {
132-381 . run_this;
132-382 . break;
132-383 . }
132-384 . default:
132-385 . {
132-386 . SwError;
132-387 . }
132-388 . }
132-389 .
132-390 . A = B-C;
132-391 . A = 0x0001;
132-392 .
132-393 . if (A < = B)
132-394 . {
132-395 . A = B + C;
132-396 . D = E + F;
132-397 . }
132-398 .
132-399 . A = B/C;
132-400 .
132-401 . if (A == B)
132-402 . {
132-403 . A = B + C;
132-404 . D = E + F;
132-405 . }
132-406 .
132-407 . A = B*C;
132-408 . A = (long)B + C;
132-409 . A = B*C;
132-410 . A = B+C;
132-411 . A = B*C;
132-412 .
132-413 . switch (wxp stuff)
132-414 . {
132-415 . case one:
132-416 . {
132-417 . run_this;
132-418 . break;
132-419 . }
132-420 . case two:
132-421 . {
132-422 . run_this;
132-423 . break;
132-424 . }
132-425 . default:
132-426 . {
132-427 . SwError;
132-428 . }
132-429 . }
132-430 .
132-431 . A = B/C;
132-432 . A = B+C;
132-433 . A = B+C;
132-434 . A = B-C;
132-435 . A = B*C;
132-436 . A = B/C;
132-437 . A = B+C;
132-438 . /* LE SV TOC-3111 this is a wxp-15.2.45 req to enable*/
132-439 . A = B*C;
132-440 . A = B+C;
132-441 . A = B-C;
132-442 . A = B+C;
132-443 . /* LE SV TOC-3112 this is a wxp-15.2.49 req to enable*/
132-444 .
132-445 . if (A < B)
132-446 . {
132-447 . A = B + C;
132-448 . D = E + F;
132-449 . }
132-450 .
132-451 . A = B-C;
132-452 .
132-453 . if (A le B)
132-454 . {
132-455 . A = B + C;
132-456 . D = E + F;
132-457 . }
132-458 .
132-459 .
132-460 . if (A == B)
132-461 . {
132-462 . A = B + C;
132-463 . D = E + F;
132-464 . }
132-465 .
132-466 .
132-467 . if (A < B)
132-468 . {
132-469 . A = B + C;
132-470 . D = E + F;
132-471 . }
132-472 .
132-473 .
132-474 . if (A gt B)
132-475 . {
132-476 . A = B + C;
132-477 . D = E + F;
132-478 . }
132-479 .
132-480 .
132-481 . if (A eq B)
132-482 . {
132-483 . A = B + C;
132-484 . D = E + F;
132-485 . }
132-486 .
132-487 .
132-488 . switch (wxp stuff)
132-489 . {
132-490 . case one:
132-491 . {
132-492 . run_this;
132-493 . break;
132-494 . }
132-495 . case two:
132-496 . {
132-497 . run_this;
132-498 . break;
132-499 . }
132-500 . default:
132-501 . {
132-502 . SwError;
132-503 . }
132-504 . }
132-505 .
132-506 .
132-507 . if (A gt B)
132-508 . {
132-509 . A = B + C;
132-510 . D = E + F;
132-511 . }
132-512 .
132-513 . A = B-C;
132-514 . A = B*C;
132-515 .
132-516 . if (A lt B)
132-517 . {
132-518 . A = B + C;
132-519 . D = E + F;
132-520 . }
132-521 .
132-522 . A = B*C;
132-523 . A = B/C;
132-524 . A = B*C;
132-525 .
132-526 . if (A > = B)
132-527 . {
132-528 . A = B + C;
132-529 . D = E + F;
132-530 . }
132-531 .
132-532 . A = B/C;
132-533 . A = B/C;
132-534 . A = B-C;
132-535 . A = B*C;
132-536 .
132-537 . if (A != B)
132-538 . {
132-539 . A = B + C;
132-540 . D = E + F;
132-541 . }
132-542 .
132-543 .
132-544 . switch (wxp stuff)
132-545 . {
132-546 . case one:
132-547 . {
132-548 . run_this;
132-549 . break;
132-550 . }
132-551 . case two:
132-552 . {
132-553 . run_this;
132-554 . break;
132-555 . }
132-556 . default:
132-557 . {
132-558 . SwError;
132-559 . }
132-560 . }
132-561 .
132-562 . A = B+C;
132-563 . A = B/C;
132-564 . A = B-C;
132-565 . A = B-C;
132-566 .
132-567 . if (A gt B)
132-568 . {
132-569 . A = B + C;
132-570 . D = E + F;
132-571 . }
132-572 .
132-573 . A = B*C;
132-574 . // max LOC 76
132-575 .
132-576 . }
132-577 .
132-578 .
132-579 . /*
132-580 . -----------------------------------------------------------------------------
132-581 . --| NAME: wxp.15.3
132-582 . --|
132-583 . --| ABSTRACT:
132-584 . --| This function does wxp stuff.
132-585 . --|
132-586 . --| RETURNS:
132-587 . --| NONE.
132-588 . --|
132-589 . ----------------------------------------------------------------------------
132-590 . */
132-591 . static void wxp.15.3(void)
132-592 . {
132-593 . A = B-C;
132-594 . A = B+C;
132-595 . A = B-C;
132-596 . A = B*C;
132-597 .
132-598 . if (A != B)
132-599 . {
132-600 . A = B + C;
132-601 . D = E + F;
132-602 . }
132-603 .
132-604 . A = B+C;
132-605 . A = B*C;
132-606 . A = B+C;
132-607 . A = B+C;
132-608 . A = B*C;
132-609 . A = B-C;
132-610 . A = B*C;
132-611 .
132-612 . if (A le B)
132-613 . {
132-614 . A = B + C;
132-615 . D = E + F;
132-616 . }
132-617 .
132-618 .
132-619 . switch (wxp stuff)
132-620 . {
132-621 . case one:
132-622 . {
132-623 . run_this;
132-624 . break;
132-625 . }
132-626 . case two:
132-627 . {
132-628 . run_this;
132-629 . break;
132-630 . }
132-631 . default:
132-632 . {
132-633 . SwError;
132-634 . }
132-635 . }
132-636 .
132-637 . A = B/C;
132-638 . A = B+C;
132-639 . A = B/C;
132-640 .
132-641 . if (A == B)
132-642 . {
132-643 . A = B + C;
132-644 . D = E + F;
132-645 . }
132-646 .
132-647 . A = B/C;
132-648 .
132-649 . if (A le B)
132-650 . {
132-651 . A = B + C;
132-652 . D = E + F;
132-653 . }
132-654 .
132-655 .
132-656 . switch (wxp stuff)
132-657 . {
132-658 . case one:
132-659 . {
132-660 . run_this;
132-661 . break;
132-662 . }
132-663 . case two:
132-664 . {
132-665 . run_this;
132-666 . break;
132-667 . }
132-668 . // missing default
132-669 . }
132-670 .
132-671 . A = B/C;
132-672 .
132-673 . if (A > B)
132-674 . {
132-675 . A = B + C;
132-676 . D = E + F;
132-677 . }
132-678 .
132-679 . A = B/C;
132-680 . A = B+C;
132-681 . // TBD - what do I do now
132-682 .
132-683 . if (A ge B)
132-684 . {
132-685 . A = B + C;
132-686 . D = E + F;
132-687 . }
132-688 .
132-689 . A = B*C;
132-690 . /* LE SV TOC-3113 this is a wxp-15.3.27 req to inhibit*/
132-691 .
132-692 . if (A < B)
132-693 . {
132-694 . A = B + C;
132-695 . D = E + F;
132-696 . }
132-697 .
132-698 .
132-699 . if (A != B)
132-700 . {
132-701 . A = B + C;
132-702 . D = E + F;
132-703 . }
132-704 .
132-705 .
132-706 . if (A > = B)
132-707 . {
132-708 . A = B + C;
132-709 . D = E + F;
132-710 . }
132-711 .
132-712 .
132-713 . if (A != B)
132-714 . {
132-715 . A = B + C;
132-716 . D = E + F;
132-717 . }
132-718 .
132-719 . A = B/C;
132-720 . A = B+C;
132-721 . // max LOC 32
132-722 .
132-723 . }
132-724 .
132-725 .
132-726 . /*
132-727 . -----------------------------------------------------------------------------
132-728 . --| NAME: wxp.15.4
132-729 . --|
132-730 . --| ABSTRACT:
132-731 . --| This function does wxp stuff.
132-732 . --|
132-733 . --| RETURNS:
132-734 . --| NONE.
132-735 . --|
132-736 . ----------------------------------------------------------------------------
132-737 . */
132-738 . static void wxp.15.4(void)
132-739 . {
132-740 . A = B/C;
132-741 . A = B+C;
132-742 . A = B/C;
132-743 .
132-744 . if (A > = B)
132-745 . {
132-746 . A = B + C;
132-747 . D = E + F;
132-748 . }
132-749 .
132-750 . A = B/C;
132-751 . A = B*C;
132-752 . /* LE SV TOC-3114 this is a wxp-15.4.7 req to store*/
132-753 . A = B-C;
132-754 .
132-755 . if (A eq B)
132-756 . {
132-757 . A = B + C;
132-758 . D = E + F;
132-759 . }
132-760 .
132-761 .
132-762 . switch (wxp stuff)
132-763 . {
132-764 . case:
132-765 . case:
132-766 . // stacked case statements but only if there is a new line in between
132-767 .
132-768 . case:
132-769 . case:
132-770 . case:
132-771 . {
132-772 . run_this;
132-773 . break;
132-774 . }
132-775 . default:
132-776 . {
132-777 . halt;
132-778 . }
132-779 . }
132-780 .
132-781 .
132-782 . if (A gt B)
132-783 . {
132-784 . A = B + C;
132-785 . D = E + F;
132-786 . }
132-787 .
132-788 . A = B/C;
132-789 . A = B*C;
132-790 . A = B-C;
132-791 . A = B-C;
132-792 . A = B-C;
132-793 . A = B/C;
132-794 . A = 0x0004;
132-795 . A = B+C;
132-796 .
132-797 . if (A == B)
132-798 . {
132-799 . A = B + C;
132-800 . D = E + F;
132-801 . }
132-802 .
132-803 . A = B-C;
132-804 . A = B*C;
132-805 .
132-806 . if (A == B)
132-807 . {
132-808 . A = B + C;
132-809 . D = E + F;
132-810 . }
132-811 .
132-812 .
132-813 . if (A gt B)
132-814 . {
132-815 . A = B + C;
132-816 . D = E + F;
132-817 . }
132-818 .
132-819 . A = B*C;
132-820 .
132-821 . if (A == B)
132-822 . {
132-823 . A = B + C;
132-824 . D = E + F;
132-825 . }
132-826 .
132-827 . A = B-C;
132-828 . A = B+C;
132-829 .
132-830 . if (A > B)
132-831 . {
132-832 . A = B + C;
132-833 . D = E + F;
132-834 . }
132-835 .
132-836 .
132-837 . if (A ne B)
132-838 . {
132-839 . A = B + C;
132-840 . D = E + F;
132-841 . }
132-842 .
132-843 . A = B*C;
132-844 .
132-845 . if (A > = B)
132-846 . {
132-847 . A = B + C;
132-848 . D = E + F;
132-849 . }
132-850 .
132-851 . A = B/C;
132-852 . A = B/C;
132-853 . A = B+C;
132-854 .
132-855 . if (A < B)
132-856 . {
132-857 . A = B + C;
132-858 . D = E + F;
132-859 . }
132-860 .
132-861 . // max LOC 33
132-862 .
132-863 . }
132-864 .
132 132 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-15.c
133 133 Source: source/ft-app/ft-app-B1.0/wxp/wxp-16.c
133-0 . /*
133-1 . ----------------------------------------------------------------------------
133-2 . --| BEGIN PROLOGUE
133-3 . --|
133-4 . --| CLASSIFICATION: UNCLASSIFIED
133-5 . --|
133-6 . --| FILE NAME: wxp-16.c
133-7 . --|
133-8 . --| ABSTRACT:
133-9 . --| This file contains the 1 functions that do file wxp stuff.
133-10 . --|
133-11 . --| HISTORY:
133-12 . --| CCCQ_NAME:
133-13 . --| CCCQ_VER:
133-14 . --|
133-15 . --| END PROLOGUE
133-16 . ----------------------------------------------------------------------------
133-17 . */
133-18 .
133-19 . #define B;
133-20 . double C;
133-21 . float B;
133-22 . int A;
133-23 .
133-24 .
133-25 .
133-26 . /*
133-27 . -----------------------------------------------------------------------------
133-28 . --| NAME: wxp.16.1
133-29 . --|
133-30 . --| ABSTRACT:
133-31 . --| This function does wxp stuff.
133-32 . --|
133-33 . --| RETURNS:
133-34 . --| NONE.
133-35 . --|
133-36 . ----------------------------------------------------------------------------
133-37 . */
133-38 . static void wxp.16.1(void)
133-39 . {
133-40 . A = B*C;
133-41 . A = B/C;
133-42 . A = B-C;
133-43 .
133-44 . if (A lt B)
133-45 . {
133-46 . A = B + C;
133-47 . D = E + F;
133-48 . }
133-49 .
133-50 .
133-51 . if (A < = B)
133-52 . {
133-53 . A = B + C;
133-54 . D = E + F;
133-55 . }
133-56 .
133-57 .
133-58 . if (A > = B)
133-59 . {
133-60 . A = B + C;
133-61 . D = E + F;
133-62 . }
133-63 .
133-64 . A = B/C;
133-65 . A = B*C;
133-66 .
133-67 . if (A != B)
133-68 . {
133-69 . A = B + C;
133-70 . D = E + F;
133-71 . }
133-72 .
133-73 . A = B-C;
133-74 . A = B+C;
133-75 . A = B+C;
133-76 . A = B*C;
133-77 . A = 0x0009;
133-78 . A = B+C;
133-79 . A = B+C;
133-80 . A = B*C;
133-81 . A = B+C;
133-82 . A = B-C;
133-83 . A = B*C;
133-84 .
133-85 . if (A > B)
133-86 . {
133-87 . A = B + C;
133-88 . D = E + F;
133-89 . }
133-90 .
133-91 . A = B+C;
133-92 . A = B+C;
133-93 . A = B-C;
133-94 . A = B+C;
133-95 . A = B-C;
133-96 . A = B-C;
133-97 . A = B*C;
133-98 . A = B/C;
133-99 .
133-100 . if (A > B)
133-101 . {
133-102 . A = B + C;
133-103 . D = E + F;
133-104 . }
133-105 .
133-106 . A = B+C;
133-107 .
133-108 . if (A < B)
133-109 . {
133-110 . A = B + C;
133-111 . D = E + F;
133-112 . }
133-113 .
133-114 . A = B-C;
133-115 . A = 0x0002;
133-116 . A = B/C;
133-117 .
133-118 . if (A < B)
133-119 . {
133-120 . A = B + C;
133-121 . D = E + F;
133-122 . }
133-123 .
133-124 .
133-125 . if (A ge B)
133-126 . {
133-127 . A = B + C;
133-128 . D = E + F;
133-129 . }
133-130 .
133-131 . A = B/C;
133-132 . // max LOC 36
133-133 .
133-134 . }
133-135 .
133 133 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-16.c
134 134 Source: source/ft-app/ft-app-B1.0/wxp/wxp-17.c
134-0 . /*
134-1 . ----------------------------------------------------------------------------
134-2 . --| BEGIN PROLOGUE
134-3 . --|
134-4 . --| CLASSIFICATION: UNCLASSIFIED
134-5 . --|
134-6 . --| FILE NAME: wxp-17.c
134-7 . --|
134-8 . --| ABSTRACT:
134-9 . --| This file contains the 4 functions that do file wxp stuff.
134-10 . --|
134-11 . --| HISTORY:
134-12 . --| CCCQ_NAME:
134-13 . --| CCCQ_VER:
134-14 . --|
134-15 . --| END PROLOGUE
134-16 . ----------------------------------------------------------------------------
134-17 . */
134-18 .
134-19 . #define B;
134-20 . char D;
134-21 . #include B;
134-22 . char D;
134-23 .
134-24 .
134-25 .
134-26 . /*
134-27 . -----------------------------------------------------------------------------
134-28 . --| NAME: wxp.17.1
134-29 . --|
134-30 . --| ABSTRACT:
134-31 . --| This function does wxp stuff.
134-32 . --|
134-33 . --| RETURNS:
134-34 . --| NONE.
134-35 . --|
134-36 . ----------------------------------------------------------------------------
134-37 . */
134-38 . static void wxp.17.1(void)
134-39 . {
134-40 . A = B-C;
134-41 . A = B*C;
134-42 . A = B/C;
134-43 . A = B-C;
134-44 . A = B-C;
134-45 . A = B/C;
134-46 . rcv_buffer = (U16 *) alloc(size+1);
134-47 . A = B*C;
134-48 .
134-49 . if (A ge B)
134-50 . {
134-51 . A = B + C;
134-52 . D = E + F;
134-53 . }
134-54 .
134-55 .
134-56 . if (A ne B)
134-57 . {
134-58 . A = B + C;
134-59 . D = E + F;
134-60 . }
134-61 .
134-62 . A = B-C;
134-63 . A = B/C;
134-64 . A = B+C;
134-65 . /* LE SV TOC-3115 this is a wxp-17.1.13 req to halt*/
134-66 . A = B/C;
134-67 .
134-68 . if (A < B)
134-69 . {
134-70 . A = B + C;
134-71 . D = E + F;
134-72 . }
134-73 .
134-74 .
134-75 . if (A ge B)
134-76 . {
134-77 . A = B + C;
134-78 . D = E + F;
134-79 . }
134-80 .
134-81 . A = B*C;
134-82 .
134-83 . if ($wxp stuff > $otherwxp stuff)
134-84 . /* LE SV TOC-008 we really should log all error calls */
134-85 . {
134-86 . A = B + C;
134-87 . }
134-88 .
134-89 . A = B/C;
134-90 . A = B*C;
134-91 . A = B/C;
134-92 . A = B+C;
134-93 .
134-94 . if (A > B)
134-95 . {
134-96 . A = B + C;
134-97 . D = E + F;
134-98 . }
134-99 .
134-100 . A = 0x0006;
134-101 . A = B-C;
134-102 .
134-103 . if (A le B)
134-104 . {
134-105 . A = B + C;
134-106 . D = E + F;
134-107 . }
134-108 .
134-109 .
134-110 . if (A == B)
134-111 . {
134-112 . A = B + C;
134-113 . D = E + F;
134-114 . }
134-115 .
134-116 . A = B+C;
134-117 . A = B*C;
134-118 . A = B/C;
134-119 . A = B-C;
134-120 . A = B+C;
134-121 . A = B+C;
134-122 . A = B-C;
134-123 . A = B*C;
134-124 . A = B-C;
134-125 . A = B*C;
134-126 . A = B*C;
134-127 . A = B*C;
134-128 . A = B/C;
134-129 . A = B+C;
134-130 . A = B*C;
134-131 . do forever;
134-132 .
134-133 . if (A ne B)
134-134 . {
134-135 . A = B + C;
134-136 . D = E + F;
134-137 . }
134-138 .
134-139 . A = B/C;
134-140 . A = B*C;
134-141 . A = B*C;
134-142 . A = (int)B + C;
134-143 . A = B-C;
134-144 . A = B*C;
134-145 .
134-146 . if (A lt B)
134-147 . {
134-148 . A = B + C;
134-149 . D = E + F;
134-150 . }
134-151 .
134-152 . A = B/C;
134-153 .
134-154 . if (A ne B)
134-155 . {
134-156 . A = B + C;
134-157 . D = E + F;
134-158 . }
134-159 .
134-160 . A = B/C;
134-161 . A = B-C;
134-162 .
134-163 . if (A le B)
134-164 . {
134-165 . A = B + C;
134-166 . D = E + F;
134-167 . }
134-168 .
134-169 . A = B*C;
134-170 . // max LOC 52
134-171 .
134-172 . }
134-173 .
134-174 .
134-175 . /*
134-176 . -----------------------------------------------------------------------------
134-177 . --| NAME: wxp.17.2
134-178 . --|
134-179 . --| ABSTRACT:
134-180 . --| This function does wxp stuff.
134-181 . --|
134-182 . --| RETURNS:
134-183 . --| NONE.
134-184 . --|
134-185 . ----------------------------------------------------------------------------
134-186 . */
134-187 . static void wxp.17.2(void)
134-188 . {
134-189 . A = B*C;
134-190 . A = B+C;
134-191 . A = B+C;
134-192 .
134-193 . if (A > B)
134-194 . {
134-195 . A = B + C;
134-196 . D = E + F;
134-197 . }
134-198 .
134-199 . A = B-C;
134-200 .
134-201 . if (A > = B)
134-202 . {
134-203 . A = B + C;
134-204 . D = E + F;
134-205 . }
134-206 .
134-207 .
134-208 . if (A < = B)
134-209 . {
134-210 . A = B + C;
134-211 . D = E + F;
134-212 . }
134-213 .
134-214 .
134-215 . if (A ge B)
134-216 . {
134-217 . A = B + C;
134-218 . D = E + F;
134-219 . }
134-220 .
134-221 .
134-222 . /*
134-223 . dead_block = C * D;
134-224 . dead_block = E * F;
134-225 . */
134-226 .
134-227 .
134-228 . if (A gt B)
134-229 . {
134-230 . A = B + C;
134-231 . D = E + F;
134-232 . }
134-233 .
134-234 .
134-235 . if (A > B)
134-236 . {
134-237 . A = B + C;
134-238 . D = E + F;
134-239 . }
134-240 .
134-241 . A = B*C;
134-242 . A = B/C;
134-243 . A = B/C;
134-244 .
134-245 . if (A > B)
134-246 . {
134-247 . A = B + C;
134-248 . D = E + F;
134-249 . }
134-250 .
134-251 . A = B-C;
134-252 . A = B/C;
134-253 . A = B*C;
134-254 . A = B-C;
134-255 .
134-256 . if (A < = B)
134-257 . {
134-258 . A = B + C;
134-259 . D = E + F;
134-260 . }
134-261 .
134-262 .
134-263 . if (A != B)
134-264 . {
134-265 . A = B + C;
134-266 . D = E + F;
134-267 . }
134-268 .
134-269 . A = B/C;
134-270 .
134-271 . if (A < = B)
134-272 . {
134-273 . A = B + C;
134-274 . D = E + F;
134-275 . }
134-276 .
134-277 . A = B-C;
134-278 . A = B*C;
134-279 .
134-280 . if (A == B)
134-281 . {
134-282 . A = B + C;
134-283 . D = E + F;
134-284 . }
134-285 .
134-286 . A = B/C;
134-287 . A = B/C;
134-288 .
134-289 . if (A lt B)
134-290 . {
134-291 . A = B + C;
134-292 . D = E + F;
134-293 . }
134-294 .
134-295 . A = B-C;
134-296 . A = B/C;
134-297 . A = B*C;
134-298 . /* LE SV TOC-3116 this is a wxp-17.2.32 req to halt*/
134-299 . A = B/C;
134-300 . A = B/C;
134-301 .
134-302 . if (A lt B)
134-303 . {
134-304 . A = B + C;
134-305 . D = E + F;
134-306 . }
134-307 .
134-308 . A = (long)B + C;
134-309 . A = B*C;
134-310 . A = B/C;
134-311 . A = B/C;
134-312 . A = B*C;
134-313 . A = 0x0008;
134-314 . A = B*C;
134-315 . A = B/C;
134-316 . A = B+C;
134-317 . A = B*C;
134-318 . A = B/C;
134-319 .
134-320 . if (A ne B)
134-321 . {
134-322 . A = B + C;
134-323 . D = E + F;
134-324 . }
134-325 .
134-326 . A = B-C;
134-327 . // max LOC 45
134-328 .
134-329 . }
134-330 .
134-331 .
134-332 . /*
134-333 . -----------------------------------------------------------------------------
134-334 . --| NAME: wxp.17.3
134-335 . --|
134-336 . --| ABSTRACT:
134-337 . --| This function does wxp stuff.
134-338 . --|
134-339 . --| RETURNS:
134-340 . --| NONE.
134-341 . --|
134-342 . ----------------------------------------------------------------------------
134-343 . */
134-344 . static void wxp.17.3(void)
134-345 . {
134-346 . A = B*C;
134-347 .
134-348 . if (A gt B)
134-349 . {
134-350 . A = B + C;
134-351 . D = E + F;
134-352 . }
134-353 .
134-354 . A = B/C;
134-355 . A = B/C;
134-356 . A = B+C;
134-357 . /* LE SV TOC-3117 this is a wxp-17.3.6 req to check pSOS*/
134-358 .
134-359 . switch (wxp stuff)
134-360 . {
134-361 . case one:
134-362 . {
134-363 . run_this;
134-364 . break;
134-365 . }
134-366 . case two:
134-367 . {
134-368 . run_this;
134-369 . break;
134-370 . }
134-371 . default:
134-372 . {
134-373 . SwError;
134-374 . }
134-375 . }
134-376 .
134-377 . A = B-C;
134-378 . A = B-C;
134-379 . A = B-C;
134-380 .
134-381 . if (A gt B)
134-382 . {
134-383 . A = B + C;
134-384 . D = E + F;
134-385 . }
134-386 .
134-387 . A = B-C;
134-388 . A = B*C;
134-389 .
134-390 . if (A > = B)
134-391 . {
134-392 . A = B + C;
134-393 . D = E + F;
134-394 . }
134-395 .
134-396 . A = B+C;
134-397 . A = B*C;
134-398 . /* LE SV TOC-3118 this is a wxp-17.3.16 req to halt*/
134-399 .
134-400 . if (A lt B)
134-401 . {
134-402 . A = B + C;
134-403 . D = E + F;
134-404 . }
134-405 .
134-406 . A = B*C;
134-407 . A = B-C;
134-408 . A = B/C;
134-409 .
134-410 . if (A > B)
134-411 . {
134-412 . A = B + C;
134-413 . D = E + F;
134-414 . }
134-415 .
134-416 .
134-417 . if (A < = B)
134-418 . {
134-419 . A = B + C;
134-420 . D = E + F;
134-421 . }
134-422 .
134-423 .
134-424 . /* dead_code = B + C;
134-425 . dead_code = D + E;
134-426 . dead_code = F + G; */
134-427 .
134-428 . A = B+C;
134-429 . /* LE SV TOC-3119 this is a wxp-17.3.23 req to process*/
134-430 .
134-431 . if (A ne B)
134-432 . {
134-433 . A = B + C;
134-434 . D = E + F;
134-435 . }
134-436 .
134-437 . A = B-C;
134-438 . A = B/C;
134-439 . A = B*C;
134-440 .
134-441 . if (A lt B)
134-442 . {
134-443 . A = B + C;
134-444 . D = E + F;
134-445 . }
134-446 .
134-447 . A = B/C;
134-448 . A = B/C;
134-449 . A = B*C;
134-450 . A = B/C;
134-451 . A = B/C;
134-452 . A = B/C;
134-453 . A = B/C;
134-454 . A = B*C;
134-455 .
134-456 . if (A < B)
134-457 . {
134-458 . A = B + C;
134-459 . D = E + F;
134-460 . }
134-461 .
134-462 . A = B-C;
134-463 .
134-464 . if (A > B)
134-465 . {
134-466 . A = B + C;
134-467 . D = E + F;
134-468 . }
134-469 .
134-470 .
134-471 . if (A le B)
134-472 . {
134-473 . A = B + C;
134-474 . D = E + F;
134-475 . }
134-476 .
134-477 .
134-478 . if (A < B)
134-479 . {
134-480 . A = B + C;
134-481 . D = E + F;
134-482 . }
134-483 .
134-484 .
134-485 . if (A < = B)
134-486 . {
134-487 . A = B + C;
134-488 . D = E + F;
134-489 . }
134-490 .
134-491 . // max LOC 41
134-492 .
134-493 . }
134-494 .
134-495 .
134-496 . /*
134-497 . -----------------------------------------------------------------------------
134-498 . --| NAME: wxp.17.4
134-499 . --|
134-500 . --| ABSTRACT:
134-501 . --| This function does wxp stuff.
134-502 . --|
134-503 . --| RETURNS:
134-504 . --| NONE.
134-505 . --|
134-506 . ----------------------------------------------------------------------------
134-507 . */
134-508 . static void wxp.17.4(void)
134-509 . {
134-510 . A = B*C;
134-511 .
134-512 . if (A > = B)
134-513 . {
134-514 . A = B + C;
134-515 . D = E + F;
134-516 . }
134-517 .
134-518 . A = B/C;
134-519 . A = B-C;
134-520 .
134-521 . /* dead_code = B + C;
134-522 . dead_code = D + E;
134-523 . dead_code = F + G; */
134-524 .
134-525 . A = B/C;
134-526 .
134-527 . if (A > B)
134-528 . {
134-529 . A = B + C;
134-530 . D = E + F;
134-531 . }
134-532 .
134-533 . A = B*C;
134-534 .
134-535 . if (A lt B)
134-536 . {
134-537 . A = B + C;
134-538 . D = E + F;
134-539 . }
134-540 .
134-541 .
134-542 . if (A gt B)
134-543 . {
134-544 . A = B + C;
134-545 . D = E + F;
134-546 . }
134-547 .
134-548 . A = B+C;
134-549 . A = B*C;
134-550 . A = B*C;
134-551 .
134-552 . if (A > = B)
134-553 . {
134-554 . A = B + C;
134-555 . D = E + F;
134-556 . }
134-557 .
134-558 . A = B-C;
134-559 . A = B+C;
134-560 .
134-561 . if (A eq B)
134-562 . {
134-563 . A = B + C;
134-564 . D = E + F;
134-565 . }
134-566 .
134-567 . /* LE SV TOC-3120 this is a wxp-17.4.17 req to record*/
134-568 .
134-569 . if (A > B)
134-570 . {
134-571 . A = B + C;
134-572 . D = E + F;
134-573 . }
134-574 .
134-575 . A = B*C;
134-576 . A = B-C;
134-577 . A = B*C;
134-578 .
134-579 . if (A ne B)
134-580 . {
134-581 . A = B + C;
134-582 . D = E + F;
134-583 . }
134-584 .
134-585 . A = B+C;
134-586 . A = B/C;
134-587 .
134-588 . if (A gt B)
134-589 . {
134-590 . A = B + C;
134-591 . D = E + F;
134-592 . }
134-593 .
134-594 . A = B+C;
134-595 . A = B+C;
134-596 . A = B-C;
134-597 . A = B-C;
134-598 . A = B-C;
134-599 .
134-600 . if (A gt B)
134-601 . {
134-602 . A = B + C;
134-603 . D = E + F;
134-604 . }
134-605 .
134-606 . A = B/C;
134-607 .
134-608 . if (A > = B)
134-609 . {
134-610 . A = B + C;
134-611 . D = E + F;
134-612 . }
134-613 .
134-614 . A = 0x0006;
134-615 . A = B+C;
134-616 . // max LOC 33
134-617 .
134-618 . }
134-619 .
134 134 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-17.c
135 135 Source: source/ft-app/ft-app-B1.0/wxp/wxp-18.c
135-0 . /*
135-1 . ----------------------------------------------------------------------------
135-2 . --| BEGIN PROLOGUE
135-3 . --|
135-4 . --| CLASSIFICATION: UNCLASSIFIED
135-5 . --|
135-6 . --| FILE NAME: wxp-18.c
135-7 . --|
135-8 . --| ABSTRACT:
135-9 . --| This file contains the 2 functions that do file wxp stuff.
135-10 . --|
135-11 . --| HISTORY:
135-12 . --| CCCQ_NAME:
135-13 . --| CCCQ_VER:
135-14 . --|
135-15 . --| END PROLOGUE
135-16 . ----------------------------------------------------------------------------
135-17 . */
135-18 .
135-19 . #include A;
135-20 . double C;
135-21 .
135-22 .
135-23 .
135-24 . /*
135-25 . -----------------------------------------------------------------------------
135-26 . --| NAME: wxp.18.1
135-27 . --|
135-28 . --| ABSTRACT:
135-29 . --| This function does wxp stuff.
135-30 . --|
135-31 . --| RETURNS:
135-32 . --| NONE.
135-33 . --|
135-34 . ----------------------------------------------------------------------------
135-35 . */
135-36 . static void wxp.18.1(void)
135-37 . {
135-38 .
135-39 . /*
135-40 . dead_code = B - C;
135-41 . dead_code = D - E;
135-42 . dead_code = F - G;
135-43 . */
135-44 .
135-45 . A = B-C;
135-46 . A = B+C;
135-47 . A = B+C;
135-48 .
135-49 . switch (wxp stuff)
135-50 . {
135-51 . case one:
135-52 . {
135-53 . run_this;
135-54 . break;
135-55 . }
135-56 . case two:
135-57 . {
135-58 . run_this;
135-59 . break;
135-60 . }
135-61 . default:
135-62 . {
135-63 . SwError;
135-64 . }
135-65 . }
135-66 .
135-67 . A = B+C;
135-68 .
135-69 . if (A > = B)
135-70 . {
135-71 . A = B + C;
135-72 . D = E + F;
135-73 . }
135-74 .
135-75 . A = B*C;
135-76 .
135-77 . if (A ne B)
135-78 . {
135-79 . A = B + C;
135-80 . D = E + F;
135-81 . }
135-82 .
135-83 .
135-84 . if (A ne B)
135-85 . {
135-86 . A = B + C;
135-87 . D = E + F;
135-88 . }
135-89 .
135-90 . free(FreePtr);
135-91 .
135-92 . if (A gt B)
135-93 . {
135-94 . A = B + C;
135-95 . D = E + F;
135-96 . }
135-97 .
135-98 . A = B/C;
135-99 . A = B+C;
135-100 .
135-101 . if (A eq B)
135-102 . {
135-103 . A = B + C;
135-104 . D = E + F;
135-105 . }
135-106 .
135-107 . A = B*C;
135-108 .
135-109 . if (A < = B)
135-110 . {
135-111 . A = B + C;
135-112 . D = E + F;
135-113 . }
135-114 .
135-115 . A = B/C;
135-116 . send_buffer = (U16 *) malloc(size+1);
135-117 . A = B*C;
135-118 . A = B-C;
135-119 . /* LE SV TOC-3121 this is a wxp-18.1.19 req to record*/
135-120 . A = B/C;
135-121 . A = B+C;
135-122 .
135-123 . if (A < B)
135-124 . {
135-125 . A = B + C;
135-126 . D = E + F;
135-127 . }
135-128 .
135-129 . A = B*C;
135-130 . /* LE SV TOC-3122 this is a wxp-18.1.23 req to translate*/
135-131 . A = B-C;
135-132 .
135-133 . if (A == B)
135-134 . {
135-135 . A = B + C;
135-136 . D = E + F;
135-137 . }
135-138 .
135-139 .
135-140 . if (A eq B)
135-141 . {
135-142 . A = B + C;
135-143 . D = E + F;
135-144 . }
135-145 .
135-146 .
135-147 . if (A != B)
135-148 . {
135-149 . A = B + C;
135-150 . D = E + F;
135-151 . }
135-152 .
135-153 .
135-154 . if (A > B)
135-155 . {
135-156 . A = B + C;
135-157 . D = E + F;
135-158 . }
135-159 .
135-160 . A = B+C;
135-161 . A = B-C;
135-162 . A = B/C;
135-163 . A = B/C;
135-164 . A = B/C;
135-165 . A = B*C;
135-166 . A = B+C;
135-167 . A = B*C;
135-168 . A = B+C;
135-169 . A = B+C;
135-170 .
135-171 . if (A ge B)
135-172 . {
135-173 . A = B + C;
135-174 . D = E + F;
135-175 . }
135-176 .
135-177 .
135-178 . if (A > B)
135-179 . {
135-180 . A = B + C;
135-181 . D = E + F;
135-182 . }
135-183 .
135-184 . A = B-C;
135-185 . A = B-C;
135-186 . A = B/C;
135-187 .
135-188 . switch (wxp stuff)
135-189 . {
135-190 . case one:
135-191 . {
135-192 . run_this;
135-193 . break;
135-194 . }
135-195 . case two:
135-196 . {
135-197 . run_this;
135-198 . break;
135-199 . }
135-200 . default:
135-201 . {
135-202 . SwError;
135-203 . }
135-204 . }
135-205 .
135-206 . A = B/C;
135-207 .
135-208 . if (A > = B)
135-209 . {
135-210 . A = B + C;
135-211 . D = E + F;
135-212 . }
135-213 .
135-214 . A = B+C;
135-215 .
135-216 . switch (wxp stuff)
135-217 . {
135-218 . case one:
135-219 . {
135-220 . run_this;
135-221 . break;
135-222 . }
135-223 . case two:
135-224 . {
135-225 . run_this;
135-226 . break;
135-227 . }
135-228 . default:
135-229 . {
135-230 . SwError;
135-231 . }
135-232 . }
135-233 .
135-234 .
135-235 . if (A > B)
135-236 . {
135-237 . A = B + C;
135-238 . D = E + F;
135-239 . }
135-240 .
135-241 . A = B*C;
135-242 .
135-243 . if (A != B)
135-244 . {
135-245 . A = B + C;
135-246 . D = E + F;
135-247 . }
135-248 .
135-249 . A = B+C;
135-250 . A = B+C;
135-251 . A = B+C;
135-252 .
135-253 . if (A ge B)
135-254 . {
135-255 . A = B + C;
135-256 . D = E + F;
135-257 . }
135-258 .
135-259 .
135-260 . if (A < B)
135-261 . {
135-262 . A = B + C;
135-263 . D = E + F;
135-264 . }
135-265 .
135-266 . A = B*C;
135-267 .
135-268 . if (A != B)
135-269 . {
135-270 . A = B + C;
135-271 . D = E + F;
135-272 . }
135-273 .
135-274 . A = B-C;
135-275 . A = B+C;
135-276 . A = B/C;
135-277 . A = B*C;
135-278 .
135-279 . if (A < B)
135-280 . {
135-281 . A = B + C;
135-282 . D = E + F;
135-283 . }
135-284 .
135-285 . A = B*C;
135-286 .
135-287 . if (A ge B)
135-288 . {
135-289 . A = B + C;
135-290 . D = E + F;
135-291 . }
135-292 .
135-293 . A = B-C;
135-294 . A = B-C;
135-295 . A = B-C;
135-296 . A = B+C;
135-297 . A = B/C;
135-298 .
135-299 . if (A > B)
135-300 . {
135-301 . A = B + C;
135-302 . D = E + F;
135-303 . }
135-304 .
135-305 . A = B+C;
135-306 . A = B*C;
135-307 .
135-308 . if (A eq B)
135-309 . {
135-310 . A = B + C;
135-311 . D = E + F;
135-312 . }
135-313 .
135-314 . A = B-C;
135-315 . A = B*C;
135-316 . A = B+C;
135-317 . A = B/C;
135-318 . A = B-C;
135-319 .
135-320 . if (A < = B)
135-321 . {
135-322 . A = B + C;
135-323 . D = E + F;
135-324 . }
135-325 .
135-326 . A = B*C;
135-327 .
135-328 . if (A lt B)
135-329 . {
135-330 . A = B + C;
135-331 . D = E + F;
135-332 . }
135-333 .
135-334 . A = B-C;
135-335 . A = B/C;
135-336 . A = B+C;
135-337 . A = B/C;
135-338 . A = B*C;
135-339 .
135-340 . if (A < B)
135-341 . {
135-342 . A = B + C;
135-343 . D = E + F;
135-344 . }
135-345 .
135-346 . /* LE SV TOC-3123 this is a wxp-18.1.88 req to set RTC*/
135-347 . A = B/C;
135-348 . A = B*C;
135-349 . /* LE SV TOC-3124 this is a wxp-18.1.90 req to enable*/
135-350 .
135-351 . if (A > = B)
135-352 . {
135-353 . A = B + C;
135-354 . D = E + F;
135-355 . }
135-356 .
135-357 . A = B+C;
135-358 .
135-359 . if (A < = B)
135-360 . {
135-361 . A = B + C;
135-362 . D = E + F;
135-363 . }
135-364 .
135-365 . A = B/C;
135-366 . A = B*C;
135-367 . // max LOC 94
135-368 .
135-369 . }
135-370 .
135-371 .
135-372 . /*
135-373 . -----------------------------------------------------------------------------
135-374 . --| NAME: wxp.18.2
135-375 . --|
135-376 . --| ABSTRACT:
135-377 . --| This function does wxp stuff.
135-378 . --|
135-379 . --| RETURNS:
135-380 . --| NONE.
135-381 . --|
135-382 . ----------------------------------------------------------------------------
135-383 . */
135-384 . static void wxp.18.2(void)
135-385 . {
135-386 .
135-387 . if (A > = B)
135-388 . {
135-389 . A = B + C;
135-390 . D = E + F;
135-391 . }
135-392 .
135-393 . A = B/C;
135-394 . A = B+C;
135-395 .
135-396 . if (A ne B)
135-397 . {
135-398 . A = B + C;
135-399 . D = E + F;
135-400 . }
135-401 .
135-402 . A = B*C;
135-403 .
135-404 . if (A ge B)
135-405 . {
135-406 . A = B + C;
135-407 . D = E + F;
135-408 . }
135-409 .
135-410 . A = B*C;
135-411 . A = B*C;
135-412 . A = B-C;
135-413 . A = B/C;
135-414 .
135-415 . if (A ge B)
135-416 . {
135-417 . A = B + C;
135-418 . D = E + F;
135-419 . }
135-420 .
135-421 . A = B+C;
135-422 . A = B-C;
135-423 . A = B+C;
135-424 . A = 0x0009;
135-425 .
135-426 . if ($wxp stuff > $otherwxp stuff)
135-427 . /* LE SV TOC-008 we really should log all error calls */
135-428 . {
135-429 . A = B + C;
135-430 . }
135-431 .
135-432 .
135-433 . if (A eq B)
135-434 . {
135-435 . A = B + C;
135-436 . D = E + F;
135-437 . }
135-438 .
135-439 . A = B/C;
135-440 . A = B+C;
135-441 . A = B-C;
135-442 . A = B/C;
135-443 . A = B-C;
135-444 . A = B*C;
135-445 .
135-446 . switch (wxp stuff)
135-447 . {
135-448 . case one:
135-449 . {
135-450 . run_this;
135-451 . break;
135-452 . }
135-453 . case two:
135-454 . {
135-455 . run_this;
135-456 . break;
135-457 . }
135-458 . default:
135-459 . {
135-460 . SwError;
135-461 . }
135-462 . }
135-463 .
135-464 . A = B+C;
135-465 . A = B*C;
135-466 . A = B-C;
135-467 . A = B/C;
135-468 . A = B-C;
135-469 . A = B*C;
135-470 . A = B/C;
135-471 . A = B/C;
135-472 . A = B-C;
135-473 .
135-474 . switch (wxp stuff)
135-475 . {
135-476 . case one:
135-477 . {
135-478 . run_this;
135-479 . break;
135-480 . }
135-481 . case two:
135-482 . {
135-483 . run_this;
135-484 . break;
135-485 . }
135-486 . // missing default
135-487 . }
135-488 .
135-489 . A = B-C;
135-490 . A = B/C;
135-491 . A = B/C;
135-492 . A = 0x0002;
135-493 .
135-494 . if (A le B)
135-495 . {
135-496 . A = B + C;
135-497 . D = E + F;
135-498 . }
135-499 .
135-500 . A = B/C;
135-501 . A = B+C;
135-502 .
135-503 . /* dead_code = B + C;
135-504 . dead_code = D + E;
135-505 . dead_code = F + G; */
135-506 .
135-507 . A = B+C;
135-508 .
135-509 . if (A gt B)
135-510 . {
135-511 . A = B + C;
135-512 . D = E + F;
135-513 . }
135-514 .
135-515 .
135-516 . if (A > = B)
135-517 . {
135-518 . A = B + C;
135-519 . D = E + F;
135-520 . }
135-521 .
135-522 . A = B+C;
135-523 . // max LOC 41
135-524 .
135-525 . }
135-526 .
135 135 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-18.c
136 136 Source: source/ft-app/ft-app-B1.0/wxp/wxp-19.c
136-0 . /*
136-1 . ----------------------------------------------------------------------------
136-2 . --| BEGIN PROLOGUE
136-3 . --|
136-4 . --| CLASSIFICATION: UNCLASSIFIED
136-5 . --|
136-6 . --| FILE NAME: wxp-19.c
136-7 . --|
136-8 . --| ABSTRACT:
136-9 . --| This file contains the 7 functions that do file wxp stuff.
136-10 . --|
136-11 . --| HISTORY:
136-12 . --| CCCQ_NAME:
136-13 . --| CCCQ_VER:
136-14 . --|
136-15 . --| END PROLOGUE
136-16 . ----------------------------------------------------------------------------
136-17 . */
136-18 .
136-19 . #define C;
136-20 . #include D;
136-21 . int A;
136-22 . int A;
136-23 . #include D;
136-24 .
136-25 .
136-26 .
136-27 . /*
136-28 . -----------------------------------------------------------------------------
136-29 . --| NAME: wxp.19.1
136-30 . --|
136-31 . --| ABSTRACT:
136-32 . --| This function does wxp stuff.
136-33 . --|
136-34 . --| RETURNS:
136-35 . --| NONE.
136-36 . --|
136-37 . ----------------------------------------------------------------------------
136-38 . */
136-39 . static void wxp.19.1(void)
136-40 . {
136-41 . A = B+C;
136-42 . A = B-C;
136-43 . A = B*C;
136-44 . A = B+C;
136-45 . A = B+C;
136-46 . A = B-C;
136-47 . A = B+C;
136-48 . A = B*C;
136-49 .
136-50 . if (A != B)
136-51 . {
136-52 . A = B + C;
136-53 . D = E + F;
136-54 . }
136-55 .
136-56 . /* LE SV TOC-3125 this is a wxp-19.1.10 req to verify*/
136-57 . A = B-C;
136-58 . A = B*C;
136-59 . A = B-C;
136-60 .
136-61 . if (A > = B)
136-62 . {
136-63 . A = B + C;
136-64 . D = E + F;
136-65 . }
136-66 .
136-67 . A = B/C;
136-68 .
136-69 . if (A != B)
136-70 . {
136-71 . A = B + C;
136-72 . D = E + F;
136-73 . }
136-74 .
136-75 . A = B+C;
136-76 . /* LE SV TOC-3126 this is a wxp-19.1.17 req to record*/
136-77 . A = B+C;
136-78 . A = B-C;
136-79 . A = B/C;
136-80 . A = B*C;
136-81 . A = B*C;
136-82 . A = B+C;
136-83 . goto error;
136-84 .
136-85 . if (A ne B)
136-86 . {
136-87 . A = B + C;
136-88 . D = E + F;
136-89 . }
136-90 .
136-91 . A = B+C;
136-92 . A = B-C;
136-93 .
136-94 . if (A > B)
136-95 . {
136-96 . A = B + C;
136-97 . D = E + F;
136-98 . }
136-99 .
136-100 . A = B/C;
136-101 . A = B-C;
136-102 . /* LE SV TOC-3127 this is a wxp-19.1.29 req to record*/
136-103 . A = B*C;
136-104 .
136-105 . switch (wxp stuff)
136-106 . {
136-107 . case one:
136-108 . {
136-109 . run_this;
136-110 . break;
136-111 . }
136-112 . case two:
136-113 . {
136-114 . run_this;
136-115 . break;
136-116 . }
136-117 . default:
136-118 . {
136-119 . SwError;
136-120 . }
136-121 . }
136-122 .
136-123 . A = B+C;
136-124 . A = B-C;
136-125 . A = B-C;
136-126 . A = B+C;
136-127 .
136-128 . if (A > = B)
136-129 . {
136-130 . A = B + C;
136-131 . D = E + F;
136-132 . }
136-133 .
136-134 . A = B-C;
136-135 . A = B/C;
136-136 .
136-137 . if (A == B)
136-138 . {
136-139 . A = B + C;
136-140 . D = E + F;
136-141 . }
136-142 .
136-143 .
136-144 . if (A != B)
136-145 . {
136-146 . A = B + C;
136-147 . D = E + F;
136-148 . }
136-149 .
136-150 .
136-151 . if (A ne B)
136-152 . {
136-153 . A = B + C;
136-154 . D = E + F;
136-155 . }
136-156 .
136-157 .
136-158 . if (A gt B)
136-159 . {
136-160 . A = B + C;
136-161 . D = E + F;
136-162 . }
136-163 .
136-164 . A = B*C;
136-165 . A = B/C;
136-166 . A = B*C;
136-167 .
136-168 . if (A != B)
136-169 . {
136-170 . A = B + C;
136-171 . D = E + F;
136-172 . }
136-173 .
136-174 . A = B+C;
136-175 . A = B*C;
136-176 . /* LE SV TOC-3128 this is a wxp-19.1.48 req to transform*/
136-177 .
136-178 . if (A ge B)
136-179 . {
136-180 . A = B + C;
136-181 . D = E + F;
136-182 . }
136-183 .
136-184 . A = B-C;
136-185 . A = B-C;
136-186 .
136-187 . if (A > B)
136-188 . {
136-189 . A = B + C;
136-190 . D = E + F;
136-191 . }
136-192 .
136-193 . A = B+C;
136-194 . A = B/C;
136-195 . A = B+C;
136-196 . // max LOC 54
136-197 .
136-198 . }
136-199 .
136-200 .
136-201 . /*
136-202 . -----------------------------------------------------------------------------
136-203 . --| NAME: wxp.19.2
136-204 . --|
136-205 . --| ABSTRACT:
136-206 . --| This function does wxp stuff.
136-207 . --|
136-208 . --| RETURNS:
136-209 . --| NONE.
136-210 . --|
136-211 . ----------------------------------------------------------------------------
136-212 . */
136-213 . static void wxp.19.2(void)
136-214 . {
136-215 .
136-216 . if (A lt B)
136-217 . {
136-218 . A = B + C;
136-219 . D = E + F;
136-220 . }
136-221 .
136-222 . A = (int)B + C;
136-223 . A = B-C;
136-224 . A = B+C;
136-225 . A = B+C;
136-226 . A = B/C;
136-227 .
136-228 . if (A ne B)
136-229 . {
136-230 . A = B + C;
136-231 . D = E + F;
136-232 . }
136-233 .
136-234 . A = B+C;
136-235 . A = 0x0002;
136-236 . A = B-C;
136-237 . A = (int)B + C;
136-238 . A = B+C;
136-239 . A = B/C;
136-240 . A = B+C;
136-241 . A = B+C;
136-242 .
136-243 . if (A ne B)
136-244 . {
136-245 . A = B + C;
136-246 . D = E + F;
136-247 . }
136-248 .
136-249 .
136-250 . if (A ge B)
136-251 . {
136-252 . A = B + C;
136-253 . D = E + F;
136-254 . }
136-255 .
136-256 . A = B+C;
136-257 . A = B-C;
136-258 .
136-259 . if (A gt B)
136-260 . {
136-261 . A = B + C;
136-262 . D = E + F;
136-263 . }
136-264 .
136-265 . A = B*C;
136-266 .
136-267 . #ifdef LAZY
136-268 . // this is not nice
136-269 . A = B + C;
136-270 . A = B + C;
136-271 . #endif
136-272 .
136-273 . A = B*C;
136-274 . A = 0x0001;
136-275 . A = B*C;
136-276 .
136-277 . if (A eq B)
136-278 . {
136-279 . A = B + C;
136-280 . D = E + F;
136-281 . }
136-282 .
136-283 . A = B-C;
136-284 .
136-285 . if (A < = B)
136-286 . {
136-287 . A = B + C;
136-288 . D = E + F;
136-289 . }
136-290 .
136-291 . A = B/C;
136-292 . A = B+C;
136-293 . A = B/C;
136-294 . A = B/C;
136-295 . A = B-C;
136-296 . A = B/C;
136-297 .
136-298 . if (A gt B)
136-299 . {
136-300 . A = B + C;
136-301 . D = E + F;
136-302 . }
136-303 .
136-304 . A = B+C;
136-305 .
136-306 . if (A > B)
136-307 . {
136-308 . A = B + C;
136-309 . D = E + F;
136-310 . }
136-311 .
136-312 . A = B*C;
136-313 .
136-314 . if (A ne B)
136-315 . {
136-316 . A = B + C;
136-317 . D = E + F;
136-318 . }
136-319 .
136-320 . A = B-C;
136-321 . A = B*C;
136-322 . A = B/C;
136-323 . A = B-C;
136-324 .
136-325 . switch (wxp stuff)
136-326 . {
136-327 . case one:
136-328 . {
136-329 . run_this;
136-330 . break;
136-331 . }
136-332 . case two:
136-333 . {
136-334 . run_this;
136-335 . break;
136-336 . }
136-337 . default:
136-338 . {
136-339 . SwError;
136-340 . }
136-341 . }
136-342 .
136-343 . A = B/C;
136-344 .
136-345 . if (A ge B)
136-346 . {
136-347 . A = B + C;
136-348 . D = E + F;
136-349 . }
136-350 .
136-351 . A = B+C;
136-352 . A = 0x0007;
136-353 . A = B+C;
136-354 .
136-355 . if (A ne B)
136-356 . {
136-357 . A = B + C;
136-358 . D = E + F;
136-359 . }
136-360 .
136-361 .
136-362 . if (A ne B)
136-363 . {
136-364 . A = B + C;
136-365 . D = E + F;
136-366 . }
136-367 .
136-368 . A = B*C;
136-369 . // (P) this is really improtant
136-370 .
136-371 . if (A != B)
136-372 . {
136-373 . A = B + C;
136-374 . D = E + F;
136-375 . }
136-376 .
136-377 . A = B+C;
136-378 . A = B+C;
136-379 .
136-380 . if (A == B)
136-381 . {
136-382 . A = B + C;
136-383 . D = E + F;
136-384 . }
136-385 .
136-386 . A = B-C;
136-387 . /* LE SV TOC-3129 this is a wxp-19.2.52 req to fail*/
136-388 . A = B/C;
136-389 . A = B-C;
136-390 .
136-391 . if (A > = B)
136-392 . {
136-393 . A = B + C;
136-394 . D = E + F;
136-395 . }
136-396 .
136-397 . A = B*C;
136-398 .
136-399 . if (A gt B)
136-400 . {
136-401 . A = B + C;
136-402 . D = E + F;
136-403 . }
136-404 .
136-405 . A = B-C;
136-406 . A = B/C;
136-407 .
136-408 . if (A gt B)
136-409 . {
136-410 . A = B + C;
136-411 . D = E + F;
136-412 . }
136-413 .
136-414 . A = B+C;
136-415 . A = B-C;
136-416 . A = B/C;
136-417 . // max LOC 62
136-418 .
136-419 . }
136-420 .
136-421 .
136-422 . /*
136-423 . -----------------------------------------------------------------------------
136-424 . --| NAME: wxp.19.3
136-425 . --|
136-426 . --| ABSTRACT:
136-427 . --| This function does wxp stuff.
136-428 . --|
136-429 . --| RETURNS:
136-430 . --| NONE.
136-431 . --|
136-432 . ----------------------------------------------------------------------------
136-433 . */
136-434 . static void wxp.19.3(void)
136-435 . {
136-436 . A = B*C;
136-437 . A = B/C;
136-438 .
136-439 . if (A le B)
136-440 . {
136-441 . A = B + C;
136-442 . D = E + F;
136-443 . }
136-444 .
136-445 . /* LE SV TOC-3130 this is a wxp-19.3.4 req to halt*/
136-446 . A = B+C;
136-447 .
136-448 . if (A ge B)
136-449 . {
136-450 . A = B + C;
136-451 . D = E + F;
136-452 . }
136-453 .
136-454 . A = B/C;
136-455 . A = B*C;
136-456 .
136-457 . if (A > = B)
136-458 . {
136-459 . A = B + C;
136-460 . D = E + F;
136-461 . }
136-462 .
136-463 .
136-464 . if (A < B)
136-465 . {
136-466 . A = B + C;
136-467 . D = E + F;
136-468 . }
136-469 .
136-470 .
136-471 . if (A lt B)
136-472 . {
136-473 . A = B + C;
136-474 . D = E + F;
136-475 . }
136-476 .
136-477 . A = B/C;
136-478 . A = B*C;
136-479 . A = B-C;
136-480 . /* LE SV TOC-3131 this is a wxp-19.3.14 req to transform*/
136-481 . A = B+C;
136-482 . A = B*C;
136-483 . A = B-C;
136-484 . A = B/C;
136-485 .
136-486 . if (A < B)
136-487 . {
136-488 . A = B + C;
136-489 . D = E + F;
136-490 . }
136-491 .
136-492 . A = B*C;
136-493 . // max LOC 19
136-494 .
136-495 . }
136-496 .
136-497 .
136-498 . /*
136-499 . -----------------------------------------------------------------------------
136-500 . --| NAME: wxp.19.4
136-501 . --|
136-502 . --| ABSTRACT:
136-503 . --| This function does wxp stuff.
136-504 . --|
136-505 . --| RETURNS:
136-506 . --| NONE.
136-507 . --|
136-508 . ----------------------------------------------------------------------------
136-509 . */
136-510 . static void wxp.19.4(void)
136-511 . {
136-512 . A = B/C;
136-513 . A = B-C;
136-514 . A = B-C;
136-515 . A = B/C;
136-516 . A = B*C;
136-517 . A = B*C;
136-518 . A = B/C;
136-519 . A = B+C;
136-520 .
136-521 . if (A le B)
136-522 . {
136-523 . A = B + C;
136-524 . D = E + F;
136-525 . }
136-526 .
136-527 . A = B/C;
136-528 .
136-529 . if (A < = B)
136-530 . {
136-531 . A = B + C;
136-532 . D = E + F;
136-533 . }
136-534 .
136-535 . A = B*C;
136-536 . A = B-C;
136-537 . do forever;
136-538 . A = B-C;
136-539 . A = B+C;
136-540 .
136-541 . if (A > B)
136-542 . {
136-543 . A = B + C;
136-544 . D = E + F;
136-545 . }
136-546 .
136-547 .
136-548 . if (A eq B)
136-549 . {
136-550 . A = B + C;
136-551 . D = E + F;
136-552 . }
136-553 .
136-554 . A = B+C;
136-555 .
136-556 . if (A ne B)
136-557 . {
136-558 . A = B + C;
136-559 . D = E + F;
136-560 . }
136-561 .
136-562 . A = B*C;
136-563 . A = B*C;
136-564 . free(FreePtr);
136-565 . A = B*C;
136-566 . A = B-C;
136-567 .
136-568 . if (A == B)
136-569 . {
136-570 . A = B + C;
136-571 . D = E + F;
136-572 . }
136-573 .
136-574 .
136-575 . if (A eq B)
136-576 . {
136-577 . A = B + C;
136-578 . D = E + F;
136-579 . }
136-580 .
136-581 .
136-582 . if (A ge B)
136-583 . {
136-584 . A = B + C;
136-585 . D = E + F;
136-586 . }
136-587 .
136-588 .
136-589 . if (A lt B)
136-590 . {
136-591 . A = B + C;
136-592 . D = E + F;
136-593 . }
136-594 .
136-595 . A = (float)B + C;
136-596 . A = B+C;
136-597 . A = B*C;
136-598 . A = B/C;
136-599 . A = B/C;
136-600 . A = B+C;
136-601 . A = B-C;
136-602 . A = B+C;
136-603 .
136-604 . if (A < B)
136-605 . {
136-606 . A = B + C;
136-607 . D = E + F;
136-608 . }
136-609 .
136-610 .
136-611 . if (A ne B)
136-612 . {
136-613 . A = B + C;
136-614 . D = E + F;
136-615 . }
136-616 .
136-617 .
136-618 . if (veg)
136-619 . // missing curly brace
136-620 . variable = orange;
136-621 .
136-622 . A = B+C;
136-623 . A = B+C;
136-624 . /* LE SV TOC-3132 this is a wxp-19.4.39 req to check unix*/
136-625 .
136-626 . if (A lt B)
136-627 . {
136-628 . A = B + C;
136-629 . D = E + F;
136-630 . }
136-631 .
136-632 . A = B*C;
136-633 . A = B*C;
136-634 . A = B/C;
136-635 . A = B+C;
136-636 . A = B*C;
136-637 . A = B-C;
136-638 .
136-639 . if (A lt B)
136-640 . {
136-641 . A = B + C;
136-642 . D = E + F;
136-643 . }
136-644 .
136-645 . A = B-C;
136-646 . A = B-C;
136-647 . A = B+C;
136-648 . A = B+C;
136-649 . A = B/C;
136-650 . A = B-C;
136-651 .
136-652 . if (A < = B)
136-653 . {
136-654 . A = B + C;
136-655 . D = E + F;
136-656 . }
136-657 .
136-658 . A = B/C;
136-659 . A = B/C;
136-660 . A = B/C;
136-661 .
136-662 . if (A lt B)
136-663 . {
136-664 . A = B + C;
136-665 . D = E + F;
136-666 . }
136-667 .
136-668 . A = B/C;
136-669 . A = B-C;
136-670 . A = B/C;
136-671 . A = B-C;
136-672 .
136-673 . if (A > = B)
136-674 . {
136-675 . A = B + C;
136-676 . D = E + F;
136-677 . }
136-678 .
136-679 .
136-680 . if (A > = B)
136-681 . {
136-682 . A = B + C;
136-683 . D = E + F;
136-684 . }
136-685 .
136-686 . A = B*C;
136-687 . A = B+C;
136-688 .
136-689 . if (A > = B)
136-690 . {
136-691 . A = B + C;
136-692 . D = E + F;
136-693 . }
136-694 .
136-695 . A = B*C;
136-696 . /* LE SV TOC-3133 this is a wxp-19.4.68 req to detect error*/
136-697 .
136-698 . if (A le B)
136-699 . {
136-700 . A = B + C;
136-701 . D = E + F;
136-702 . }
136-703 .
136-704 .
136-705 . if (A != B)
136-706 . {
136-707 . A = B + C;
136-708 . D = E + F;
136-709 . }
136-710 .
136-711 . A = B+C;
136-712 .
136-713 . switch (wxp stuff)
136-714 . {
136-715 . case one:
136-716 . {
136-717 . switch (nested)
136-718 . {
136-719 . case:
136-720 . X = Y + Z;
136-721 . case:
136-722 . X = Y + Z;
136-723 . default:
136-724 . SwError;
136-725 . }
136-726 . }
136-727 . case two:
136-728 . {
136-729 . run_this;
136-730 . break;
136-731 . }
136-732 . default:
136-733 . {
136-734 . SwError;
136-735 . }
136-736 . }
136-737 .
136-738 . A = B-C;
136-739 .
136-740 . if (A < B)
136-741 . {
136-742 . A = B + C;
136-743 . D = E + F;
136-744 . }
136-745 .
136-746 .
136-747 . if (A > = B)
136-748 . {
136-749 . A = B + C;
136-750 . D = E + F;
136-751 . }
136-752 .
136-753 . A = B+C;
136-754 . A = B-C;
136-755 . A = B-C;
136-756 .
136-757 . if (A le B)
136-758 . {
136-759 . A = B + C;
136-760 . D = E + F;
136-761 . }
136-762 .
136-763 .
136-764 . if (A < B)
136-765 . {
136-766 . A = B + C;
136-767 . D = E + F;
136-768 . }
136-769 .
136-770 . A = B-C;
136-771 .
136-772 . if (A > = B)
136-773 . {
136-774 . A = B + C;
136-775 . D = E + F;
136-776 . }
136-777 .
136-778 . A = B+C;
136-779 . /* LE SV TOC-3134 this is a wxp-19.4.82 req to recover*/
136-780 .
136-781 . if (A eq B)
136-782 . {
136-783 . A = B + C;
136-784 . D = E + F;
136-785 . }
136-786 .
136-787 .
136-788 . if (A eq B)
136-789 . {
136-790 . A = B + C;
136-791 . D = E + F;
136-792 . }
136-793 .
136-794 .
136-795 . if (A ne B)
136-796 . {
136-797 . A = B + C;
136-798 . D = E + F;
136-799 . }
136-800 .
136-801 . A = B*C;
136-802 . A = B-C;
136-803 .
136-804 . if (A le B)
136-805 . {
136-806 . A = B + C;
136-807 . D = E + F;
136-808 . }
136-809 .
136-810 . A = B+C;
136-811 .
136-812 . if (A > B)
136-813 . {
136-814 . A = B + C;
136-815 . D = E + F;
136-816 . }
136-817 .
136-818 . A = B+C;
136-819 . /* LE SV TOC-3135 this is a wxp-19.4.91 req to reject*/
136-820 . A = B-C;
136-821 . A = B*C;
136-822 . A = B+C;
136-823 . A = B-C;
136-824 .
136-825 . if {
136-826 . X = Y + Z;
136-827 . }
136-828 . else {
136-829 . halt;
136-830 . }
136-831 .
136-832 . A = B/C;
136-833 . A = B+C;
136-834 . A = B*C;
136-835 . A = B/C;
136-836 . A = B*C;
136-837 . // max LOC 99
136-838 .
136-839 . }
136-840 .
136-841 .
136-842 . /*
136-843 . -----------------------------------------------------------------------------
136-844 . --| NAME: wxp.19.5
136-845 . --|
136-846 . --| ABSTRACT:
136-847 . --| This function does wxp stuff.
136-848 . --|
136-849 . --| RETURNS:
136-850 . --| NONE.
136-851 . --|
136-852 . ----------------------------------------------------------------------------
136-853 . */
136-854 . static void wxp.19.5(void)
136-855 . {
136-856 . /* LE SV TOC-3136 this is a wxp-19.5.1 req to inhibit*/
136-857 . A = B/C;
136-858 .
136-859 . if (A gt B)
136-860 . {
136-861 . A = B + C;
136-862 . D = E + F;
136-863 . }
136-864 .
136-865 . A = B*C;
136-866 . A = B*C;
136-867 .
136-868 . if (A ge B)
136-869 . {
136-870 . A = B + C;
136-871 . D = E + F;
136-872 . }
136-873 .
136-874 . A = B+C;
136-875 . A = B+C;
136-876 . A = B*C;
136-877 . A = B-C;
136-878 .
136-879 . if (A eq B)
136-880 . {
136-881 . A = B + C;
136-882 . D = E + F;
136-883 . }
136-884 .
136-885 . send_buffer = (U16 *) malloc(size+1);
136-886 . A = B/C;
136-887 .
136-888 . if (A ge B)
136-889 . {
136-890 . A = B + C;
136-891 . D = E + F;
136-892 . }
136-893 .
136-894 .
136-895 . if (A == B)
136-896 . {
136-897 . A = B + C;
136-898 . D = E + F;
136-899 . }
136-900 .
136-901 . A = B*C;
136-902 . A = B-C;
136-903 .
136-904 . if (A gt B)
136-905 . {
136-906 . A = B + C;
136-907 . D = E + F;
136-908 . }
136-909 .
136-910 . A = B/C;
136-911 . A = B-C;
136-912 . A = B/C;
136-913 . // max LOC 19
136-914 .
136-915 . }
136-916 .
136-917 .
136-918 . /*
136-919 . -----------------------------------------------------------------------------
136-920 . --| NAME: wxp.19.6
136-921 . --|
136-922 . --| ABSTRACT:
136-923 . --| This function does wxp stuff.
136-924 . --|
136-925 . --| RETURNS:
136-926 . --| NONE.
136-927 . --|
136-928 . ----------------------------------------------------------------------------
136-929 . */
136-930 . static void wxp.19.6(void)
136-931 . {
136-932 .
136-933 . if (A lt B)
136-934 . {
136-935 . A = B + C;
136-936 . D = E + F;
136-937 . }
136-938 .
136-939 . A = B/C;
136-940 .
136-941 . if (A > B)
136-942 . {
136-943 . A = B + C;
136-944 . D = E + F;
136-945 . }
136-946 .
136-947 . A = B*C;
136-948 . A = B/C;
136-949 . A = B-C;
136-950 . A = B/C;
136-951 . A = B-C;
136-952 .
136-953 . if (A > B)
136-954 . {
136-955 . A = B + C;
136-956 . D = E + F;
136-957 . }
136-958 .
136-959 . A = B+C;
136-960 . A = B/C;
136-961 . A = B+C;
136-962 . A = B*C;
136-963 . A = B*C;
136-964 .
136-965 . if (A > = B)
136-966 . {
136-967 . A = B + C;
136-968 . D = E + F;
136-969 . }
136-970 .
136-971 .
136-972 . if (A ne B)
136-973 . {
136-974 . A = B + C;
136-975 . D = E + F;
136-976 . }
136-977 .
136-978 . A = B*C;
136-979 . A = B-C;
136-980 . A = B/C;
136-981 .
136-982 . if (A < = B)
136-983 . {
136-984 . A = B + C;
136-985 . D = E + F;
136-986 . }
136-987 .
136-988 . A = B*C;
136-989 . A = B+C;
136-990 . A = B+C;
136-991 . /* LE SV TOC-3137 this is a wxp-19.6.24 req to increment*/
136-992 . A = B/C;
136-993 . A = B+C;
136-994 . A = B+C;
136-995 . A = B+C;
136-996 . A = B+C;
136-997 . A = B*C;
136-998 . A = B*C;
136-999 .
136-1000 . switch (wxp stuff)
136-1001 . {
136-1002 . case one:
136-1003 . {
136-1004 . run_this;
136-1005 . break;
136-1006 . }
136-1007 . case two:
136-1008 . {
136-1009 . run_this;
136-1010 . break;
136-1011 . }
136-1012 . default:
136-1013 . {
136-1014 . SwError;
136-1015 . }
136-1016 . }
136-1017 .
136-1018 . A = B*C;
136-1019 . A = B/C;
136-1020 . /* LE SV TOC-3138 this is a wxp-19.6.34 req to convert*/
136-1021 . A = B+C;
136-1022 . A = B-C;
136-1023 . A = B+C;
136-1024 . A = B+C;
136-1025 . /* LE SV TOC-3139 this is a wxp-19.6.38 req to enable*/
136-1026 . A = B/C;
136-1027 . A = B-C;
136-1028 . A = B*C;
136-1029 . A = B-C;
136-1030 . A = B+C;
136-1031 . A = B-C;
136-1032 .
136-1033 . /*
136-1034 . dead_block = C * D;
136-1035 . dead_block = E * F;
136-1036 . */
136-1037 .
136-1038 . A = B+C;
136-1039 . // max LOC 44
136-1040 .
136-1041 . }
136-1042 .
136-1043 .
136-1044 . /*
136-1045 . -----------------------------------------------------------------------------
136-1046 . --| NAME: wxp.19.7
136-1047 . --|
136-1048 . --| ABSTRACT:
136-1049 . --| This function does wxp stuff.
136-1050 . --|
136-1051 . --| RETURNS:
136-1052 . --| NONE.
136-1053 . --|
136-1054 . ----------------------------------------------------------------------------
136-1055 . */
136-1056 . static void wxp.19.7(void)
136-1057 . {
136-1058 . A = B*C;
136-1059 . A = B/C;
136-1060 . A = B*C;
136-1061 . A = B*C;
136-1062 . A = B*C;
136-1063 . A = B-C;
136-1064 .
136-1065 . if (A == B)
136-1066 . {
136-1067 . A = B + C;
136-1068 . D = E + F;
136-1069 . }
136-1070 .
136-1071 .
136-1072 . switch (wxp stuff)
136-1073 . {
136-1074 . case one:
136-1075 . {
136-1076 . run_this;
136-1077 . break;
136-1078 . }
136-1079 . case two:
136-1080 . {
136-1081 . run_this;
136-1082 . break;
136-1083 . }
136-1084 . default:
136-1085 . {
136-1086 . SwError;
136-1087 . }
136-1088 . }
136-1089 .
136-1090 . A = B*C;
136-1091 .
136-1092 . if (A == B)
136-1093 . {
136-1094 . A = B + C;
136-1095 . D = E + F;
136-1096 . }
136-1097 .
136-1098 . A = 0x0004;
136-1099 . A = B*C;
136-1100 . A = B+C;
136-1101 .
136-1102 . if (A le B)
136-1103 . {
136-1104 . A = B + C;
136-1105 . D = E + F;
136-1106 . }
136-1107 .
136-1108 . A = B/C;
136-1109 . A = B*C;
136-1110 . A = B/C;
136-1111 . A = B/C;
136-1112 . A = B-C;
136-1113 . A = B+C;
136-1114 .
136-1115 . if (A == B)
136-1116 . {
136-1117 . A = B + C;
136-1118 . D = E + F;
136-1119 . }
136-1120 .
136-1121 .
136-1122 . if (A gt B)
136-1123 . {
136-1124 . A = B + C;
136-1125 . D = E + F;
136-1126 . }
136-1127 .
136-1128 . A = B/C;
136-1129 . A = 0x0008;
136-1130 . A = B*C;
136-1131 . /* LE SV TOC-3140 this is a wxp-19.7.24 req to translate*/
136-1132 . A = B+C;
136-1133 . A = 0x0002;
136-1134 . A = B+C;
136-1135 . A = B+C;
136-1136 . /* LE SV TOC-3141 this is a wxp-19.7.27 req to set RTC*/
136-1137 . A = B/C;
136-1138 . A = B+C;
136-1139 . A = B+C;
136-1140 . A = B+C;
136-1141 .
136-1142 . /*
136-1143 . dead_block = C * D;
136-1144 . dead_block = E * F;
136-1145 . */
136-1146 .
136-1147 . A = B-C;
136-1148 . A = B/C;
136-1149 .
136-1150 . if (A eq B)
136-1151 . {
136-1152 . A = B + C;
136-1153 . D = E + F;
136-1154 . }
136-1155 .
136-1156 . A = B+C;
136-1157 . A = B-C;
136-1158 .
136-1159 . if (A le B)
136-1160 . {
136-1161 . A = B + C;
136-1162 . D = E + F;
136-1163 . }
136-1164 .
136-1165 . A = B*C;
136-1166 . /* LE SV TOC-3142 this is a wxp-19.7.38 req to inhibit*/
136-1167 . A = B+C;
136-1168 . A = B/C;
136-1169 . A = B+C;
136-1170 . A = B*C;
136-1171 . // max LOC 41
136-1172 .
136-1173 . }
136-1174 .
136 136 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-19.c
done
12/01/2003 17:08:53 start
12/01/2003 17:09:32 end