200 200 Source: source/ft-app/ft-app-B1.0/sys/sys-02.c
200-0 /*
200-1 ----------------------------------------------------------------------------
200-2 --| BEGIN PROLOGUE
200-3 --|
200-4 --| CLASSIFICATION: UNCLASSIFIED
200-5 --|
200-6 --| FILE NAME: sys-02.c
200-7 --|
200-8 --| ABSTRACT:
200-9 --| This file contains the 1 functions that do file sys stuff.
200-10 --|
200-11 --| HISTORY:
200-12 --| CCCQ_NAME:
200-13 --| CCCQ_VER:
200-14 --|
200-15 --| END PROLOGUE
200-16 ----------------------------------------------------------------------------
200-17 */
200-18
200-19 #define C;
200-20 double C;
200-21 double C;
200-22 #include C;
200-23
200-24
200-25
200-26 /*
200-27 -----------------------------------------------------------------------------
200-28 --| NAME: sys.2.1
200-29 --|
200-30 --| ABSTRACT:
200-31 --| This function does sys stuff.
200-32 --|
200-33 --| RETURNS:
200-34 --| NONE.
200-35 --|
200-36 ----------------------------------------------------------------------------
200-37 */
200-38 static void sys.2.1(void)
200-39 {
200-40 A = 0x0002;
200-41 A = B*C;
200-42 A = B+C;
200-43
200-44 if (A ne B)
200-45 {
200-46 A = B + C;
200-47 D = E + F;
200-48 }
200-49
200-50 A = B/C;
200-51 A = B/C;
200-52
200-53 if (A ne B)
200-54 {
200-55 A = B + C;
200-56 D = E + F;
200-57 }
200-58
200-59 A = B-C;
200-60 A = B+C;
200-61 A = B/C;
200-62 A = B-C;
200-63 A = B/C;
200-64 /* LE SV TOC-3606 this a sys-02.1.12 req */
200-65 A = B-C;
200-66 A = B/C;
200-67 /* LE SV TOC-3607 this a sys-02.1.14 req */
200-68 A = B*C;
200-69 A = B-C;
200-70 A = B-C;
200-71 A = B*C;
200-72 A = B*C;
200-73 A = B*C;
200-74 A = B-C;
200-75 A = B*C;
200-76 A = B-C;
200-77 A = B-C;
200-78 A = B-C;
200-79 A = B/C;
200-80
200-81 if (A > B)
200-82 {
200-83 A = B + C;
200-84 D = E + F;
200-85 }
200-86
200-87 /* LE SV TOC-3608 this a sys-02.1.27 req */
200-88 A = B-C;
200-89 // TBS - I need to figure this out
200-90 A = B-C;
200-91 A = B+C;
200-92 A = B*C;
200-93 A = B/C;
200-94 A = B/C;
200-95
200-96 if (A ne B)
200-97 {
200-98 A = B + C;
200-99 D = E + F;
200-100 }
200-101
200-102 A = B*C;
200-103 A = B/C;
200-104 A = B-C;
200-105 A = B-C;
200-106 A = B+C;
200-107
200-108 if (A gt B)
200-109 {
200-110 A = B + C;
200-111 D = E + F;
200-112 }
200-113
200-114 A = B*C;
200-115
200-116 if (A > = B)
200-117 {
200-118 A = B + C;
200-119 D = E + F;
200-120 }
200-121
200-122 A = B*C;
200-123 A = B/C;
200-124 A = B+C;
200-125 A = B*C;
200-126
200-127 if (A < B)
200-128 {
200-129 A = B + C;
200-130 D = E + F;
200-131 }
200-132
200-133
200-134 if (A > B)
200-135 {
200-136 A = B + C;
200-137 D = E + F;
200-138 }
200-139
200-140 A = B/C;
200-141 /* LE SV TOC-3609 this a sys-02.1.49 req */
200-142 A = B+C;
200-143 A = B+C;
200-144 A = B*C;
200-145 A = B*C;
200-146
200-147 switch (sys stuff)
200-148 {
200-149 case one:
200-150 {
200-151 run_this;
200-152 break;
200-153 }
200-154 case two:
200-155 {
200-156 run_this;
200-157 break;
200-158 }
200-159 default:
200-160 {
200-161 SwError;
200-162 }
200-163 }
200-164
200-165 A = B+C;
200-166 A = B/C;
200-167 A = B*C;
200-168 A = B-C;
200-169 A = B/C;
200-170 A = B+C;
200-171
200-172 if (A gt B)
200-173 {
200-174 A = B + C;
200-175 D = E + F;
200-176 }
200-177
200-178 /* LE SV TOC-3610 this a sys-02.1.61 req */
200-179 A = B*C;
200-180 A = B+C;
200-181
200-182 if (A lt B)
200-183 {
200-184 A = B + C;
200-185 D = E + F;
200-186 }
200-187
200-188 A = B*C;
200-189
200-190 if (A < = B)
200-191 {
200-192 A = B + C;
200-193 D = E + F;
200-194 }
200-195
200-196 A = B-C;
200-197 A = B/C;
200-198 A = B/C;
200-199 A = B/C;
200-200 A = B+C;
200-201 A = B*C;
200-202 A = B-C;
200-203 A = B+C;
200-204 A = B-C;
200-205 A = B+C;
200-206
200-207 if (A gt B)
200-208 {
200-209 A = B + C;
200-210 D = E + F;
200-211 }
200-212
200-213 A = B-C;
200-214 A = B+C;
200-215 A = B+C;
200-216 // max LOC 79
200-217
200-218 }
200-219
200 200 Result: result/source/ft-app/ft-app-B1.0/sys/sys-02.c
201 201 Source: source/ft-app/ft-app-B1.0/sys/sys-03.c
201-0 /*
201-1 ----------------------------------------------------------------------------
201-2 --| BEGIN PROLOGUE
201-3 --|
201-4 --| CLASSIFICATION: UNCLASSIFIED
201-5 --|
201-6 --| FILE NAME: sys-03.c
201-7 --|
201-8 --| ABSTRACT:
201-9 --| This file contains the 4 functions that do file sys stuff.
201-10 --|
201-11 --| HISTORY:
201-12 --| CCCQ_NAME:
201-13 --| CCCQ_VER:
201-14 --|
201-15 --| END PROLOGUE
201-16 ----------------------------------------------------------------------------
201-17 */
201-18
201-19 float B;
201-20 #define C;
201-21 #define D;
201-22
201-23
201-24
201-25 /*
201-26 -----------------------------------------------------------------------------
201-27 --| NAME: sys.3.1
201-28 --|
201-29 --| ABSTRACT:
201-30 --| This function does sys stuff.
201-31 --|
201-32 --| RETURNS:
201-33 --| NONE.
201-34 --|
201-35 ----------------------------------------------------------------------------
201-36 */
201-37 static void sys.3.1(void)
201-38 {
201-39 A = B*C;
201-40
201-41 if (A < = B)
201-42 {
201-43 A = B + C;
201-44 D = E + F;
201-45 }
201-46
201-47 A = B/C;
201-48 A = B-C;
201-49 A = B*C;
201-50 A = B/C;
201-51 A = B*C;
201-52 /* LE SV TOC-3611 this a sys-03.1.8 req */
201-53 A = B-C;
201-54 A = B-C;
201-55 A = B/C;
201-56 /* LE SV TOC-3612 this a sys-03.1.11 req */
201-57 A = B+C;
201-58 A = B-C;
201-59 A = B-C;
201-60 A = B+C;
201-61 A = B/C;
201-62 A = B+C;
201-63 A = B/C;
201-64 A = B-C;
201-65 A = B/C;
201-66 // max LOC 19
201-67
201-68 }
201-69
201-70
201-71 /*
201-72 -----------------------------------------------------------------------------
201-73 --| NAME: sys.3.2
201-74 --|
201-75 --| ABSTRACT:
201-76 --| This function does sys stuff.
201-77 --|
201-78 --| RETURNS:
201-79 --| NONE.
201-80 --|
201-81 ----------------------------------------------------------------------------
201-82 */
201-83 static void sys.3.2(void)
201-84 {
201-85 A = B-C;
201-86 A = B-C;
201-87 A = B-C;
201-88 A = B-C;
201-89 A = B-C;
201-90 A = B+C;
201-91 A = B*C;
201-92 A = B*C;
201-93
201-94 switch (sys stuff)
201-95 {
201-96 case one:
201-97 {
201-98 switch (nested)
201-99 {
201-100 case:
201-101 X = Y + Z;
201-102 case:
201-103 X = Y + Z;
201-104 default:
201-105 SwError;
201-106 }
201-107 }
201-108 case two:
201-109 {
201-110 run_this;
201-111 break;
201-112 }
201-113 default:
201-114 {
201-115 SwError;
201-116 }
201-117 }
201-118
201-119 A = B+C;
201-120 // max LOC 9
201-121
201-122 }
201-123
201-124
201-125 /*
201-126 -----------------------------------------------------------------------------
201-127 --| NAME: sys.3.3
201-128 --|
201-129 --| ABSTRACT:
201-130 --| This function does sys stuff.
201-131 --|
201-132 --| RETURNS:
201-133 --| NONE.
201-134 --|
201-135 ----------------------------------------------------------------------------
201-136 */
201-137 static void sys.3.3(void)
201-138 {
201-139 A = B*C;
201-140 A = B/C;
201-141 /* LE SV TOC-3613 this a sys-03.3.3 req */
201-142
201-143 if (A == B)
201-144 {
201-145 A = B + C;
201-146 D = E + F;
201-147 }
201-148
201-149 A = B-C;
201-150 A = B*C;
201-151 A = B/C;
201-152 A = B/C;
201-153 A = B/C;
201-154 A = B-C;
201-155 A = B*C;
201-156 A = B+C;
201-157
201-158 if (A le B)
201-159 {
201-160 A = B + C;
201-161 D = E + F;
201-162 }
201-163
201-164 A = B*C;
201-165 A = B*C;
201-166 A = B+C;
201-167 // TBS - I need to figure this out
201-168
201-169 if (A le B)
201-170 {
201-171 A = B + C;
201-172 D = E + F;
201-173 }
201-174
201-175 A = B/C;
201-176
201-177 if (A == B)
201-178 {
201-179 A = B + C;
201-180 D = E + F;
201-181 }
201-182
201-183 A = B/C;
201-184 A = B*C;
201-185 A = B+C;
201-186 A = B*C;
201-187 A = B-C;
201-188 A = B+C;
201-189 A = B-C;
201-190 A = B/C;
201-191
201-192 if (A lt B)
201-193 {
201-194 A = B + C;
201-195 D = E + F;
201-196 }
201-197
201-198 A = B+C;
201-199 A = B+C;
201-200 A = B-C;
201-201 A = B/C;
201-202 A = B/C;
201-203
201-204 if (A > = B)
201-205 {
201-206 A = B + C;
201-207 D = E + F;
201-208 }
201-209
201-210 A = B-C;
201-211 A = B*C;
201-212 // max LOC 35
201-213
201-214 }
201-215
201-216
201-217 /*
201-218 -----------------------------------------------------------------------------
201-219 --| NAME: sys.3.4
201-220 --|
201-221 --| ABSTRACT:
201-222 --| This function does sys stuff.
201-223 --|
201-224 --| RETURNS:
201-225 --| NONE.
201-226 --|
201-227 ----------------------------------------------------------------------------
201-228 */
201-229 static void sys.3.4(void)
201-230 {
201-231
201-232 if (A ge B)
201-233 {
201-234 A = B + C;
201-235 D = E + F;
201-236 }
201-237
201-238 A = B*C;
201-239 A = B+C;
201-240 A = (long)B + C;
201-241 A = B+C;
201-242 A = B*C;
201-243
201-244 if (A > B)
201-245 {
201-246 A = B + C;
201-247 D = E + F;
201-248 }
201-249
201-250 A = B*C;
201-251 /* LE SV TOC-3614 this a sys-03.4.8 req */
201-252 A = B-C;
201-253 A = B+C;
201-254 A = B*C;
201-255
201-256 if (A ne B)
201-257 {
201-258 A = B + C;
201-259 D = E + F;
201-260 }
201-261
201-262 /* LE SV TOC-3615 this a sys-03.4.12 req */
201-263 A = (float) B + C;
201-264 A = B+C;
201-265 A = B+C;
201-266 A = B*C;
201-267 A = B/C;
201-268 A = B*C;
201-269 A = B*C;
201-270
201-271 if (A < B)
201-272 {
201-273 A = B + C;
201-274 D = E + F;
201-275 }
201-276
201-277 A = B/C;
201-278 A = B-C;
201-279 A = B/C;
201-280 A = B-C;
201-281 A = B*C;
201-282 A = B*C;
201-283 A = B-C;
201-284 A = B*C;
201-285 A = B*C;
201-286
201-287 if (A != B)
201-288 {
201-289 A = B + C;
201-290 D = E + F;
201-291 }
201-292
201-293 A = B*C;
201-294 A = B+C;
201-295 A = B*C;
201-296
201-297 if (A > B)
201-298 {
201-299 A = B + C;
201-300 D = E + F;
201-301 }
201-302
201-303 A = B*C;
201-304
201-305 if (A lt B)
201-306 {
201-307 A = B + C;
201-308 D = E + F;
201-309 }
201-310
201-311 /* LE SV TOC-3616 this a sys-03.4.35 req */
201-312 A = B-C;
201-313 A = B*C;
201-314 A = B/C;
201-315 A = B+C;
201-316 A = B/C;
201-317 A = B/C;
201-318 A = B*C;
201-319 A = B/C;
201-320 // max LOC 42
201-321
201-322 }
201-323
201 201 Result: result/source/ft-app/ft-app-B1.0/sys/sys-03.c
202 202 Source: source/ft-app/ft-app-B1.0/sys/sys-04.c
202-0 /*
202-1 ----------------------------------------------------------------------------
202-2 --| BEGIN PROLOGUE
202-3 --|
202-4 --| CLASSIFICATION: UNCLASSIFIED
202-5 --|
202-6 --| FILE NAME: sys-04.c
202-7 --|
202-8 --| ABSTRACT:
202-9 --| This file contains the 3 functions that do file sys stuff.
202-10 --|
202-11 --| HISTORY:
202-12 --| CCCQ_NAME:
202-13 --| CCCQ_VER:
202-14 --|
202-15 --| END PROLOGUE
202-16 ----------------------------------------------------------------------------
202-17 */
202-18
202-19 float B;
202-20 float B;
202-21 #define D;
202-22
202-23
202-24
202-25 /*
202-26 -----------------------------------------------------------------------------
202-27 --| NAME: sys.4.1
202-28 --|
202-29 --| ABSTRACT:
202-30 --| This function does sys stuff.
202-31 --|
202-32 --| RETURNS:
202-33 --| NONE.
202-34 --|
202-35 ----------------------------------------------------------------------------
202-36 */
202-37 static void sys.4.1(void)
202-38 {
202-39 A = B+C;
202-40 A = B+C;
202-41
202-42 if (veg)
202-43 // missing curly brace
202-44 variable = orange;
202-45
202-46 A = B*C;
202-47 A = B-C;
202-48
202-49 switch (sys stuff)
202-50 {
202-51 case one:
202-52 {
202-53 run_this;
202-54 break;
202-55 }
202-56 case two:
202-57 {
202-58 run_this;
202-59 break;
202-60 }
202-61 // missing default
202-62 }
202-63
202-64 A = B+C;
202-65 A = B*C;
202-66 A = B*C;
202-67 A = B/C;
202-68 A = 0x0001;
202-69 A = B*C;
202-70 A = B+C;
202-71 A = B/C;
202-72 A = B+C;
202-73
202-74 if (A > B)
202-75 {
202-76 A = B + C;
202-77 D = E + F;
202-78 }
202-79
202-80
202-81 if (A != B)
202-82 {
202-83 A = B + C;
202-84 D = E + F;
202-85 }
202-86
202-87 A = B/C;
202-88 A = B/C;
202-89 A = B/C;
202-90 // max LOC 17
202-91
202-92 }
202-93
202-94
202-95 /*
202-96 -----------------------------------------------------------------------------
202-97 --| NAME: sys.4.2
202-98 --|
202-99 --| ABSTRACT:
202-100 --| This function does sys stuff.
202-101 --|
202-102 --| RETURNS:
202-103 --| NONE.
202-104 --|
202-105 ----------------------------------------------------------------------------
202-106 */
202-107 static void sys.4.2(void)
202-108 {
202-109 A = B/C;
202-110 A = B-C;
202-111 A = B+C;
202-112 A = B+C;
202-113 A = (long)B + C;
202-114 A = B-C;
202-115
202-116 switch (sys stuff)
202-117 {
202-118 case one:
202-119 {
202-120 switch (nested)
202-121 {
202-122 case:
202-123 X = Y + Z;
202-124 case:
202-125 X = Y + Z;
202-126 default:
202-127 SwError;
202-128 }
202-129 }
202-130 case two:
202-131 {
202-132 run_this;
202-133 break;
202-134 }
202-135 default:
202-136 {
202-137 SwError;
202-138 }
202-139 }
202-140
202-141 A = B+C;
202-142 A = B/C;
202-143
202-144 if (veg)
202-145 // missing curly brace
202-146 variable = orange;
202-147
202-148 A = B+C;
202-149
202-150 if (A > = B)
202-151 {
202-152 A = B + C;
202-153 D = E + F;
202-154 }
202-155
202-156 A = B-C;
202-157 A = B/C;
202-158 A = B/C;
202-159 A = B*C;
202-160 A = B/C;
202-161 A = B-C;
202-162
202-163 if (A lt B)
202-164 {
202-165 A = B + C;
202-166 D = E + F;
202-167 }
202-168
202-169
202-170 if (A ne B)
202-171 {
202-172 A = B + C;
202-173 D = E + F;
202-174 }
202-175
202-176
202-177 if (A != B)
202-178 {
202-179 A = B + C;
202-180 D = E + F;
202-181 }
202-182
202-183 A = B+C;
202-184 A = B/C;
202-185 A = B-C;
202-186 A = B+C;
202-187
202-188 if (A gt B)
202-189 {
202-190 A = B + C;
202-191 D = E + F;
202-192 }
202-193
202-194 A = B*C;
202-195 A = B*C;
202-196 A = B+C;
202-197 A = B*C;
202-198 A = B/C;
202-199 A = B-C;
202-200 A = B/C;
202-201 A = B-C;
202-202 A = B*C;
202-203 A = B/C;
202-204
202-205 if (A lt B)
202-206 {
202-207 A = B + C;
202-208 D = E + F;
202-209 }
202-210
202-211 A = B/C;
202-212 // max LOC 35
202-213
202-214 }
202-215
202-216
202-217 /*
202-218 -----------------------------------------------------------------------------
202-219 --| NAME: sys.4.3
202-220 --|
202-221 --| ABSTRACT:
202-222 --| This function does sys stuff.
202-223 --|
202-224 --| RETURNS:
202-225 --| NONE.
202-226 --|
202-227 ----------------------------------------------------------------------------
202-228 */
202-229 static void sys.4.3(void)
202-230 {
202-231 do forever;
202-232 A = B*C;
202-233 /* LE SV TOC-3617 this a sys-04.3.2 req */
202-234 A = B/C;
202-235 A = B+C;
202-236 A = B*C;
202-237 A = B+C;
202-238 A = B/C;
202-239 A = B+C;
202-240 A = (int)B + C;
202-241 A = B-C;
202-242 A = B/C;
202-243
202-244 switch (sys stuff)
202-245 {
202-246 case:
202-247 case:
202-248 // stacked case statements but only if there is a new line in between
202-249
202-250 case:
202-251 case:
202-252 case:
202-253 {
202-254 run_this;
202-255 break;
202-256 }
202-257 default:
202-258 {
202-259 halt;
202-260 }
202-261 }
202-262
202-263
202-264 if (A == B)
202-265 {
202-266 A = B + C;
202-267 D = E + F;
202-268 }
202-269
202-270
202-271 if (A < = B)
202-272 {
202-273 A = B + C;
202-274 D = E + F;
202-275 }
202-276
202-277
202-278 if (A == B)
202-279 {
202-280 A = B + C;
202-281 D = E + F;
202-282 }
202-283
202-284
202-285 if (A < = B)
202-286 {
202-287 A = B + C;
202-288 D = E + F;
202-289 }
202-290
202-291 A = B+C;
202-292 A = B+C;
202-293 A = 0x0002;
202-294 A = B-C;
202-295 A = B+C;
202-296
202-297 if (A > = B)
202-298 {
202-299 A = B + C;
202-300 D = E + F;
202-301 }
202-302
202-303 A = B*C;
202-304 A = B-C;
202-305 A = B+C;
202-306 A = B+C;
202-307 A = B+C;
202-308
202-309 if (A == B)
202-310 {
202-311 A = B + C;
202-312 D = E + F;
202-313 }
202-314
202-315 // max LOC 24
202-316
202-317 }
202-318
202 202 Result: result/source/ft-app/ft-app-B1.0/sys/sys-04.c
203 203 Source: source/ft-app/ft-app-B1.0/sys/sys-05.c
203-0 /*
203-1 ----------------------------------------------------------------------------
203-2 --| BEGIN PROLOGUE
203-3 --|
203-4 --| CLASSIFICATION: UNCLASSIFIED
203-5 --|
203-6 --| FILE NAME: sys-05.c
203-7 --|
203-8 --| ABSTRACT:
203-9 --| This file contains the 3 functions that do file sys stuff.
203-10 --|
203-11 --| HISTORY:
203-12 --| CCCQ_NAME:
203-13 --| CCCQ_VER:
203-14 --|
203-15 --| END PROLOGUE
203-16 ----------------------------------------------------------------------------
203-17 */
203-18
203-19 int A;
203-20 #include C;
203-21 #define C;
203-22 #define A;
203-23 #include C;
203-24 float B;
203-25 #include B;
203-26 #define A;
203-27 #include B;
203-28
203-29
203-30
203-31 /*
203-32 -----------------------------------------------------------------------------
203-33 --| NAME: sys.5.1
203-34 --|
203-35 --| ABSTRACT:
203-36 --| This function does sys stuff.
203-37 --|
203-38 --| RETURNS:
203-39 --| NONE.
203-40 --|
203-41 ----------------------------------------------------------------------------
203-42 */
203-43 static void sys.5.1(void)
203-44 {
203-45 A = B/C;
203-46 A = B-C;
203-47
203-48 if (A > B)
203-49 {
203-50 A = B + C;
203-51 D = E + F;
203-52 }
203-53
203-54 A = B*C;
203-55 A = B/C;
203-56 /* dead_code = B + C; */
203-57 A = B+C;
203-58 A = B-C;
203-59 A = B+C;
203-60 A = B+C;
203-61 A = B-C;
203-62
203-63 if (A < = B)
203-64 {
203-65 A = B + C;
203-66 D = E + F;
203-67 }
203-68
203-69 A = B+C;
203-70 A = B-C;
203-71 A = B+C;
203-72 A = B/C;
203-73 /* LE SV TOC-3618 this a sys-05.1.16 req */
203-74 A = B*C;
203-75 A = B*C;
203-76 A = B/C;
203-77 A = B+C;
203-78 A = B-C;
203-79 A = B/C;
203-80 A = B+C;
203-81 A = B+C;
203-82 A = B-C;
203-83 A = B+C;
203-84 A = B*C;
203-85 A = B*C;
203-86 A = B-C;
203-87 A = B*C;
203-88 A = B-C;
203-89 A = B-C;
203-90 A = B/C;
203-91
203-92 switch (sys stuff)
203-93 {
203-94 case one:
203-95 {
203-96 run_this;
203-97 break;
203-98 }
203-99 case two:
203-100 {
203-101 run_this;
203-102 break;
203-103 }
203-104 default:
203-105 {
203-106 // missing error call
203-107 }
203-108 }
203-109
203-110 A = B/C;
203-111 A = B-C;
203-112 A = B/C;
203-113 FreePtr = HmiStringPtr;
203-114
203-115 if (A ge B)
203-116 {
203-117 A = B + C;
203-118 D = E + F;
203-119 }
203-120
203-121 A = B/C;
203-122
203-123 if (A ne B)
203-124 {
203-125 A = B + C;
203-126 D = E + F;
203-127 }
203-128
203-129 A = B-C;
203-130 A = B-C;
203-131 A = B+C;
203-132 A = B-C;
203-133 A = B*C;
203-134 A = B+C;
203-135 A = B+C;
203-136 A = B*C;
203-137
203-138 if (A == B)
203-139 {
203-140 A = B + C;
203-141 D = E + F;
203-142 }
203-143
203-144 A = B/C;
203-145
203-146 if (A > B)
203-147 {
203-148 A = B + C;
203-149 D = E + F;
203-150 }
203-151
203-152 A = B-C;
203-153
203-154 if (A > = B)
203-155 {
203-156 A = B + C;
203-157 D = E + F;
203-158 }
203-159
203-160 A = B/C;
203-161 A = B*C;
203-162 A = B/C;
203-163 A = B-C;
203-164 A = B-C;
203-165 A = B/C;
203-166 A = B-C;
203-167
203-168 if (A < = B)
203-169 {
203-170 A = B + C;
203-171 D = E + F;
203-172 }
203-173
203-174 A = B*C;
203-175 A = B+C;
203-176 A = B+C;
203-177
203-178 switch (sys stuff)
203-179 {
203-180 case one:
203-181 {
203-182 run_this;
203-183 break;
203-184 }
203-185 case two:
203-186 {
203-187 run_this;
203-188 break;
203-189 }
203-190 default:
203-191 {
203-192 SwError;
203-193 }
203-194 }
203-195
203-196 // max LOC 63
203-197
203-198 }
203-199
203-200
203-201 /*
203-202 -----------------------------------------------------------------------------
203-203 --| NAME: sys.5.2
203-204 --|
203-205 --| ABSTRACT:
203-206 --| This function does sys stuff.
203-207 --|
203-208 --| RETURNS:
203-209 --| NONE.
203-210 --|
203-211 ----------------------------------------------------------------------------
203-212 */
203-213 static void sys.5.2(void)
203-214 {
203-215 A = B-C;
203-216 A = B*C;
203-217 A = B-C;
203-218
203-219 if (A lt B)
203-220 {
203-221 A = B + C;
203-222 D = E + F;
203-223 }
203-224
203-225 A = B+C;
203-226
203-227 if (A lt B)
203-228 {
203-229 A = B + C;
203-230 D = E + F;
203-231 }
203-232
203-233 A = B*C;
203-234
203-235 if (A le B)
203-236 {
203-237 A = B + C;
203-238 D = E + F;
203-239 }
203-240
203-241
203-242 if (A ne B)
203-243 {
203-244 A = B + C;
203-245 D = E + F;
203-246 }
203-247
203-248 A = B+C;
203-249
203-250 if (A > = B)
203-251 {
203-252 A = B + C;
203-253 D = E + F;
203-254 }
203-255
203-256 A = B*C;
203-257 A = B-C;
203-258 A = B*C;
203-259 A = B-C;
203-260 A = B/C;
203-261 A = B-C;
203-262 A = B*C;
203-263 A = B+C;
203-264
203-265 if (A == B)
203-266 {
203-267 A = B + C;
203-268 D = E + F;
203-269 }
203-270
203-271 A = B/C;
203-272 A = B/C;
203-273
203-274 if (A == B)
203-275 {
203-276 A = B + C;
203-277 D = E + F;
203-278 }
203-279
203-280 A = B/C;
203-281 A = B-C;
203-282 A = B+C;
203-283 A = B+C;
203-284
203-285 #ifdef LAZY
203-286 // this is not nice
203-287 A = B + C;
203-288 A = B + C;
203-289 #endif
203-290
203-291 A = B*C;
203-292
203-293 if (A < = B)
203-294 {
203-295 A = B + C;
203-296 D = E + F;
203-297 }
203-298
203-299
203-300 if (A == B)
203-301 {
203-302 A = B + C;
203-303 D = E + F;
203-304 }
203-305
203-306 A = B+C;
203-307 A = B/C;
203-308 A = B*C;
203-309 A = B/C;
203-310 A = B*C;
203-311 A = B-C;
203-312 A = B/C;
203-313 A = B-C;
203-314 A = B-C;
203-315 A = B+C;
203-316 A = B+C;
203-317 A = B+C;
203-318 A = B+C;
203-319 A = B/C;
203-320
203-321 switch (sys stuff)
203-322 {
203-323 case one:
203-324 {
203-325 switch (nested)
203-326 {
203-327 case:
203-328 X = Y + Z;
203-329 case:
203-330 X = Y + Z;
203-331 default:
203-332 SwError;
203-333 }
203-334 }
203-335 case two:
203-336 {
203-337 run_this;
203-338 break;
203-339 }
203-340 default:
203-341 {
203-342 SwError;
203-343 }
203-344 }
203-345
203-346
203-347 if (A lt B)
203-348 {
203-349 A = B + C;
203-350 D = E + F;
203-351 }
203-352
203-353 A = B-C;
203-354 A = B/C;
203-355 A = B*C;
203-356 A = B+C;
203-357 A = B-C;
203-358 A = B-C;
203-359 A = B*C;
203-360
203-361 if (A le B)
203-362 {
203-363 A = B + C;
203-364 D = E + F;
203-365 }
203-366
203-367 A = B*C;
203-368 A = B+C;
203-369 A = B+C;
203-370
203-371 if (A le B)
203-372 {
203-373 A = B + C;
203-374 D = E + F;
203-375 }
203-376
203-377 A = B+C;
203-378 A = B/C;
203-379
203-380 if (A < B)
203-381 {
203-382 A = B + C;
203-383 D = E + F;
203-384 }
203-385
203-386 A = B+C;
203-387
203-388 if (A > = B)
203-389 {
203-390 A = B + C;
203-391 D = E + F;
203-392 }
203-393
203-394
203-395 switch (sys stuff)
203-396 {
203-397 case one:
203-398 {
203-399 switch (nested)
203-400 {
203-401 case:
203-402 X = Y + Z;
203-403 case:
203-404 X = Y + Z;
203-405 default:
203-406 SwError;
203-407 }
203-408 }
203-409 case two:
203-410 {
203-411 run_this;
203-412 break;
203-413 }
203-414 default:
203-415 {
203-416 SwError;
203-417 }
203-418 }
203-419
203-420 A = B*C;
203-421 A = B-C;
203-422 do forever;
203-423
203-424 if (A gt B)
203-425 {
203-426 A = B + C;
203-427 D = E + F;
203-428 }
203-429
203-430 A = B-C;
203-431 A = B+C;
203-432 A = B+C;
203-433
203-434 if (A eq B)
203-435 {
203-436 A = B + C;
203-437 D = E + F;
203-438 }
203-439
203-440 // max LOC 69
203-441
203-442 }
203-443
203-444
203-445 /*
203-446 -----------------------------------------------------------------------------
203-447 --| NAME: sys.5.3
203-448 --|
203-449 --| ABSTRACT:
203-450 --| This function does sys stuff.
203-451 --|
203-452 --| RETURNS:
203-453 --| NONE.
203-454 --|
203-455 ----------------------------------------------------------------------------
203-456 */
203-457 static void sys.5.3(void)
203-458 {
203-459 A = B+C;
203-460
203-461 if (A > B)
203-462 {
203-463 A = B + C;
203-464 D = E + F;
203-465 }
203-466
203-467 /* LE SV TOC-3619 this a sys-05.3.3 req */
203-468 A = B+C;
203-469 /* LE SV TOC-3620 this a sys-05.3.4 req */
203-470 A = B/C;
203-471
203-472 if (A < B)
203-473 {
203-474 A = B + C;
203-475 D = E + F;
203-476 }
203-477
203-478 A = B/C;
203-479
203-480 if (A lt B)
203-481 {
203-482 A = B + C;
203-483 D = E + F;
203-484 }
203-485
203-486 A = B+C;
203-487 A = B*C;
203-488 A = B+C;
203-489
203-490 if (A ne B)
203-491 {
203-492 A = B + C;
203-493 D = E + F;
203-494 }
203-495
203-496 A = B/C;
203-497 A = B*C;
203-498 A = B*C;
203-499 A = B-C;
203-500 A = B-C;
203-501 A = B+C;
203-502
203-503 if (A gt B)
203-504 {
203-505 A = B + C;
203-506 D = E + F;
203-507 }
203-508
203-509 A = B+C;
203-510
203-511 if (A ne B)
203-512 {
203-513 A = B + C;
203-514 D = E + F;
203-515 }
203-516
203-517 A = 0x0008;
203-518 A = B*C;
203-519 A = B/C;
203-520 A = B*C;
203-521 A = B+C;
203-522 A = B/C;
203-523 A = B-C;
203-524 A = B-C;
203-525 A = B+C;
203-526 /* LE SV TOC-3621 this a sys-05.3.29 req */
203-527 A = B*C;
203-528 A = B*C;
203-529 A = B*C;
203-530 A = B/C;
203-531
203-532 if (A == B)
203-533 {
203-534 A = B + C;
203-535 D = E + F;
203-536 }
203-537
203-538 A = B-C;
203-539 A = B/C;
203-540 A = B-C;
203-541 A = B*C;
203-542 /* LE SV TOC-3622 this a sys-05.3.38 req */
203-543 A = B/C;
203-544 A = B-C;
203-545 A = B-C;
203-546 A = B-C;
203-547 // max LOC 41
203-548
203-549 }
203-550
203 203 Result: result/source/ft-app/ft-app-B1.0/sys/sys-05.c
204 204 Source: source/ft-app/ft-app-B1.0/wxp/wxp-01.c
204-0 /*
204-1 ----------------------------------------------------------------------------
204-2 --| BEGIN PROLOGUE
204-3 --|
204-4 --| CLASSIFICATION: UNCLASSIFIED
204-5 --|
204-6 --| FILE NAME: wxp-01.c
204-7 --|
204-8 --| ABSTRACT:
204-9 --| This file contains the 3 functions that do file wxp stuff.
204-10 --|
204-11 --| HISTORY:
204-12 --| CCCQ_NAME:
204-13 --| CCCQ_VER:
204-14 --|
204-15 --| END PROLOGUE
204-16 ----------------------------------------------------------------------------
204-17 */
204-18
204-19 #define D;
204-20 char D;
204-21 #include C;
204-22 float B;
204-23
204-24
204-25
204-26 /*
204-27 -----------------------------------------------------------------------------
204-28 --| NAME: wxp.1.1
204-29 --|
204-30 --| ABSTRACT:
204-31 --| This function does wxp stuff.
204-32 --|
204-33 --| RETURNS:
204-34 --| NONE.
204-35 --|
204-36 ----------------------------------------------------------------------------
204-37 */
204-38 static void wxp.1.1(void)
204-39 {
204-40 A = B*C;
204-41 A = B+C;
204-42 A = B-C;
204-43 A = B*C;
204-44 A = B/C;
204-45 A = B-C;
204-46 A = B*C;
204-47 A = B/C;
204-48 A = B-C;
204-49 A = B*C;
204-50 A = B+C;
204-51 A = B+C;
204-52
204-53 if (A > = B)
204-54 {
204-55 A = B + C;
204-56 D = E + F;
204-57 }
204-58
204-59 A = B-C;
204-60 A = B-C;
204-61 A = B*C;
204-62 A = B/C;
204-63 A = B-C;
204-64 A = B*C;
204-65
204-66 if (A < = B)
204-67 {
204-68 A = B + C;
204-69 D = E + F;
204-70 }
204-71
204-72 A = B*C;
204-73 A = B+C;
204-74 A = B+C;
204-75 A = 0x0008;
204-76
204-77 if (A gt B)
204-78 {
204-79 A = B + C;
204-80 D = E + F;
204-81 }
204-82
204-83
204-84 if (A == B)
204-85 {
204-86 A = B + C;
204-87 D = E + F;
204-88 }
204-89
204-90 A = B-C;
204-91 A = B*C;
204-92 A = B*C;
204-93 A = 0x0004;
204-94 A = B-C;
204-95
204-96 if (A le B)
204-97 {
204-98 A = B + C;
204-99 D = E + F;
204-100 }
204-101
204-102 A = B*C;
204-103 A = B+C;
204-104 A = B+C;
204-105 A = B-C;
204-106 A = B-C;
204-107 A = B/C;
204-108 A = B-C;
204-109 A = B*C;
204-110 A = B/C;
204-111 A = B+C;
204-112 A = B/C;
204-113 A = B+C;
204-114 A = B-C;
204-115
204-116 if (A > = B)
204-117 {
204-118 A = B + C;
204-119 D = E + F;
204-120 }
204-121
204-122
204-123 if (A ne B)
204-124 {
204-125 A = B + C;
204-126 D = E + F;
204-127 }
204-128
204-129 A = B*C;
204-130
204-131 if (A ge B)
204-132 {
204-133 A = B + C;
204-134 D = E + F;
204-135 }
204-136
204-137 A = B-C;
204-138 A = B*C;
204-139 // max LOC 49
204-140
204-141 }
204-142
204-143
204-144 /*
204-145 -----------------------------------------------------------------------------
204-146 --| NAME: wxp.1.2
204-147 --|
204-148 --| ABSTRACT:
204-149 --| This function does wxp stuff.
204-150 --|
204-151 --| RETURNS:
204-152 --| NONE.
204-153 --|
204-154 ----------------------------------------------------------------------------
204-155 */
204-156 static void wxp.1.2(void)
204-157 {
204-158 A = B/C;
204-159 A = B-C;
204-160 A = B*C;
204-161 A = B+C;
204-162 A = B+C;
204-163 /* LE SV TOC-3801 this a wxp-01.2.6 req */
204-164 A = B-C;
204-165
204-166 if (A == B)
204-167 {
204-168 A = B + C;
204-169 D = E + F;
204-170 }
204-171
204-172 A = B*C;
204-173 A = B-C;
204-174 A = B-C;
204-175 A = B-C;
204-176 A = B+C;
204-177 A = B/C;
204-178
204-179 if (A > B)
204-180 {
204-181 A = B + C;
204-182 D = E + F;
204-183 }
204-184
204-185
204-186 if (A eq B)
204-187 {
204-188 A = B + C;
204-189 D = E + F;
204-190 }
204-191
204-192 A = B/C;
204-193 A = B*C;
204-194 A = B+C;
204-195
204-196 if (A > = B)
204-197 {
204-198 A = B + C;
204-199 D = E + F;
204-200 }
204-201
204-202 /* LE SV TOC-3802 this a wxp-01.2.20 req */
204-203 A = B/C;
204-204 A = B-C;
204-205 A = B/C;
204-206 /* LE SV TOC-3803 this a wxp-01.2.23 req */
204-207 A = B*C;
204-208 A = B*C;
204-209 A = B/C;
204-210 A = B/C;
204-211 A = B-C;
204-212 A = B-C;
204-213 A = B*C;
204-214
204-215 if (A lt B)
204-216 {
204-217 A = B + C;
204-218 D = E + F;
204-219 }
204-220
204-221
204-222 if (A < = B)
204-223 {
204-224 A = B + C;
204-225 D = E + F;
204-226 }
204-227
204-228 A = B*C;
204-229 A = B*C;
204-230 A = B*C;
204-231 A = B-C;
204-232 FreePtr = HmiStringPtr;
204-233 A = B-C;
204-234 A = B/C;
204-235 A = B-C;
204-236 A = B+C;
204-237 A = B+C;
204-238
204-239 if (A == B)
204-240 {
204-241 A = B + C;
204-242 D = E + F;
204-243 }
204-244
204-245 A = B*C;
204-246 A = B*C;
204-247
204-248 if (A le B)
204-249 {
204-250 A = B + C;
204-251 D = E + F;
204-252 }
204-253
204-254
204-255 if (A ge B)
204-256 {
204-257 A = B + C;
204-258 D = E + F;
204-259 }
204-260
204-261 A = B-C;
204-262 A = B*C;
204-263 A = B/C;
204-264 A = B*C;
204-265 /* LE SV TOC-3804 this a wxp-01.2.50 req */
204-266 A = B+C;
204-267 A = B-C;
204-268
204-269 if {
204-270 X = Y + Z;
204-271 }
204-272 else {
204-273 halt;
204-274 }
204-275
204-276
204-277 if (A lt B)
204-278 {
204-279 A = B + C;
204-280 D = E + F;
204-281 }
204-282
204-283 A = B+C;
204-284 A = B-C;
204-285 A = B+C;
204-286
204-287 if (A > = B)
204-288 {
204-289 A = B + C;
204-290 D = E + F;
204-291 }
204-292
204-293 A = B-C;
204-294 A = B/C;
204-295
204-296 switch (wxp stuff)
204-297 {
204-298 case one:
204-299 {
204-300 run_this;
204-301 break;
204-302 }
204-303 case two:
204-304 {
204-305 run_this;
204-306 break;
204-307 }
204-308 default:
204-309 {
204-310 // missing error call
204-311 }
204-312 }
204-313
204-314 A = B+C;
204-315 A = B/C;
204-316 A = B*C;
204-317
204-318 if (A le B)
204-319 {
204-320 A = B + C;
204-321 D = E + F;
204-322 }
204-323
204-324 A = B-C;
204-325 A = B/C;
204-326
204-327 if (A ge B)
204-328 {
204-329 A = B + C;
204-330 D = E + F;
204-331 }
204-332
204-333 A = B*C;
204-334
204-335 if (A > B)
204-336 {
204-337 A = B + C;
204-338 D = E + F;
204-339 }
204-340
204-341 A = B-C;
204-342
204-343 if (A ge B)
204-344 {
204-345 A = B + C;
204-346 D = E + F;
204-347 }
204-348
204-349
204-350 if (A > B)
204-351 {
204-352 A = B + C;
204-353 D = E + F;
204-354 }
204-355
204-356 A = B+C;
204-357 A = B-C;
204-358 A = B+C;
204-359 /* LE SV TOC-3805 this a wxp-01.2.74 req */
204-360
204-361 if (A != B)
204-362 {
204-363 A = B + C;
204-364 D = E + F;
204-365 }
204-366
204-367
204-368 if (A lt B)
204-369 {
204-370 A = B + C;
204-371 D = E + F;
204-372 }
204-373
204-374 A = B-C;
204-375 A = B*C;
204-376 // max LOC 77
204-377
204-378 }
204-379
204-380
204-381 /*
204-382 -----------------------------------------------------------------------------
204-383 --| NAME: wxp.1.3
204-384 --|
204-385 --| ABSTRACT:
204-386 --| This function does wxp stuff.
204-387 --|
204-388 --| RETURNS:
204-389 --| NONE.
204-390 --|
204-391 ----------------------------------------------------------------------------
204-392 */
204-393 static void wxp.1.3(void)
204-394 {
204-395 A = B*C;
204-396 A = B+C;
204-397 A = B/C;
204-398 A = B-C;
204-399 A = B*C;
204-400
204-401 switch (wxp stuff)
204-402 {
204-403 case one:
204-404 {
204-405 run_this;
204-406 break;
204-407 }
204-408 case two:
204-409 {
204-410 run_this;
204-411 break;
204-412 }
204-413 default:
204-414 {
204-415 SwError;
204-416 }
204-417 }
204-418
204-419 A = B*C;
204-420 A = B+C;
204-421 A = B-C;
204-422 A = B-C;
204-423 A = B*C;
204-424 A = B+C;
204-425 A = B*C;
204-426 A = B+C;
204-427 // max LOC 14
204-428
204-429 }
204-430
204 204 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-01.c
205 205 Source: source/ft-app/ft-app-B1.0/wxp/wxp-02.c
205-0 /*
205-1 ----------------------------------------------------------------------------
205-2 --| BEGIN PROLOGUE
205-3 --|
205-4 --| CLASSIFICATION: UNCLASSIFIED
205-5 --|
205-6 --| FILE NAME: wxp-02.c
205-7 --|
205-8 --| ABSTRACT:
205-9 --| This file contains the 4 functions that do file wxp stuff.
205-10 --|
205-11 --| HISTORY:
205-12 --| CCCQ_NAME:
205-13 --| CCCQ_VER:
205-14 --|
205-15 --| END PROLOGUE
205-16 ----------------------------------------------------------------------------
205-17 */
205-18
205-19 char D;
205-20 int A;
205-21 #include D;
205-22 #include D;
205-23 #define C;
205-24
205-25
205-26
205-27 /*
205-28 -----------------------------------------------------------------------------
205-29 --| NAME: wxp.2.1
205-30 --|
205-31 --| ABSTRACT:
205-32 --| This function does wxp stuff.
205-33 --|
205-34 --| RETURNS:
205-35 --| NONE.
205-36 --|
205-37 ----------------------------------------------------------------------------
205-38 */
205-39 static void wxp.2.1(void)
205-40 {
205-41 A = B-C;
205-42 A = B/C;
205-43 A = B*C;
205-44 A = B*C;
205-45
205-46 if (A > = B)
205-47 {
205-48 A = B + C;
205-49 D = E + F;
205-50 }
205-51
205-52
205-53 if (A ge B)
205-54 {
205-55 A = B + C;
205-56 D = E + F;
205-57 }
205-58
205-59 rcv_buffer = (U16 *) alloc(size+1);
205-60
205-61 if (A < B)
205-62 {
205-63 A = B + C;
205-64 D = E + F;
205-65 }
205-66
205-67
205-68 if (A > B)
205-69 {
205-70 A = B + C;
205-71 D = E + F;
205-72 }
205-73
205-74
205-75 if (A > = B)
205-76 {
205-77 A = B + C;
205-78 D = E + F;
205-79 }
205-80
205-81
205-82 if (A eq B)
205-83 {
205-84 A = B + C;
205-85 D = E + F;
205-86 }
205-87
205-88 A = B+C;
205-89 A = B/C;
205-90 A = B/C;
205-91 A = B*C;
205-92 // max LOC 14
205-93
205-94 }
205-95
205-96
205-97 /*
205-98 -----------------------------------------------------------------------------
205-99 --| NAME: wxp.2.2
205-100 --|
205-101 --| ABSTRACT:
205-102 --| This function does wxp stuff.
205-103 --|
205-104 --| RETURNS:
205-105 --| NONE.
205-106 --|
205-107 ----------------------------------------------------------------------------
205-108 */
205-109 static void wxp.2.2(void)
205-110 {
205-111 A = B-C;
205-112 A = B+C;
205-113 A = B+C;
205-114
205-115 if (A lt B)
205-116 {
205-117 A = B + C;
205-118 D = E + F;
205-119 }
205-120
205-121
205-122 if (A eq B)
205-123 {
205-124 A = B + C;
205-125 D = E + F;
205-126 }
205-127
205-128 A = B*C;
205-129
205-130 if (A ne B)
205-131 {
205-132 A = B + C;
205-133 D = E + F;
205-134 }
205-135
205-136 A = B/C;
205-137 A = B/C;
205-138 A = B-C;
205-139 A = B+C;
205-140 A = B*C;
205-141 A = B-C;
205-142 A = B*C;
205-143 /* LE SV TOC-3806 this a wxp-02.2.15 req */
205-144 A = B-C;
205-145 A = B*C;
205-146 A = B-C;
205-147 A = B-C;
205-148 A = B*C;
205-149 /* LE SV TOC-3807 this a wxp-02.2.20 req */
205-150 A = B*C;
205-151 A = (int)B + C;
205-152 A = B+C;
205-153 A = B*C;
205-154 A = B-C;
205-155 A = B+C;
205-156 A = B*C;
205-157 A = B/C;
205-158 A = B+C;
205-159 A = B*C;
205-160 A = B/C;
205-161 A = B+C;
205-162 A = B+C;
205-163 A = B*C;
205-164 A = B-C;
205-165 A = B*C;
205-166 A = B-C;
205-167 A = B+C;
205-168
205-169 if (A lt B)
205-170 {
205-171 A = B + C;
205-172 D = E + F;
205-173 }
205-174
205-175 A = B/C;
205-176 A = B+C;
205-177 A = B/C;
205-178
205-179 if (A > = B)
205-180 {
205-181 A = B + C;
205-182 D = E + F;
205-183 }
205-184
205-185
205-186 if ($wxp stuff > $otherwxp stuff)
205-187 /* LE SV TOC-008 we really should log all error calls */
205-188 {
205-189 A = B + C;
205-190 }
205-191
205-192 A = B/C;
205-193 A = B+C;
205-194 A = B+C;
205-195 A = B+C;
205-196 A = B/C;
205-197 A = B*C;
205-198 // max LOC 47
205-199
205-200 }
205-201
205-202
205-203 /*
205-204 -----------------------------------------------------------------------------
205-205 --| NAME: wxp.2.3
205-206 --|
205-207 --| ABSTRACT:
205-208 --| This function does wxp stuff.
205-209 --|
205-210 --| RETURNS:
205-211 --| NONE.
205-212 --|
205-213 ----------------------------------------------------------------------------
205-214 */
205-215 static void wxp.2.3(void)
205-216 {
205-217 A = B/C;
205-218 A = 0x0008;
205-219 A = B+C;
205-220 A = B*C;
205-221 A = B-C;
205-222 A = B*C;
205-223 A = B/C;
205-224 A = B-C;
205-225
205-226 if (A le B)
205-227 {
205-228 A = B + C;
205-229 D = E + F;
205-230 }
205-231
205-232 A = B+C;
205-233 A = B*C;
205-234 A = B+C;
205-235 A = B/C;
205-236
205-237 if (A ne B)
205-238 {
205-239 A = B + C;
205-240 D = E + F;
205-241 }
205-242
205-243 A = B+C;
205-244
205-245 if (A ge B)
205-246 {
205-247 A = B + C;
205-248 D = E + F;
205-249 }
205-250
205-251 A = B-C;
205-252
205-253 if (A > = B)
205-254 {
205-255 A = B + C;
205-256 D = E + F;
205-257 }
205-258
205-259 A = B/C;
205-260 A = B-C;
205-261 A = B+C;
205-262 A = B*C;
205-263 A = B-C;
205-264 A = B-C;
205-265 A = B*C;
205-266 A = B+C;
205-267 A = B*C;
205-268 A = B/C;
205-269 A = 0x0001;
205-270 A = B-C;
205-271 A = B-C;
205-272 A = B*C;
205-273 A = B-C;
205-274 A = B*C;
205-275 A = B*C;
205-276 A = B*C;
205-277 A = B-C;
205-278 A = B-C;
205-279 A = B+C;
205-280 A = B*C;
205-281 A = B+C;
205-282
205-283 if (A > = B)
205-284 {
205-285 A = B + C;
205-286 D = E + F;
205-287 }
205-288
205-289 A = B+C;
205-290 A = B/C;
205-291 A = B*C;
205-292 A = B*C;
205-293
205-294 if (A == B)
205-295 {
205-296 A = B + C;
205-297 D = E + F;
205-298 }
205-299
205-300
205-301 if (A eq B)
205-302 {
205-303 A = B + C;
205-304 D = E + F;
205-305 }
205-306
205-307 /* LE SV TOC-3808 this a wxp-02.3.47 req */
205-308 A = B+C;
205-309 A = B/C;
205-310 A = B+C;
205-311 A = B/C;
205-312 A = B/C;
205-313
205-314 if (A ge B)
205-315 {
205-316 A = B + C;
205-317 D = E + F;
205-318 }
205-319
205-320
205-321 if (A < = B)
205-322 {
205-323 A = B + C;
205-324 D = E + F;
205-325 }
205-326
205-327 A = B+C;
205-328 // max LOC 54
205-329
205-330 }
205-331
205-332
205-333 /*
205-334 -----------------------------------------------------------------------------
205-335 --| NAME: wxp.2.4
205-336 --|
205-337 --| ABSTRACT:
205-338 --| This function does wxp stuff.
205-339 --|
205-340 --| RETURNS:
205-341 --| NONE.
205-342 --|
205-343 ----------------------------------------------------------------------------
205-344 */
205-345 static void wxp.2.4(void)
205-346 {
205-347 A = B*C;
205-348 A = B+C;
205-349 A = B-C;
205-350 A = B*C;
205-351
205-352 if (A ge B)
205-353 {
205-354 A = B + C;
205-355 D = E + F;
205-356 }
205-357
205-358 A = B-C;
205-359 A = B-C;
205-360 A = B+C;
205-361
205-362 if (A < B)
205-363 {
205-364 A = B + C;
205-365 D = E + F;
205-366 }
205-367
205-368 A = B+C;
205-369 A = B-C;
205-370
205-371 if (A < B)
205-372 {
205-373 A = B + C;
205-374 D = E + F;
205-375 }
205-376
205-377 A = B+C;
205-378 A = B/C;
205-379 A = B-C;
205-380 A = B+C;
205-381 A = B*C;
205-382 A = B*C;
205-383 A = B+C;
205-384 A = B-C;
205-385 A = B/C;
205-386 A = B+C;
205-387 A = B*C;
205-388 A = B-C;
205-389 A = B-C;
205-390
205-391 if (A eq B)
205-392 {
205-393 A = B + C;
205-394 D = E + F;
205-395 }
205-396
205-397 A = B+C;
205-398
205-399 if (A < = B)
205-400 {
205-401 A = B + C;
205-402 D = E + F;
205-403 }
205-404
205-405 A = B-C;
205-406 A = B-C;
205-407 A = B*C;
205-408
205-409 if (A gt B)
205-410 {
205-411 A = B + C;
205-412 D = E + F;
205-413 }
205-414
205-415 A = B*C;
205-416 A = B+C;
205-417 A = B+C;
205-418 A = B+C;
205-419 A = B+C;
205-420 A = B/C;
205-421
205-422 switch (wxp stuff)
205-423 {
205-424 case one:
205-425 {
205-426 run_this;
205-427 break;
205-428 }
205-429 case two:
205-430 {
205-431 run_this;
205-432 break;
205-433 }
205-434 default:
205-435 {
205-436 SwError;
205-437 }
205-438 }
205-439
205-440 /* LE SV TOC-3809 this a wxp-02.4.40 req */
205-441 A = B-C;
205-442
205-443 if (A == B)
205-444 {
205-445 A = B + C;
205-446 D = E + F;
205-447 }
205-448
205-449 A = B/C;
205-450 A = B+C;
205-451
205-452 if (A ne B)
205-453 {
205-454 A = B + C;
205-455 D = E + F;
205-456 }
205-457
205-458 A = B-C;
205-459 /* LE SV TOC-3810 this a wxp-02.4.46 req */
205-460
205-461 if (A eq B)
205-462 {
205-463 A = B + C;
205-464 D = E + F;
205-465 }
205-466
205-467 A = B+C;
205-468 A = B/C;
205-469 A = B*C;
205-470 A = B*C;
205-471 A = B*C;
205-472 A = B*C;
205-473 /* LE SV TOC-3811 this a wxp-02.4.53 req */
205-474 A = B/C;
205-475 A = B/C;
205-476 A = B*C;
205-477 A = B+C;
205-478 A = B*C;
205-479 A = B/C;
205-480 A = B-C;
205-481 A = B/C;
205-482 A = B-C;
205-483 A = B+C;
205-484 A = B*C;
205-485
205-486 if (A eq B)
205-487 {
205-488 A = B + C;
205-489 D = E + F;
205-490 }
205-491
205-492 A = B*C;
205-493 A = 0x0006;
205-494 A = B+C;
205-495 // max LOC 66
205-496
205-497 }
205-498
205 205 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-02.c
206 206 Source: source/ft-app/ft-app-B1.0/wxp/wxp-03.c
206-0 /*
206-1 ----------------------------------------------------------------------------
206-2 --| BEGIN PROLOGUE
206-3 --|
206-4 --| CLASSIFICATION: UNCLASSIFIED
206-5 --|
206-6 --| FILE NAME: wxp-03.c
206-7 --|
206-8 --| ABSTRACT:
206-9 --| This file contains the 2 functions that do file wxp stuff.
206-10 --|
206-11 --| HISTORY:
206-12 --| CCCQ_NAME:
206-13 --| CCCQ_VER:
206-14 --|
206-15 --| END PROLOGUE
206-16 ----------------------------------------------------------------------------
206-17 */
206-18
206-19 #include D;
206-20 #define C;
206-21 int A;
206-22
206-23
206-24
206-25 /*
206-26 -----------------------------------------------------------------------------
206-27 --| NAME: wxp.3.1
206-28 --|
206-29 --| ABSTRACT:
206-30 --| This function does wxp stuff.
206-31 --|
206-32 --| RETURNS:
206-33 --| NONE.
206-34 --|
206-35 ----------------------------------------------------------------------------
206-36 */
206-37 static void wxp.3.1(void)
206-38 {
206-39 A = B/C;
206-40
206-41 #ifdef LAZY
206-42 // this is not nice
206-43 A = B + C;
206-44 A = B + C;
206-45 #endif
206-46
206-47 A = B/C;
206-48 /* LE SV TOC-3812 this a wxp-03.1.3 req */
206-49 A = B/C;
206-50 A = B-C;
206-51 A = B+C;
206-52 A = B/C;
206-53 A = B+C;
206-54 A = B+C;
206-55 A = B*C;
206-56 A = B-C;
206-57 A = B-C;
206-58 A = B/C;
206-59 A = B/C;
206-60 A = B/C;
206-61 A = B/C;
206-62
206-63 if (A == B)
206-64 {
206-65 A = B + C;
206-66 D = E + F;
206-67 }
206-68
206-69 A = B-C;
206-70
206-71 if (A ne B)
206-72 {
206-73 A = B + C;
206-74 D = E + F;
206-75 }
206-76
206-77 A = B*C;
206-78 A = B*C;
206-79 /* LE SV TOC-3813 this a wxp-03.1.21 req */
206-80 A = B/C;
206-81 A = 0x0007;
206-82 A = B+C;
206-83
206-84 if (A lt B)
206-85 {
206-86 A = B + C;
206-87 D = E + F;
206-88 }
206-89
206-90 A = B/C;
206-91 A = B*C;
206-92
206-93 if (A < = B)
206-94 {
206-95 A = B + C;
206-96 D = E + F;
206-97 }
206-98
206-99 A = B+C;
206-100 free(FreePtr);
206-101 A = B-C;
206-102 A = B+C;
206-103 A = B+C;
206-104 A = B-C;
206-105
206-106 switch (wxp stuff)
206-107 {
206-108 case one:
206-109 {
206-110 run_this;
206-111 break;
206-112 }
206-113 case two:
206-114 {
206-115 run_this;
206-116 break;
206-117 }
206-118 default:
206-119 {
206-120 SwError;
206-121 }
206-122 }
206-123
206-124 A = B-C;
206-125 A = B*C;
206-126 A = B+C;
206-127 // max LOC 35
206-128
206-129 }
206-130
206-131
206-132 /*
206-133 -----------------------------------------------------------------------------
206-134 --| NAME: wxp.3.2
206-135 --|
206-136 --| ABSTRACT:
206-137 --| This function does wxp stuff.
206-138 --|
206-139 --| RETURNS:
206-140 --| NONE.
206-141 --|
206-142 ----------------------------------------------------------------------------
206-143 */
206-144 static void wxp.3.2(void)
206-145 {
206-146
206-147 if (A gt B)
206-148 {
206-149 A = B + C;
206-150 D = E + F;
206-151 }
206-152
206-153 A = B*C;
206-154 A = B*C;
206-155 A = B+C;
206-156 A = B+C;
206-157 A = B/C;
206-158 A = B*C;
206-159 A = B+C;
206-160
206-161 if (A > = B)
206-162 {
206-163 A = B + C;
206-164 D = E + F;
206-165 }
206-166
206-167 A = (long)B + C;
206-168 A = B+C;
206-169 A = B*C;
206-170
206-171 if (A == B)
206-172 {
206-173 A = B + C;
206-174 D = E + F;
206-175 }
206-176
206-177 A = B/C;
206-178 A = B/C;
206-179 A = B+C;
206-180 A = B+C;
206-181 A = B-C;
206-182 A = B-C;
206-183 A = B/C;
206-184 // TBS - I need to figure this out
206-185 A = B*C;
206-186 A = B/C;
206-187 A = B-C;
206-188
206-189 switch (wxp stuff)
206-190 {
206-191 case one:
206-192 {
206-193 run_this;
206-194 break;
206-195 }
206-196 case two:
206-197 {
206-198 run_this;
206-199 break;
206-200 }
206-201 default:
206-202 {
206-203 SwError;
206-204 }
206-205 }
206-206
206-207 A = B-C;
206-208
206-209 if (A ge B)
206-210 {
206-211 A = B + C;
206-212 D = E + F;
206-213 }
206-214
206-215 A = B/C;
206-216
206-217 if (A gt B)
206-218 {
206-219 A = B + C;
206-220 D = E + F;
206-221 }
206-222
206-223
206-224 if (A < B)
206-225 {
206-226 A = B + C;
206-227 D = E + F;
206-228 }
206-229
206-230 A = B+C;
206-231
206-232 if (A ge B)
206-233 {
206-234 A = B + C;
206-235 D = E + F;
206-236 }
206-237
206-238
206-239 switch (wxp stuff)
206-240 {
206-241 case one:
206-242 {
206-243 run_this;
206-244 break;
206-245 }
206-246 case two:
206-247 {
206-248 run_this;
206-249 break;
206-250 }
206-251 default:
206-252 {
206-253 SwError;
206-254 }
206-255 }
206-256
206-257
206-258 if (A gt B)
206-259 {
206-260 A = B + C;
206-261 D = E + F;
206-262 }
206-263
206-264 A = B*C;
206-265 A = B+C;
206-266 A = B+C;
206-267 A = B-C;
206-268 A = B/C;
206-269 A = B/C;
206-270
206-271 if (A != B)
206-272 {
206-273 A = B + C;
206-274 D = E + F;
206-275 }
206-276
206-277 A = B-C;
206-278 A = B*C;
206-279 A = B-C;
206-280 A = B/C;
206-281
206-282 if (A < = B)
206-283 {
206-284 A = B + C;
206-285 D = E + F;
206-286 }
206-287
206-288
206-289 if (A < B)
206-290 {
206-291 A = B + C;
206-292 D = E + F;
206-293 }
206-294
206-295 A = B+C;
206-296 // TBS - I need to figure this out
206-297
206-298 if (A > = B)
206-299 {
206-300 A = B + C;
206-301 D = E + F;
206-302 }
206-303
206-304 A = B*C;
206-305 A = B*C;
206-306 A = B/C;
206-307 A = B*C;
206-308 A = B/C;
206-309 A = B*C;
206-310 A = B-C;
206-311 A = B+C;
206-312 A = B/C;
206-313 A = B/C;
206-314 A = B+C;
206-315
206-316 if (A == B)
206-317 {
206-318 A = B + C;
206-319 D = E + F;
206-320 }
206-321
206-322 /* LE SV TOC-3814 this a wxp-03.2.60 req */
206-323 A = B-C;
206-324 A = B+C;
206-325
206-326 switch (wxp stuff)
206-327 {
206-328 case one:
206-329 {
206-330 run_this;
206-331 break;
206-332 }
206-333 case two:
206-334 {
206-335 run_this;
206-336 break;
206-337 }
206-338 default:
206-339 {
206-340 SwError;
206-341 }
206-342 }
206-343
206-344 A = B+C;
206-345
206-346 if (A gt B)
206-347 {
206-348 A = B + C;
206-349 D = E + F;
206-350 }
206-351
206-352 A = B-C;
206-353 /* LE SV TOC-3815 this a wxp-03.2.66 req */
206-354 A = B*C;
206-355
206-356 if (A ne B)
206-357 {
206-358 A = B + C;
206-359 D = E + F;
206-360 }
206-361
206-362
206-363 if (A lt B)
206-364 {
206-365 A = B + C;
206-366 D = E + F;
206-367 }
206-368
206-369
206-370 if (A ge B)
206-371 {
206-372 A = B + C;
206-373 D = E + F;
206-374 }
206-375
206-376 /* LE SV TOC-3816 this a wxp-03.2.70 req */
206-377 A = B/C;
206-378 A = B+C;
206-379 A = B+C;
206-380
206-381 if (A ge B)
206-382 {
206-383 A = B + C;
206-384 D = E + F;
206-385 }
206-386
206-387 A = B*C;
206-388 // max LOC 74
206-389
206-390 }
206-391
206 206 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-03.c
207 207 Source: source/ft-app/ft-app-B1.0/wxp/wxp-04.c
207-0 /*
207-1 ----------------------------------------------------------------------------
207-2 --| BEGIN PROLOGUE
207-3 --|
207-4 --| CLASSIFICATION: UNCLASSIFIED
207-5 --|
207-6 --| FILE NAME: wxp-04.c
207-7 --|
207-8 --| ABSTRACT:
207-9 --| This file contains the 4 functions that do file wxp stuff.
207-10 --|
207-11 --| HISTORY:
207-12 --| CCCQ_NAME:
207-13 --| CCCQ_VER:
207-14 --|
207-15 --| END PROLOGUE
207-16 ----------------------------------------------------------------------------
207-17 */
207-18
207-19 #include B;
207-20
207-21
207-22
207-23 /*
207-24 -----------------------------------------------------------------------------
207-25 --| NAME: wxp.4.1
207-26 --|
207-27 --| ABSTRACT:
207-28 --| This function does wxp stuff.
207-29 --|
207-30 --| RETURNS:
207-31 --| NONE.
207-32 --|
207-33 ----------------------------------------------------------------------------
207-34 */
207-35 static void wxp.4.1(void)
207-36 {
207-37
207-38 if (A < = B)
207-39 {
207-40 A = B + C;
207-41 D = E + F;
207-42 }
207-43
207-44 A = B-C;
207-45 A = B-C;
207-46 A = B-C;
207-47 A = B*C;
207-48 A = B-C;
207-49
207-50 if (A ge B)
207-51 {
207-52 A = B + C;
207-53 D = E + F;
207-54 }
207-55
207-56 A = B+C;
207-57 A = B-C;
207-58
207-59 if (A > = B)
207-60 {
207-61 A = B + C;
207-62 D = E + F;
207-63 }
207-64
207-65 A = B+C;
207-66 A = B*C;
207-67 A = B/C;
207-68 A = B*C;
207-69
207-70 if (A < B)
207-71 {
207-72 A = B + C;
207-73 D = E + F;
207-74 }
207-75
207-76 A = B+C;
207-77 A = B/C;
207-78 /* LE SV TOC-3817 this a wxp-04.1.18 req */
207-79 A = B-C;
207-80 A = B+C;
207-81 A = B+C;
207-82 A = B*C;
207-83
207-84 if (A le B)
207-85 {
207-86 A = B + C;
207-87 D = E + F;
207-88 }
207-89
207-90 A = B+C;
207-91 A = B*C;
207-92 A = B+C;
207-93 A = B-C;
207-94 /* LE SV TOC-3818 this a wxp-04.1.27 req */
207-95 A = B-C;
207-96 A = B/C;
207-97
207-98 if (A > B)
207-99 {
207-100 A = B + C;
207-101 D = E + F;
207-102 }
207-103
207-104 A = B-C;
207-105 A = B+C;
207-106 /* LE SV TOC-3819 this a wxp-04.1.32 req */
207-107 A = B/C;
207-108 A = B*C;
207-109 A = B-C;
207-110 A = B-C;
207-111 A = B*C;
207-112 A = B/C;
207-113 A = B*C;
207-114 A = B-C;
207-115 A = B*C;
207-116 A = B*C;
207-117 A = B+C;
207-118 A = B/C;
207-119 A = B-C;
207-120 A = B-C;
207-121
207-122 if (A != B)
207-123 {
207-124 A = B + C;
207-125 D = E + F;
207-126 }
207-127
207-128
207-129 if (A < B)
207-130 {
207-131 A = B + C;
207-132 D = E + F;
207-133 }
207-134
207-135
207-136 if (A > B)
207-137 {
207-138 A = B + C;
207-139 D = E + F;
207-140 }
207-141
207-142 A = B/C;
207-143 A = B*C;
207-144
207-145 if {
207-146 X = Y + Z;
207-147 }
207-148 else {
207-149 halt;
207-150 }
207-151
207-152 A = B/C;
207-153 A = B/C;
207-154 A = B*C;
207-155 A = (int)B + C;
207-156 A = B+C;
207-157 A = B*C;
207-158 A = B*C;
207-159 A = B*C;
207-160 A = B-C;
207-161 A = B/C;
207-162 // max LOC 59
207-163
207-164 }
207-165
207-166
207-167 /*
207-168 -----------------------------------------------------------------------------
207-169 --| NAME: wxp.4.2
207-170 --|
207-171 --| ABSTRACT:
207-172 --| This function does wxp stuff.
207-173 --|
207-174 --| RETURNS:
207-175 --| NONE.
207-176 --|
207-177 ----------------------------------------------------------------------------
207-178 */
207-179 static void wxp.4.2(void)
207-180 {
207-181 A = B-C;
207-182 A = B/C;
207-183 A = B+C;
207-184 A = B/C;
207-185
207-186 if (A ge B)
207-187 {
207-188 A = B + C;
207-189 D = E + F;
207-190 }
207-191
207-192 A = 0x0007;
207-193
207-194 if (A == B)
207-195 {
207-196 A = B + C;
207-197 D = E + F;
207-198 }
207-199
207-200 A = B-C;
207-201 A = B/C;
207-202 A = B+C;
207-203 A = B-C;
207-204 A = B-C;
207-205 A = B-C;
207-206 A = B/C;
207-207
207-208 if (A ge B)
207-209 {
207-210 A = B + C;
207-211 D = E + F;
207-212 }
207-213
207-214 A = B+C;
207-215 A = B*C;
207-216 A = B-C;
207-217 A = B*C;
207-218 A = B*C;
207-219 A = B+C;
207-220 A = B*C;
207-221 A = B*C;
207-222
207-223 if (A lt B)
207-224 {
207-225 A = B + C;
207-226 D = E + F;
207-227 }
207-228
207-229
207-230 if (A == B)
207-231 {
207-232 A = B + C;
207-233 D = E + F;
207-234 }
207-235
207-236 A = B*C;
207-237 A = B-C;
207-238
207-239 if (A ne B)
207-240 {
207-241 A = B + C;
207-242 D = E + F;
207-243 }
207-244
207-245 A = B-C;
207-246 A = B*C;
207-247 // max LOC 29
207-248
207-249 }
207-250
207-251
207-252 /*
207-253 -----------------------------------------------------------------------------
207-254 --| NAME: wxp.4.3
207-255 --|
207-256 --| ABSTRACT:
207-257 --| This function does wxp stuff.
207-258 --|
207-259 --| RETURNS:
207-260 --| NONE.
207-261 --|
207-262 ----------------------------------------------------------------------------
207-263 */
207-264 static void wxp.4.3(void)
207-265 {
207-266 A = (long)B + C;
207-267 A = B-C;
207-268 A = B/C;
207-269 A = B*C;
207-270 A = B-C;
207-271 A = B+C;
207-272 A = B*C;
207-273 A = B*C;
207-274 A = B*C;
207-275 A = B-C;
207-276 A = B+C;
207-277 A = B/C;
207-278 A = B+C;
207-279 A = B+C;
207-280 A = B-C;
207-281
207-282 if (A == B)
207-283 {
207-284 A = B + C;
207-285 D = E + F;
207-286 }
207-287
207-288
207-289 if (A > B)
207-290 {
207-291 A = B + C;
207-292 D = E + F;
207-293 }
207-294
207-295 A = B/C;
207-296 A = B+C;
207-297 A = B-C;
207-298 A = B*C;
207-299 /* LE SV TOC-3820 this a wxp-04.3.21 req */
207-300 A = B/C;
207-301 A = B/C;
207-302
207-303 if {
207-304 X = Y + Z;
207-305 }
207-306 else {
207-307 halt;
207-308 }
207-309
207-310 A = B/C;
207-311 A = B-C;
207-312 A = B-C;
207-313 A = B*C;
207-314 A = B/C;
207-315 A = B/C;
207-316 A = B+C;
207-317 A = B+C;
207-318
207-319 if (A le B)
207-320 {
207-321 A = B + C;
207-322 D = E + F;
207-323 }
207-324
207-325 A = B/C;
207-326
207-327 if (A lt B)
207-328 {
207-329 A = B + C;
207-330 D = E + F;
207-331 }
207-332
207-333 A = B-C;
207-334 A = B*C;
207-335
207-336 if (A eq B)
207-337 {
207-338 A = B + C;
207-339 D = E + F;
207-340 }
207-341
207-342 A = B+C;
207-343
207-344 if (A eq B)
207-345 {
207-346 A = B + C;
207-347 D = E + F;
207-348 }
207-349
207-350 // (P) this is really improtant
207-351 A = B-C;
207-352
207-353 if (A gt B)
207-354 {
207-355 A = B + C;
207-356 D = E + F;
207-357 }
207-358
207-359 A = B+C;
207-360 A = B/C;
207-361 A = 0x0008;
207-362
207-363 if (A < = B)
207-364 {
207-365 A = B + C;
207-366 D = E + F;
207-367 }
207-368
207-369 A = B+C;
207-370 A = B*C;
207-371 A = B*C;
207-372 A = B*C;
207-373
207-374 if (A > B)
207-375 {
207-376 A = B + C;
207-377 D = E + F;
207-378 }
207-379
207-380 A = B/C;
207-381 A = B-C;
207-382
207-383 switch (wxp stuff)
207-384 {
207-385 case one:
207-386 {
207-387 run_this;
207-388 break;
207-389 }
207-390 case two:
207-391 {
207-392 run_this;
207-393 break;
207-394 }
207-395 default:
207-396 {
207-397 SwError;
207-398 }
207-399 }
207-400
207-401 A = B*C;
207-402 A = B*C;
207-403 A = 0x0001;
207-404 A = B*C;
207-405 A = B/C;
207-406 /* LE SV TOC-3821 this a wxp-04.3.56 req */
207-407 A = B+C;
207-408 A = B-C;
207-409 A = B*C;
207-410 A = B+C;
207-411 A = B*C;
207-412 A = B+C;
207-413 A = B+C;
207-414 A = B*C;
207-415 A = B+C;
207-416 A = B+C;
207-417
207-418 switch (wxp stuff)
207-419 {
207-420 case one:
207-421 {
207-422 run_this;
207-423 break;
207-424 }
207-425 case two:
207-426 {
207-427 run_this;
207-428 break;
207-429 }
207-430 default:
207-431 {
207-432 SwError;
207-433 }
207-434 }
207-435
207-436 A = B/C;
207-437 A = B+C;
207-438 A = B+C;
207-439 A = B*C;
207-440 A = 0x0006;
207-441
207-442 switch (wxp stuff)
207-443 {
207-444 case one:
207-445 {
207-446 run_this;
207-447 break;
207-448 }
207-449 case two:
207-450 {
207-451 run_this;
207-452 break;
207-453 }
207-454 default:
207-455 {
207-456 SwError;
207-457 }
207-458 }
207-459
207-460 A = B/C;
207-461 A = B+C;
207-462
207-463 if ($wxp stuff > $otherwxp stuff)
207-464 /* LE SV TOC-008 we really should log all error calls */
207-465 {
207-466 A = B + C;
207-467 }
207-468
207-469
207-470 if (A < B)
207-471 {
207-472 A = B + C;
207-473 D = E + F;
207-474 }
207-475
207-476 A = B/C;
207-477 A = B-C;
207-478 A = B/C;
207-479 // max LOC 77
207-480
207-481 }
207-482
207-483
207-484 /*
207-485 -----------------------------------------------------------------------------
207-486 --| NAME: wxp.4.4
207-487 --|
207-488 --| ABSTRACT:
207-489 --| This function does wxp stuff.
207-490 --|
207-491 --| RETURNS:
207-492 --| NONE.
207-493 --|
207-494 ----------------------------------------------------------------------------
207-495 */
207-496 static void wxp.4.4(void)
207-497 {
207-498 A = B/C;
207-499 A = B*C;
207-500
207-501 if (A == B)
207-502 {
207-503 A = B + C;
207-504 D = E + F;
207-505 }
207-506
207-507 A = B*C;
207-508 A = B+C;
207-509
207-510 if (A > = B)
207-511 {
207-512 A = B + C;
207-513 D = E + F;
207-514 }
207-515
207-516 A = B-C;
207-517
207-518 #ifdef LAZY
207-519 // this is not nice
207-520 A = B + C;
207-521 A = B + C;
207-522 #endif
207-523
207-524 A = B*C;
207-525 A = B+C;
207-526 A = B-C;
207-527 A = B*C;
207-528
207-529 if (A lt B)
207-530 {
207-531 A = B + C;
207-532 D = E + F;
207-533 }
207-534
207-535 A = B-C;
207-536 A = B*C;
207-537 A = B/C;
207-538 A = B/C;
207-539
207-540 if (A eq B)
207-541 {
207-542 A = B + C;
207-543 D = E + F;
207-544 }
207-545
207-546 A = B+C;
207-547 // TBD - what do I do now
207-548 A = B*C;
207-549 A = B-C;
207-550 // ??? go see ws
207-551 A = B+C;
207-552 A = B-C;
207-553
207-554 if (A == B)
207-555 {
207-556 A = B + C;
207-557 D = E + F;
207-558 }
207-559
207-560 A = B/C;
207-561 A = B/C;
207-562 A = B-C;
207-563 A = B/C;
207-564 /* LE SV TOC-3822 this a wxp-04.4.28 req */
207-565
207-566 if (A != B)
207-567 {
207-568 A = B + C;
207-569 D = E + F;
207-570 }
207-571
207-572
207-573 if (A ge B)
207-574 {
207-575 A = B + C;
207-576 D = E + F;
207-577 }
207-578
207-579 // max LOC 29
207-580
207-581 }
207-582
207 207 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-04.c
208 208 Source: source/ft-app/ft-app-B1.0/wxp/wxp-05.c
208-0 /*
208-1 ----------------------------------------------------------------------------
208-2 --| BEGIN PROLOGUE
208-3 --|
208-4 --| CLASSIFICATION: UNCLASSIFIED
208-5 --|
208-6 --| FILE NAME: wxp-05.c
208-7 --|
208-8 --| ABSTRACT:
208-9 --| This file contains the 4 functions that do file wxp stuff.
208-10 --|
208-11 --| HISTORY:
208-12 --| CCCQ_NAME:
208-13 --| CCCQ_VER:
208-14 --|
208-15 --| END PROLOGUE
208-16 ----------------------------------------------------------------------------
208-17 */
208-18
208-19 #include D;
208-20 char D;
208-21 #include D;
208-22 #include B;
208-23 #include A;
208-24 #include C;
208-25 #define C;
208-26 #define D;
208-27 #include C;
208-28
208-29
208-30
208-31 /*
208-32 -----------------------------------------------------------------------------
208-33 --| NAME: wxp.5.1
208-34 --|
208-35 --| ABSTRACT:
208-36 --| This function does wxp stuff.
208-37 --|
208-38 --| RETURNS:
208-39 --| NONE.
208-40 --|
208-41 ----------------------------------------------------------------------------
208-42 */
208-43 static void wxp.5.1(void)
208-44 {
208-45 A = B/C;
208-46 A = B/C;
208-47 A = B+C;
208-48
208-49 if (A lt B)
208-50 {
208-51 A = B + C;
208-52 D = E + F;
208-53 }
208-54
208-55 A = B/C;
208-56 A = B*C;
208-57
208-58 if (A > B)
208-59 {
208-60 A = B + C;
208-61 D = E + F;
208-62 }
208-63
208-64
208-65 if (A == B)
208-66 {
208-67 A = B + C;
208-68 D = E + F;
208-69 }
208-70
208-71
208-72 if (A < B)
208-73 {
208-74 A = B + C;
208-75 D = E + F;
208-76 }
208-77
208-78 A = B*C;
208-79 A = B+C;
208-80 A = B-C;
208-81 A = B/C;
208-82 // (P) this is really improtant
208-83
208-84 if (A eq B)
208-85 {
208-86 A = B + C;
208-87 D = E + F;
208-88 }
208-89
208-90 A = B*C;
208-91 A = B*C;
208-92 A = B/C;
208-93 A = B+C;
208-94 A = B+C;
208-95 A = B*C;
208-96 free(FreePtr);
208-97 A = B*C;
208-98 A = B+C;
208-99 A = 0x0004;
208-100 A = B-C;
208-101 A = B+C;
208-102 A = B/C;
208-103
208-104 if (A != B)
208-105 {
208-106 A = B + C;
208-107 D = E + F;
208-108 }
208-109
208-110
208-111 if (A > B)
208-112 {
208-113 A = B + C;
208-114 D = E + F;
208-115 }
208-116
208-117 A = B-C;
208-118 // max LOC 28
208-119
208-120 }
208-121
208-122
208-123 /*
208-124 -----------------------------------------------------------------------------
208-125 --| NAME: wxp.5.2
208-126 --|
208-127 --| ABSTRACT:
208-128 --| This function does wxp stuff.
208-129 --|
208-130 --| RETURNS:
208-131 --| NONE.
208-132 --|
208-133 ----------------------------------------------------------------------------
208-134 */
208-135 static void wxp.5.2(void)
208-136 {
208-137 A = B-C;
208-138 A = B+C;
208-139 A = B/C;
208-140 A = B/C;
208-141
208-142 if (A le B)
208-143 {
208-144 A = B + C;
208-145 D = E + F;
208-146 }
208-147
208-148 A = B*C;
208-149 A = B-C;
208-150 A = B-C;
208-151 /* LE SV TOC-3823 this a wxp-05.2.9 req */
208-152 A = B+C;
208-153 A = B*C;
208-154 A = B-C;
208-155 A = B/C;
208-156
208-157 if (A < = B)
208-158 {
208-159 A = B + C;
208-160 D = E + F;
208-161 }
208-162
208-163
208-164 if (A < = B)
208-165 {
208-166 A = B + C;
208-167 D = E + F;
208-168 }
208-169
208-170
208-171 if (A le B)
208-172 {
208-173 A = B + C;
208-174 D = E + F;
208-175 }
208-176
208-177 A = B/C;
208-178 /* LE SV TOC-3824 this a wxp-05.2.17 req */
208-179 A = B-C;
208-180 A = B*C;
208-181 A = B/C;
208-182 goto error;
208-183 A = B+C;
208-184 A = B/C;
208-185 A = B+C;
208-186 A = B-C;
208-187 A = B+C;
208-188 A = B-C;
208-189 A = B-C;
208-190 A = B-C;
208-191 A = B*C;
208-192 A = B+C;
208-193
208-194 if (A ne B)
208-195 {
208-196 A = B + C;
208-197 D = E + F;
208-198 }
208-199
208-200 A = B*C;
208-201 A = B+C;
208-202 A = B+C;
208-203 /* LE SV TOC-3825 this a wxp-05.2.34 req */
208-204 A = B+C;
208-205
208-206 if (A le B)
208-207 {
208-208 A = B + C;
208-209 D = E + F;
208-210 }
208-211
208-212 A = B+C;
208-213
208-214 if (A < = B)
208-215 {
208-216 A = B + C;
208-217 D = E + F;
208-218 }
208-219
208-220
208-221 if (A != B)
208-222 {
208-223 A = B + C;
208-224 D = E + F;
208-225 }
208-226
208-227 A = B/C;
208-228 A = B+C;
208-229
208-230 if (A != B)
208-231 {
208-232 A = B + C;
208-233 D = E + F;
208-234 }
208-235
208-236
208-237 if (A ne B)
208-238 {
208-239 A = B + C;
208-240 D = E + F;
208-241 }
208-242
208-243 A = B+C;
208-244 // TBD - what do I do now
208-245 A = B-C;
208-246
208-247 if (A != B)
208-248 {
208-249 A = B + C;
208-250 D = E + F;
208-251 }
208-252
208-253 A = B+C;
208-254
208-255 if (A ne B)
208-256 {
208-257 A = B + C;
208-258 D = E + F;
208-259 }
208-260
208-261
208-262 if (A gt B)
208-263 {
208-264 A = B + C;
208-265 D = E + F;
208-266 }
208-267
208-268 A = B-C;
208-269 A = B+C;
208-270
208-271 if (A < = B)
208-272 {
208-273 A = B + C;
208-274 D = E + F;
208-275 }
208-276
208-277 A = B-C;
208-278 A = B-C;
208-279 send_buffer = (U16 *) malloc(size+1);
208-280 A = B-C;
208-281 // max LOC 54
208-282
208-283 }
208-284
208-285
208-286 /*
208-287 -----------------------------------------------------------------------------
208-288 --| NAME: wxp.5.3
208-289 --|
208-290 --| ABSTRACT:
208-291 --| This function does wxp stuff.
208-292 --|
208-293 --| RETURNS:
208-294 --| NONE.
208-295 --|
208-296 ----------------------------------------------------------------------------
208-297 */
208-298 static void wxp.5.3(void)
208-299 {
208-300 A = B+C;
208-301 /* LE SV TOC-3826 this a wxp-05.3.2 req */
208-302 A = B*C;
208-303 A = B+C;
208-304 A = B/C;
208-305 A = B*C;
208-306 A = B-C;
208-307 A = B/C;
208-308 /* LE SV TOC-3827 this a wxp-05.3.8 req */
208-309
208-310 switch (wxp stuff)
208-311 {
208-312 case one:
208-313 {
208-314 run_this;
208-315 break;
208-316 }
208-317 case two:
208-318 {
208-319 run_this;
208-320 break;
208-321 }
208-322 default:
208-323 {
208-324 SwError;
208-325 }
208-326 }
208-327
208-328 A = B*C;
208-329 A = B+C;
208-330
208-331 if (A ge B)
208-332 {
208-333 A = B + C;
208-334 D = E + F;
208-335 }
208-336
208-337 A = B*C;
208-338 A = B+C;
208-339 A = B*C;
208-340 A = 0x0001;
208-341 A = B/C;
208-342
208-343 if (A == B)
208-344 {
208-345 A = B + C;
208-346 D = E + F;
208-347 }
208-348
208-349 /* LE SV TOC-3828 this a wxp-05.3.17 req */
208-350 A = B-C;
208-351 A = B+C;
208-352 /* LE SV TOC-3829 this a wxp-05.3.19 req */
208-353 A = B*C;
208-354 /* LE SV TOC-3830 this a wxp-05.3.20 req */
208-355 A = B+C;
208-356 /* LE SV TOC-3831 this a wxp-05.3.21 req */
208-357 A = B*C;
208-358 /* LE SV TOC-3832 this a wxp-05.3.22 req */
208-359 A = B/C;
208-360 A = B/C;
208-361 A = B+C;
208-362 A = B-C;
208-363
208-364 if (A < = B)
208-365 {
208-366 A = B + C;
208-367 D = E + F;
208-368 }
208-369
208-370 A = B*C;
208-371
208-372 if (A eq B)
208-373 {
208-374 A = B + C;
208-375 D = E + F;
208-376 }
208-377
208-378 A = B/C;
208-379 A = B*C;
208-380 A = B-C;
208-381 A = B+C;
208-382 A = B-C;
208-383
208-384 if (A lt B)
208-385 {
208-386 A = B + C;
208-387 D = E + F;
208-388 }
208-389
208-390
208-391 if (A == B)
208-392 {
208-393 A = B + C;
208-394 D = E + F;
208-395 }
208-396
208-397 // (P) this is really improtant
208-398 A = B*C;
208-399 A = B-C;
208-400 A = B*C;
208-401 A = B/C;
208-402 rcv_buffer = (U16 *) alloc(size+1);
208-403 A = B*C;
208-404 A = B+C;
208-405
208-406 if (A == B)
208-407 {
208-408 A = B + C;
208-409 D = E + F;
208-410 }
208-411
208-412 A = B+C;
208-413 A = B/C;
208-414
208-415 if (A < = B)
208-416 {
208-417 A = B + C;
208-418 D = E + F;
208-419 }
208-420
208-421 A = B/C;
208-422 A = B*C;
208-423
208-424 if (A > = B)
208-425 {
208-426 A = B + C;
208-427 D = E + F;
208-428 }
208-429
208-430 A = B+C;
208-431 A = B+C;
208-432 A = B*C;
208-433
208-434 if (A == B)
208-435 {
208-436 A = B + C;
208-437 D = E + F;
208-438 }
208-439
208-440 A = B+C;
208-441
208-442 #ifdef LAZY
208-443 // this is not nice
208-444 A = B + C;
208-445 A = B + C;
208-446 #endif
208-447
208-448
208-449 if (A == B)
208-450 {
208-451 A = B + C;
208-452 D = E + F;
208-453 }
208-454
208-455 A = B*C;
208-456 A = B/C;
208-457
208-458 switch (wxp stuff)
208-459 {
208-460 case one:
208-461 {
208-462 run_this;
208-463 break;
208-464 }
208-465 case two:
208-466 {
208-467 run_this;
208-468 break;
208-469 }
208-470 default:
208-471 {
208-472 SwError;
208-473 }
208-474 }
208-475
208-476 A = B-C;
208-477
208-478 if (A gt B)
208-479 {
208-480 A = B + C;
208-481 D = E + F;
208-482 }
208-483
208-484 A = B*C;
208-485
208-486 if (A ne B)
208-487 {
208-488 A = B + C;
208-489 D = E + F;
208-490 }
208-491
208-492
208-493 if (A < B)
208-494 {
208-495 A = B + C;
208-496 D = E + F;
208-497 }
208-498
208-499 A = B-C;
208-500 /* LE SV TOC-3833 this a wxp-05.3.64 req */
208-501 A = B/C;
208-502 A = B-C;
208-503 A = B-C;
208-504 A = B/C;
208-505 A = B*C;
208-506 A = B-C;
208-507 A = B*C;
208-508 A = B+C;
208-509 /* LE SV TOC-3834 this a wxp-05.3.72 req */
208-510 A = B*C;
208-511 A = B-C;
208-512 A = B-C;
208-513 A = B*C;
208-514 A = B-C;
208-515 A = B/C;
208-516 A = B*C;
208-517 // max LOC 78
208-518
208-519 }
208-520
208-521
208-522 /*
208-523 -----------------------------------------------------------------------------
208-524 --| NAME: wxp.5.4
208-525 --|
208-526 --| ABSTRACT:
208-527 --| This function does wxp stuff.
208-528 --|
208-529 --| RETURNS:
208-530 --| NONE.
208-531 --|
208-532 ----------------------------------------------------------------------------
208-533 */
208-534 static void wxp.5.4(void)
208-535 {
208-536
208-537 if (A > B)
208-538 {
208-539 A = B + C;
208-540 D = E + F;
208-541 }
208-542
208-543 A = B*C;
208-544 A = B/C;
208-545 A = B*C;
208-546 A = B+C;
208-547 A = B*C;
208-548 A = B-C;
208-549 A = B/C;
208-550 A = B*C;
208-551 A = B*C;
208-552 A = B/C;
208-553 A = B/C;
208-554 A = B+C;
208-555 A = B*C;
208-556 A = B/C;
208-557 A = B-C;
208-558 A = B+C;
208-559
208-560 if (A ge B)
208-561 {
208-562 A = B + C;
208-563 D = E + F;
208-564 }
208-565
208-566 A = B+C;
208-567
208-568 switch (wxp stuff)
208-569 {
208-570 case one:
208-571 {
208-572 run_this;
208-573 break;
208-574 }
208-575 case two:
208-576 {
208-577 run_this;
208-578 break;
208-579 }
208-580 default:
208-581 {
208-582 SwError;
208-583 }
208-584 }
208-585
208-586 A = B-C;
208-587 A = B-C;
208-588 A = B+C;
208-589 A = B/C;
208-590 A = B-C;
208-591 A = B-C;
208-592 /* LE SV TOC-3835 this a wxp-05.4.27 req */
208-593 A = B+C;
208-594 A = B/C;
208-595 A = B-C;
208-596 A = B+C;
208-597 A = B*C;
208-598 A = B-C;
208-599 A = B/C;
208-600 A = B-C;
208-601 A = B*C;
208-602 A = B+C;
208-603 A = B+C;
208-604 A = B+C;
208-605 A = B/C;
208-606 A = B/C;
208-607 // max LOC 40
208-608
208-609 }
208-610
208 208 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-05.c
209 209 Source: source/ft-app/ft-app-B1.0/wxp/wxp-06.c
209-0 /*
209-1 ----------------------------------------------------------------------------
209-2 --| BEGIN PROLOGUE
209-3 --|
209-4 --| CLASSIFICATION: UNCLASSIFIED
209-5 --|
209-6 --| FILE NAME: wxp-06.c
209-7 --|
209-8 --| ABSTRACT:
209-9 --| This file contains the 5 functions that do file wxp stuff.
209-10 --|
209-11 --| HISTORY:
209-12 --| CCCQ_NAME:
209-13 --| CCCQ_VER:
209-14 --|
209-15 --| END PROLOGUE
209-16 ----------------------------------------------------------------------------
209-17 */
209-18
209-19 #include D;
209-20 #define A;
209-21
209-22
209-23
209-24 /*
209-25 -----------------------------------------------------------------------------
209-26 --| NAME: wxp.6.1
209-27 --|
209-28 --| ABSTRACT:
209-29 --| This function does wxp stuff.
209-30 --|
209-31 --| RETURNS:
209-32 --| NONE.
209-33 --|
209-34 ----------------------------------------------------------------------------
209-35 */
209-36 static void wxp.6.1(void)
209-37 {
209-38 A = B/C;
209-39 A = B-C;
209-40 A = B+C;
209-41 A = B/C;
209-42 A = B*C;
209-43
209-44 if (A ge B)
209-45 {
209-46 A = B + C;
209-47 D = E + F;
209-48 }
209-49
209-50 A = B-C;
209-51
209-52 if (A == B)
209-53 {
209-54 A = B + C;
209-55 D = E + F;
209-56 }
209-57
209-58 A = B/C;
209-59 A = B-C;
209-60
209-61 if (A == B)
209-62 {
209-63 A = B + C;
209-64 D = E + F;
209-65 }
209-66
209-67
209-68 if (A ge B)
209-69 {
209-70 A = B + C;
209-71 D = E + F;
209-72 }
209-73
209-74 A = B/C;
209-75 A = B/C;
209-76
209-77 if (A > B)
209-78 {
209-79 A = B + C;
209-80 D = E + F;
209-81 }
209-82
209-83 /* LE SV TOC-3836 this a wxp-06.1.16 req */
209-84 A = B/C;
209-85 A = B+C;
209-86 /* LE SV TOC-3837 this a wxp-06.1.18 req */
209-87 A = B+C;
209-88 A = B+C;
209-89 A = B-C;
209-90 A = B/C;
209-91 A = B*C;
209-92 A = B*C;
209-93 A = B*C;
209-94 A = B/C;
209-95 A = B*C;
209-96
209-97 if (A ne B)
209-98 {
209-99 A = B + C;
209-100 D = E + F;
209-101 }
209-102
209-103
209-104 if (A eq B)
209-105 {
209-106 A = B + C;
209-107 D = E + F;
209-108 }
209-109
209-110 A = B+C;
209-111
209-112 if (A > B)
209-113 {
209-114 A = B + C;
209-115 D = E + F;
209-116 }
209-117
209-118 A = B-C;
209-119 A = B-C;
209-120 A = B+C;
209-121
209-122 switch (wxp stuff)
209-123 {
209-124 case one:
209-125 {
209-126 run_this;
209-127 break;
209-128 }
209-129 case two:
209-130 {
209-131 run_this;
209-132 break;
209-133 }
209-134 default:
209-135 {
209-136 SwError;
209-137 }
209-138 }
209-139
209-140 A = B+C;
209-141 A = B-C;
209-142 A = B/C;
209-143
209-144 #ifdef LAZY
209-145 // this is not nice
209-146 A = B + C;
209-147 A = B + C;
209-148 #endif
209-149
209-150 A = B*C;
209-151 A = B/C;
209-152 A = B*C;
209-153 A = B/C;
209-154 A = B/C;
209-155 A = B-C;
209-156 A = B*C;
209-157 A = B-C;
209-158 A = B*C;
209-159
209-160 if ($wxp stuff > $otherwxp stuff)
209-161 /* LE SV TOC-008 we really should log all error calls */
209-162 {
209-163 A = B + C;
209-164 }
209-165
209-166 A = B*C;
209-167 // max LOC 47
209-168
209-169 }
209-170
209-171
209-172 /*
209-173 -----------------------------------------------------------------------------
209-174 --| NAME: wxp.6.2
209-175 --|
209-176 --| ABSTRACT:
209-177 --| This function does wxp stuff.
209-178 --|
209-179 --| RETURNS:
209-180 --| NONE.
209-181 --|
209-182 ----------------------------------------------------------------------------
209-183 */
209-184 static void wxp.6.2(void)
209-185 {
209-186 A = B-C;
209-187 A = B-C;
209-188
209-189 if (A gt B)
209-190 {
209-191 A = B + C;
209-192 D = E + F;
209-193 }
209-194
209-195 A = B+C;
209-196 A = B+C;
209-197 A = B+C;
209-198 A = B/C;
209-199 A = B+C;
209-200 A = B+C;
209-201 A = B*C;
209-202 A = B*C;
209-203
209-204 switch (wxp stuff)
209-205 {
209-206 case one:
209-207 {
209-208 run_this;
209-209 break;
209-210 }
209-211 case two:
209-212 {
209-213 run_this;
209-214 break;
209-215 }
209-216 default:
209-217 {
209-218 SwError;
209-219 }
209-220 }
209-221
209-222 A = B+C;
209-223 A = B/C;
209-224 A = B+C;
209-225 A = B/C;
209-226 A = B/C;
209-227 A = B-C;
209-228 A = B*C;
209-229 A = B-C;
209-230 A = B/C;
209-231 A = B+C;
209-232 A = B-C;
209-233 A = B+C;
209-234 A = (int)B + C;
209-235 A = B/C;
209-236 A = B/C;
209-237 A = B-C;
209-238 A = B+C;
209-239 A = B*C;
209-240 A = B/C;
209-241 A = B*C;
209-242 A = B+C;
209-243 A = B-C;
209-244 A = B*C;
209-245 /* LE SV TOC-3838 this a wxp-06.2.35 req */
209-246 A = B*C;
209-247 A = B-C;
209-248 A = B/C;
209-249 A = B-C;
209-250 // max LOC 38
209-251
209-252 }
209-253
209-254
209-255 /*
209-256 -----------------------------------------------------------------------------
209-257 --| NAME: wxp.6.3
209-258 --|
209-259 --| ABSTRACT:
209-260 --| This function does wxp stuff.
209-261 --|
209-262 --| RETURNS:
209-263 --| NONE.
209-264 --|
209-265 ----------------------------------------------------------------------------
209-266 */
209-267 static void wxp.6.3(void)
209-268 {
209-269
209-270 if (A ne B)
209-271 {
209-272 A = B + C;
209-273 D = E + F;
209-274 }
209-275
209-276 A = B-C;
209-277 A = B-C;
209-278
209-279 if (A ge B)
209-280 {
209-281 A = B + C;
209-282 D = E + F;
209-283 }
209-284
209-285 A = B*C;
209-286 A = B/C;
209-287
209-288 if (A le B)
209-289 {
209-290 A = B + C;
209-291 D = E + F;
209-292 }
209-293
209-294
209-295 if (A > = B)
209-296 {
209-297 A = B + C;
209-298 D = E + F;
209-299 }
209-300
209-301 A = B+C;
209-302
209-303 if (A ge B)
209-304 {
209-305 A = B + C;
209-306 D = E + F;
209-307 }
209-308
209-309 A = B+C;
209-310 A = B-C;
209-311 A = B/C;
209-312
209-313 if (A > = B)
209-314 {
209-315 A = B + C;
209-316 D = E + F;
209-317 }
209-318
209-319 A = B-C;
209-320 A = B-C;
209-321 A = B+C;
209-322 A = B/C;
209-323 A = B*C;
209-324 A = B/C;
209-325
209-326 if (A < B)
209-327 {
209-328 A = B + C;
209-329 D = E + F;
209-330 }
209-331
209-332 A = B/C;
209-333 A = B/C;
209-334 A = B*C;
209-335 A = B/C;
209-336 A = B/C;
209-337 A = B+C;
209-338 A = B*C;
209-339
209-340 if (A lt B)
209-341 {
209-342 A = B + C;
209-343 D = E + F;
209-344 }
209-345
209-346 A = B-C;
209-347 A = B+C;
209-348 A = B-C;
209-349 A = B/C;
209-350 A = B*C;
209-351 A = B*C;
209-352 A = B/C;
209-353 A = B-C;
209-354 A = B-C;
209-355 A = B/C;
209-356 A = B-C;
209-357 A = B+C;
209-358 A = B+C;
209-359
209-360 if ($wxp stuff > $otherwxp stuff)
209-361 /* LE SV TOC-008 we really should log all error calls */
209-362 {
209-363 A = B + C;
209-364 }
209-365
209-366 A = B+C;
209-367 A = B*C;
209-368 A = B/C;
209-369 A = B*C;
209-370 A = B/C;
209-371 A = B/C;
209-372 A = B/C;
209-373 A = B*C;
209-374
209-375 if (A < B)
209-376 {
209-377 A = B + C;
209-378 D = E + F;
209-379 }
209-380
209-381 A = B*C;
209-382 A = B/C;
209-383 A = B+C;
209-384
209-385 if (A < = B)
209-386 {
209-387 A = B + C;
209-388 D = E + F;
209-389 }
209-390
209-391 A = B/C;
209-392 A = B+C;
209-393 A = B*C;
209-394 A = B+C;
209-395 A = B+C;
209-396 A = B/C;
209-397
209-398 if (A == B)
209-399 {
209-400 A = B + C;
209-401 D = E + F;
209-402 }
209-403
209-404 A = B/C;
209-405 send_buffer = (U16 *) malloc(size+1);
209-406 A = B*C;
209-407 A = B/C;
209-408 A = B/C;
209-409
209-410 if (A eq B)
209-411 {
209-412 A = B + C;
209-413 D = E + F;
209-414 }
209-415
209-416 A = B+C;
209-417 A = B*C;
209-418 A = B*C;
209-419 A = B+C;
209-420 A = B/C;
209-421 A = B/C;
209-422 A = B+C;
209-423 A = B/C;
209-424
209-425 if (A != B)
209-426 {
209-427 A = B + C;
209-428 D = E + F;
209-429 }
209-430
209-431 A = B*C;
209-432 // max LOC 77
209-433
209-434 }
209-435
209-436
209-437 /*
209-438 -----------------------------------------------------------------------------
209-439 --| NAME: wxp.6.4
209-440 --|
209-441 --| ABSTRACT:
209-442 --| This function does wxp stuff.
209-443 --|
209-444 --| RETURNS:
209-445 --| NONE.
209-446 --|
209-447 ----------------------------------------------------------------------------
209-448 */
209-449 static void wxp.6.4(void)
209-450 {
209-451 A = B/C;
209-452
209-453 if (A lt B)
209-454 {
209-455 A = B + C;
209-456 D = E + F;
209-457 }
209-458
209-459 /* LE SV TOC-3839 this a wxp-06.4.3 req */
209-460 A = B/C;
209-461
209-462 switch (wxp stuff)
209-463 {
209-464 case one:
209-465 {
209-466 run_this;
209-467 break;
209-468 }
209-469 case two:
209-470 {
209-471 run_this;
209-472 break;
209-473 }
209-474 default:
209-475 {
209-476 SwError;
209-477 }
209-478 }
209-479
209-480 A = B*C;
209-481
209-482 #ifdef LAZY
209-483 // this is not nice
209-484 A = B + C;
209-485 A = B + C;
209-486 #endif
209-487
209-488 A = B*C;
209-489 A = B-C;
209-490 A = B/C;
209-491 A = B*C;
209-492 A = B/C;
209-493
209-494 if (A < = B)
209-495 {
209-496 A = B + C;
209-497 D = E + F;
209-498 }
209-499
209-500 A = B-C;
209-501 A = B/C;
209-502 A = 0x0004;
209-503 A = B-C;
209-504 A = B/C;
209-505
209-506 if (A ge B)
209-507 {
209-508 A = B + C;
209-509 D = E + F;
209-510 }
209-511
209-512
209-513 if (A gt B)
209-514 {
209-515 A = B + C;
209-516 D = E + F;
209-517 }
209-518
209-519
209-520 if (A ne B)
209-521 {
209-522 A = B + C;
209-523 D = E + F;
209-524 }
209-525
209-526
209-527 if (A lt B)
209-528 {
209-529 A = B + C;
209-530 D = E + F;
209-531 }
209-532
209-533 A = B*C;
209-534 free(FreePtr);
209-535 A = B*C;
209-536 A = B+C;
209-537
209-538 if (A < = B)
209-539 {
209-540 A = B + C;
209-541 D = E + F;
209-542 }
209-543
209-544 A = B/C;
209-545 A = B*C;
209-546 A = B/C;
209-547 A = B-C;
209-548 A = B*C;
209-549 A = B+C;
209-550
209-551 if (A eq B)
209-552 {
209-553 A = B + C;
209-554 D = E + F;
209-555 }
209-556
209-557 A = B/C;
209-558
209-559 if (A eq B)
209-560 {
209-561 A = B + C;
209-562 D = E + F;
209-563 }
209-564
209-565
209-566 if (A le B)
209-567 {
209-568 A = B + C;
209-569 D = E + F;
209-570 }
209-571
209-572 A = B+C;
209-573 A = B/C;
209-574
209-575 if (A < = B)
209-576 {
209-577 A = B + C;
209-578 D = E + F;
209-579 }
209-580
209-581 A = B-C;
209-582 A = B+C;
209-583 A = B-C;
209-584 A = B*C;
209-585 A = B*C;
209-586 A = B*C;
209-587
209-588 if (A > B)
209-589 {
209-590 A = B + C;
209-591 D = E + F;
209-592 }
209-593
209-594 A = B*C;
209-595 A = (long)B + C;
209-596 A = B*C;
209-597 A = B+C;
209-598
209-599 if (A le B)
209-600 {
209-601 A = B + C;
209-602 D = E + F;
209-603 }
209-604
209-605 A = B+C;
209-606
209-607 if (A ne B)
209-608 {
209-609 A = B + C;
209-610 D = E + F;
209-611 }
209-612
209-613 A = B*C;
209-614
209-615 if (A gt B)
209-616 {
209-617 A = B + C;
209-618 D = E + F;
209-619 }
209-620
209-621 A = B+C;
209-622 A = B+C;
209-623 A = B+C;
209-624
209-625 if (A < B)
209-626 {
209-627 A = B + C;
209-628 D = E + F;
209-629 }
209-630
209-631 A = (float) B + C;
209-632 A = B/C;
209-633 A = B-C;
209-634 free(FreePtr);
209-635 A = B*C;
209-636 /* LE SV TOC-3840 this a wxp-06.4.59 req */
209-637
209-638 if (A ne B)
209-639 {
209-640 A = B + C;
209-641 D = E + F;
209-642 }
209-643
209-644 // max LOC 59
209-645
209-646 }
209-647
209-648
209-649 /*
209-650 -----------------------------------------------------------------------------
209-651 --| NAME: wxp.6.5
209-652 --|
209-653 --| ABSTRACT:
209-654 --| This function does wxp stuff.
209-655 --|
209-656 --| RETURNS:
209-657 --| NONE.
209-658 --|
209-659 ----------------------------------------------------------------------------
209-660 */
209-661 static void wxp.6.5(void)
209-662 {
209-663 A = B-C;
209-664 // TBD - what do I do now
209-665 A = B-C;
209-666
209-667 if (A != B)
209-668 {
209-669 A = B + C;
209-670 D = E + F;
209-671 }
209-672
209-673 A = B-C;
209-674 A = B/C;
209-675
209-676 switch (wxp stuff)
209-677 {
209-678 case one:
209-679 {
209-680 run_this;
209-681 break;
209-682 }
209-683 case two:
209-684 {
209-685 run_this;
209-686 break;
209-687 }
209-688 default:
209-689 {
209-690 SwError;
209-691 }
209-692 }
209-693
209-694 A = B+C;
209-695
209-696 if (A == B)
209-697 {
209-698 A = B + C;
209-699 D = E + F;
209-700 }
209-701
209-702 A = B/C;
209-703 A = B*C;
209-704 A = B*C;
209-705 A = B-C;
209-706 A = B-C;
209-707
209-708 switch (wxp stuff)
209-709 {
209-710 case one:
209-711 {
209-712 run_this;
209-713 break;
209-714 }
209-715 case two:
209-716 {
209-717 run_this;
209-718 break;
209-719 }
209-720 default:
209-721 {
209-722 SwError;
209-723 }
209-724 }
209-725
209-726 /* LE SV TOC-3841 this a wxp-06.5.15 req */
209-727 A = B-C;
209-728
209-729 if (A != B)
209-730 {
209-731 A = B + C;
209-732 D = E + F;
209-733 }
209-734
209-735 A = B*C;
209-736 FreePtr = HmiStringPtr;
209-737 A = B+C;
209-738 A = B-C;
209-739
209-740 if (A > = B)
209-741 {
209-742 A = B + C;
209-743 D = E + F;
209-744 }
209-745
209-746 A = B*C;
209-747 A = B-C;
209-748 A = B*C;
209-749
209-750 if (A le B)
209-751 {
209-752 A = B + C;
209-753 D = E + F;
209-754 }
209-755
209-756 A = B-C;
209-757 A = B-C;
209-758
209-759 switch (wxp stuff)
209-760 {
209-761 case one:
209-762 {
209-763 run_this;
209-764 break;
209-765 }
209-766 case two:
209-767 {
209-768 run_this;
209-769 break;
209-770 }
209-771 // missing default
209-772 }
209-773
209-774 A = B/C;
209-775 A = B-C;
209-776
209-777 if (A < B)
209-778 {
209-779 A = B + C;
209-780 D = E + F;
209-781 }
209-782
209-783 A = B+C;
209-784
209-785 if (A == B)
209-786 {
209-787 A = B + C;
209-788 D = E + F;
209-789 }
209-790
209-791 A = B+C;
209-792 A = B-C;
209-793 A = B*C;
209-794 A = B/C;
209-795 A = B*C;
209-796 A = B+C;
209-797 rcv_buffer = (U16 *) alloc(size+1);
209-798 A = B*C;
209-799 A = B/C;
209-800 A = B/C;
209-801 A = B+C;
209-802 A = B-C;
209-803
209-804 if (A == B)
209-805 {
209-806 A = B + C;
209-807 D = E + F;
209-808 }
209-809
209-810 A = B+C;
209-811 A = B+C;
209-812 A = B/C;
209-813 A = B/C;
209-814
209-815 if (A ne B)
209-816 {
209-817 A = B + C;
209-818 D = E + F;
209-819 }
209-820
209-821
209-822 if (A < B)
209-823 {
209-824 A = B + C;
209-825 D = E + F;
209-826 }
209-827
209-828 A = B/C;
209-829 A = B-C;
209-830 A = B+C;
209-831 A = B-C;
209-832 A = B/C;
209-833 A = B+C;
209-834 A = B/C;
209-835
209-836 if (A lt B)
209-837 {
209-838 A = B + C;
209-839 D = E + F;
209-840 }
209-841
209-842 A = B*C;
209-843 A = B/C;
209-844 A = B*C;
209-845 A = 0x0001;
209-846
209-847 if (A gt B)
209-848 {
209-849 A = B + C;
209-850 D = E + F;
209-851 }
209-852
209-853 A = B/C;
209-854
209-855 switch (wxp stuff)
209-856 {
209-857 case one:
209-858 {
209-859 run_this;
209-860 break;
209-861 }
209-862 case two:
209-863 {
209-864 run_this;
209-865 break;
209-866 }
209-867 default:
209-868 {
209-869 SwError;
209-870 }
209-871 }
209-872
209-873 A = B*C;
209-874 A = B+C;
209-875 A = B+C;
209-876 // max LOC 66
209-877
209-878 }
209-879
209 209 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-06.c
210 210 Source: source/ft-app/ft-app-B1.0/wxp/wxp-07.c
210-0 /*
210-1 ----------------------------------------------------------------------------
210-2 --| BEGIN PROLOGUE
210-3 --|
210-4 --| CLASSIFICATION: UNCLASSIFIED
210-5 --|
210-6 --| FILE NAME: wxp-07.c
210-7 --|
210-8 --| ABSTRACT:
210-9 --| This file contains the 5 functions that do file wxp stuff.
210-10 --|
210-11 --| HISTORY:
210-12 --| CCCQ_NAME:
210-13 --| CCCQ_VER:
210-14 --|
210-15 --| END PROLOGUE
210-16 ----------------------------------------------------------------------------
210-17 */
210-18
210-19 #define A;
210-20 float B;
210-21 #define A;
210-22 #define D;
210-23 #define C;
210-24 double C;
210-25
210-26
210-27
210-28 /*
210-29 -----------------------------------------------------------------------------
210-30 --| NAME: wxp.7.1
210-31 --|
210-32 --| ABSTRACT:
210-33 --| This function does wxp stuff.
210-34 --|
210-35 --| RETURNS:
210-36 --| NONE.
210-37 --|
210-38 ----------------------------------------------------------------------------
210-39 */
210-40 static void wxp.7.1(void)
210-41 {
210-42
210-43 if (A eq B)
210-44 {
210-45 A = B + C;
210-46 D = E + F;
210-47 }
210-48
210-49 A = B/C;
210-50 A = B+C;
210-51 A = B+C;
210-52 A = B-C;
210-53 A = B*C;
210-54 A = B-C;
210-55 A = B+C;
210-56 A = B-C;
210-57 A = B-C;
210-58 A = B*C;
210-59 A = B-C;
210-60
210-61 if (A le B)
210-62 {
210-63 A = B + C;
210-64 D = E + F;
210-65 }
210-66
210-67 A = B/C;
210-68
210-69 if (A ge B)
210-70 {
210-71 A = B + C;
210-72 D = E + F;
210-73 }
210-74
210-75
210-76 if (A lt B)
210-77 {
210-78 A = B + C;
210-79 D = E + F;
210-80 }
210-81
210-82 A = B-C;
210-83 A = B-C;
210-84 A = B*C;
210-85
210-86 if (A > B)
210-87 {
210-88 A = B + C;
210-89 D = E + F;
210-90 }
210-91
210-92 A = B-C;
210-93 /* LE SV TOC-3842 this a wxp-07.1.22 req */
210-94 A = B*C;
210-95 A = B/C;
210-96 A = B/C;
210-97 A = B-C;
210-98
210-99 if (A < = B)
210-100 {
210-101 A = B + C;
210-102 D = E + F;
210-103 }
210-104
210-105 A = B-C;
210-106 A = B/C;
210-107 A = B*C;
210-108 A = B+C;
210-109 A = B-C;
210-110 A = B/C;
210-111 A = B-C;
210-112 A = B-C;
210-113 A = B+C;
210-114 A = B/C;
210-115 A = B-C;
210-116
210-117 if (veg)
210-118 // missing curly brace
210-119 variable = orange;
210-120
210-121 A = B-C;
210-122 A = B+C;
210-123 A = B+C;
210-124 // TBS - I need to figure this out
210-125 A = B+C;
210-126 A = B+C;
210-127 A = B/C;
210-128 /* LE SV TOC-3843 this a wxp-07.1.44 req */
210-129 A = B*C;
210-130 A = B-C;
210-131 A = B*C;
210-132 /* LE SV TOC-3844 this a wxp-07.1.47 req */
210-133 A = B*C;
210-134 A = B*C;
210-135
210-136 if (A != B)
210-137 {
210-138 A = B + C;
210-139 D = E + F;
210-140 }
210-141
210-142 A = B/C;
210-143 A = B/C;
210-144
210-145 if (A > B)
210-146 {
210-147 A = B + C;
210-148 D = E + F;
210-149 }
210-150
210-151
210-152 if ($wxp stuff > $otherwxp stuff)
210-153 /* LE SV TOC-008 we really should log all error calls */
210-154 {
210-155 A = B + C;
210-156 }
210-157
210-158 A = B+C;
210-159 A = B*C;
210-160
210-161 switch (wxp stuff)
210-162 {
210-163 case one:
210-164 {
210-165 run_this;
210-166 break;
210-167 }
210-168 case two:
210-169 {
210-170 run_this;
210-171 break;
210-172 }
210-173 default:
210-174 {
210-175 SwError;
210-176 }
210-177 }
210-178
210-179 A = B*C;
210-180 A = B-C;
210-181 A = B/C;
210-182 A = B*C;
210-183 A = B-C;
210-184
210-185 if (A < B)
210-186 {
210-187 A = B + C;
210-188 D = E + F;
210-189 }
210-190
210-191 A = B/C;
210-192 A = B/C;
210-193 A = B*C;
210-194 /* LE SV TOC-3845 this a wxp-07.1.65 req */
210-195 A = B/C;
210-196 A = B/C;
210-197 // (P) this is really improtant
210-198 A = B/C;
210-199 A = B*C;
210-200
210-201 if (A le B)
210-202 {
210-203 A = B + C;
210-204 D = E + F;
210-205 }
210-206
210-207 A = B+C;
210-208 A = B+C;
210-209
210-210 if (A ne B)
210-211 {
210-212 A = B + C;
210-213 D = E + F;
210-214 }
210-215
210-216 A = B-C;
210-217 A = B/C;
210-218 A = B+C;
210-219 A = B-C;
210-220 A = B+C;
210-221 // max LOC 77
210-222
210-223 }
210-224
210-225
210-226 /*
210-227 -----------------------------------------------------------------------------
210-228 --| NAME: wxp.7.2
210-229 --|
210-230 --| ABSTRACT:
210-231 --| This function does wxp stuff.
210-232 --|
210-233 --| RETURNS:
210-234 --| NONE.
210-235 --|
210-236 ----------------------------------------------------------------------------
210-237 */
210-238 static void wxp.7.2(void)
210-239 {
210-240 A = B-C;
210-241 /* LE SV TOC-3846 this a wxp-07.2.2 req */
210-242 A = B-C;
210-243 A = B+C;
210-244 A = B+C;
210-245 A = B-C;
210-246 A = B*C;
210-247 A = B/C;
210-248 A = B/C;
210-249 /* LE SV TOC-3847 this a wxp-07.2.9 req */
210-250 A = B+C;
210-251 A = B+C;
210-252 A = B*C;
210-253 A = B*C;
210-254 A = B/C;
210-255 A = B*C;
210-256
210-257 if (A lt B)
210-258 {
210-259 A = B + C;
210-260 D = E + F;
210-261 }
210-262
210-263
210-264 if (veg)
210-265 // missing curly brace
210-266 variable = orange;
210-267
210-268
210-269 if (A != B)
210-270 {
210-271 A = B + C;
210-272 D = E + F;
210-273 }
210-274
210-275 A = B+C;
210-276 A = B+C;
210-277 A = B+C;
210-278 A = B/C;
210-279
210-280 if (A < = B)
210-281 {
210-282 A = B + C;
210-283 D = E + F;
210-284 }
210-285
210-286 /* LE SV TOC-3848 this a wxp-07.2.22 req */
210-287 A = B*C;
210-288 A = B*C;
210-289 A = B+C;
210-290
210-291 if (A > B)
210-292 {
210-293 A = B + C;
210-294 D = E + F;
210-295 }
210-296
210-297
210-298 if (A == B)
210-299 {
210-300 A = B + C;
210-301 D = E + F;
210-302 }
210-303
210-304
210-305 if (A ne B)
210-306 {
210-307 A = B + C;
210-308 D = E + F;
210-309 }
210-310
210-311
210-312 if (A > B)
210-313 {
210-314 A = B + C;
210-315 D = E + F;
210-316 }
210-317
210-318 A = B*C;
210-319 A = B-C;
210-320 A = B/C;
210-321 A = B/C;
210-322 A = B/C;
210-323 do forever;
210-324
210-325 switch (wxp stuff)
210-326 {
210-327 case one:
210-328 {
210-329 run_this;
210-330 break;
210-331 }
210-332 case two:
210-333 {
210-334 run_this;
210-335 break;
210-336 }
210-337 default:
210-338 {
210-339 SwError;
210-340 }
210-341 }
210-342
210-343 A = B+C;
210-344 A = B+C;
210-345
210-346 if (A > B)
210-347 {
210-348 A = B + C;
210-349 D = E + F;
210-350 }
210-351
210-352 A = B-C;
210-353 A = B+C;
210-354 A = B+C;
210-355 A = B/C;
210-356 A = B+C;
210-357 A = B+C;
210-358 A = B+C;
210-359 A = B*C;
210-360 A = B/C;
210-361 A = B*C;
210-362
210-363 if (A ge B)
210-364 {
210-365 A = B + C;
210-366 D = E + F;
210-367 }
210-368
210-369 A = B/C;
210-370
210-371 if (A gt B)
210-372 {
210-373 A = B + C;
210-374 D = E + F;
210-375 }
210-376
210-377 A = B-C;
210-378 A = B/C;
210-379 A = B/C;
210-380 A = B-C;
210-381 A = B*C;
210-382 A = B-C;
210-383 A = B*C;
210-384
210-385 if (A le B)
210-386 {
210-387 A = B + C;
210-388 D = E + F;
210-389 }
210-390
210-391 /* LE SV TOC-3849 this a wxp-07.2.59 req */
210-392
210-393 if (A > = B)
210-394 {
210-395 A = B + C;
210-396 D = E + F;
210-397 }
210-398
210-399 A = B*C;
210-400
210-401 if (A ne B)
210-402 {
210-403 A = B + C;
210-404 D = E + F;
210-405 }
210-406
210-407 A = B*C;
210-408 A = B*C;
210-409 A = B*C;
210-410
210-411 switch (wxp stuff)
210-412 {
210-413 case one:
210-414 {
210-415 run_this;
210-416 break;
210-417 }
210-418 case two:
210-419 {
210-420 run_this;
210-421 break;
210-422 }
210-423 default:
210-424 {
210-425 SwError;
210-426 }
210-427 }
210-428
210-429 A = B-C;
210-430
210-431 if (A < B)
210-432 {
210-433 A = B + C;
210-434 D = E + F;
210-435 }
210-436
210-437 A = B+C;
210-438 // max LOC 68
210-439
210-440 }
210-441
210-442
210-443 /*
210-444 -----------------------------------------------------------------------------
210-445 --| NAME: wxp.7.3
210-446 --|
210-447 --| ABSTRACT:
210-448 --| This function does wxp stuff.
210-449 --|
210-450 --| RETURNS:
210-451 --| NONE.
210-452 --|
210-453 ----------------------------------------------------------------------------
210-454 */
210-455 static void wxp.7.3(void)
210-456 {
210-457 A = B-C;
210-458 A = B/C;
210-459 A = B-C;
210-460 A = B-C;
210-461 A = B+C;
210-462 A = B*C;
210-463 A = B-C;
210-464 A = B/C;
210-465 A = 0x0001;
210-466 A = B-C;
210-467 A = B-C;
210-468 A = B+C;
210-469 A = B*C;
210-470 A = B*C;
210-471 A = B*C;
210-472 A = B*C;
210-473 A = B+C;
210-474 A = 0x0002;
210-475 A = B+C;
210-476 A = B+C;
210-477 A = B-C;
210-478
210-479 switch (wxp stuff)
210-480 {
210-481 case one:
210-482 {
210-483 run_this;
210-484 break;
210-485 }
210-486 case two:
210-487 {
210-488 run_this;
210-489 break;
210-490 }
210-491 default:
210-492 {
210-493 SwError;
210-494 }
210-495 }
210-496
210-497
210-498 if (A != B)
210-499 {
210-500 A = B + C;
210-501 D = E + F;
210-502 }
210-503
210-504 A = B*C;
210-505
210-506 if (A == B)
210-507 {
210-508 A = B + C;
210-509 D = E + F;
210-510 }
210-511
210-512 A = B-C;
210-513 A = B*C;
210-514 A = B*C;
210-515 A = B*C;
210-516 A = B-C;
210-517 A = B*C;
210-518 A = B-C;
210-519 A = B+C;
210-520 A = B+C;
210-521 A = B+C;
210-522 A = B*C;
210-523 A = B/C;
210-524
210-525 if (A le B)
210-526 {
210-527 A = B + C;
210-528 D = E + F;
210-529 }
210-530
210-531 A = B+C;
210-532 A = B*C;
210-533
210-534 if (A lt B)
210-535 {
210-536 A = B + C;
210-537 D = E + F;
210-538 }
210-539
210-540 A = B*C;
210-541 goto error;
210-542 A = B+C;
210-543 A = B*C;
210-544 A = B+C;
210-545 A = B-C;
210-546 A = B/C;
210-547 A = B+C;
210-548 A = B*C;
210-549 A = B/C;
210-550 A = B/C;
210-551 A = B-C;
210-552
210-553 if (A > = B)
210-554 {
210-555 A = B + C;
210-556 D = E + F;
210-557 }
210-558
210-559 A = B*C;
210-560
210-561 if (A > B)
210-562 {
210-563 A = B + C;
210-564 D = E + F;
210-565 }
210-566
210-567 A = B/C;
210-568 A = B-C;
210-569 A = B*C;
210-570
210-571 if (A eq B)
210-572 {
210-573 A = B + C;
210-574 D = E + F;
210-575 }
210-576
210-577 A = B+C;
210-578 A = B-C;
210-579 // max LOC 59
210-580
210-581 }
210-582
210-583
210-584 /*
210-585 -----------------------------------------------------------------------------
210-586 --| NAME: wxp.7.4
210-587 --|
210-588 --| ABSTRACT:
210-589 --| This function does wxp stuff.
210-590 --|
210-591 --| RETURNS:
210-592 --| NONE.
210-593 --|
210-594 ----------------------------------------------------------------------------
210-595 */
210-596 static void wxp.7.4(void)
210-597 {
210-598 A = B/C;
210-599 A = B/C;
210-600 A = B/C;
210-601
210-602 if (A < = B)
210-603 {
210-604 A = B + C;
210-605 D = E + F;
210-606 }
210-607
210-608 A = B/C;
210-609 A = B-C;
210-610 A = B-C;
210-611 A = B+C;
210-612 // max LOC 8
210-613
210-614 }
210-615
210-616
210-617 /*
210-618 -----------------------------------------------------------------------------
210-619 --| NAME: wxp.7.5
210-620 --|
210-621 --| ABSTRACT:
210-622 --| This function does wxp stuff.
210-623 --|
210-624 --| RETURNS:
210-625 --| NONE.
210-626 --|
210-627 ----------------------------------------------------------------------------
210-628 */
210-629 static void wxp.7.5(void)
210-630 {
210-631 A = B*C;
210-632
210-633 if (A lt B)
210-634 {
210-635 A = B + C;
210-636 D = E + F;
210-637 }
210-638
210-639
210-640 if (A ne B)
210-641 {
210-642 A = B + C;
210-643 D = E + F;
210-644 }
210-645
210-646 A = B*C;
210-647 A = B*C;
210-648 A = B-C;
210-649 A = B/C;
210-650
210-651 if (A ne B)
210-652 {
210-653 A = B + C;
210-654 D = E + F;
210-655 }
210-656
210-657 /* LE SV TOC-3850 this a wxp-07.5.9 req */
210-658 A = B/C;
210-659 A = B*C;
210-660 A = B+C;
210-661 A = B/C;
210-662 A = B-C;
210-663 A = B-C;
210-664 A = B+C;
210-665 A = B+C;
210-666 A = B-C;
210-667 A = B+C;
210-668 A = B+C;
210-669 // max LOC 19
210-670
210-671 }
210-672
210 210 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-07.c
211 211 Source: source/ft-app/ft-app-B1.0/wxp/wxp-08.c
211-0 /*
211-1 ----------------------------------------------------------------------------
211-2 --| BEGIN PROLOGUE
211-3 --|
211-4 --| CLASSIFICATION: UNCLASSIFIED
211-5 --|
211-6 --| FILE NAME: wxp-08.c
211-7 --|
211-8 --| ABSTRACT:
211-9 --| This file contains the 1 functions that do file wxp stuff.
211-10 --|
211-11 --| HISTORY:
211-12 --| CCCQ_NAME:
211-13 --| CCCQ_VER:
211-14 --|
211-15 --| END PROLOGUE
211-16 ----------------------------------------------------------------------------
211-17 */
211-18
211-19 #define C;
211-20 #define C;
211-21 #define B;
211-22 int A;
211-23
211-24
211-25
211-26 /*
211-27 -----------------------------------------------------------------------------
211-28 --| NAME: wxp.8.1
211-29 --|
211-30 --| ABSTRACT:
211-31 --| This function does wxp stuff.
211-32 --|
211-33 --| RETURNS:
211-34 --| NONE.
211-35 --|
211-36 ----------------------------------------------------------------------------
211-37 */
211-38 static void wxp.8.1(void)
211-39 {
211-40 A = B*C;
211-41 A = B*C;
211-42 A = B+C;
211-43 A = B/C;
211-44 A = B/C;
211-45
211-46 if (A != B)
211-47 {
211-48 A = B + C;
211-49 D = E + F;
211-50 }
211-51
211-52 A = B/C;
211-53 A = B*C;
211-54 A = B+C;
211-55 A = B+C;
211-56 A = B-C;
211-57
211-58 if (A < B)
211-59 {
211-60 A = B + C;
211-61 D = E + F;
211-62 }
211-63
211-64 A = B*C;
211-65 A = B/C;
211-66 A = B-C;
211-67 A = B/C;
211-68 do forever;
211-69 A = B/C;
211-70 /* LE SV TOC-3851 this a wxp-08.1.18 req */
211-71 A = B/C;
211-72 A = B+C;
211-73 A = B+C;
211-74 A = B+C;
211-75 A = B*C;
211-76 A = B/C;
211-77 A = B-C;
211-78 A = B/C;
211-79 A = B*C;
211-80 A = B/C;
211-81
211-82 if (A ge B)
211-83 {
211-84 A = B + C;
211-85 D = E + F;
211-86 }
211-87
211-88 A = B/C;
211-89
211-90 switch (wxp stuff)
211-91 {
211-92 case one:
211-93 {
211-94 switch (nested)
211-95 {
211-96 case:
211-97 X = Y + Z;
211-98 case:
211-99 X = Y + Z;
211-100 default:
211-101 SwError;
211-102 }
211-103 }
211-104 case two:
211-105 {
211-106 run_this;
211-107 break;
211-108 }
211-109 default:
211-110 {
211-111 SwError;
211-112 }
211-113 }
211-114
211-115 A = B+C;
211-116
211-117 if (A > = B)
211-118 {
211-119 A = B + C;
211-120 D = E + F;
211-121 }
211-122
211-123 A = B+C;
211-124 A = B/C;
211-125 /* LE SV TOC-3852 this a wxp-08.1.34 req */
211-126 A = B-C;
211-127 A = B/C;
211-128 A = B-C;
211-129 A = B*C;
211-130 A = B-C;
211-131 A = B/C;
211-132 /* LE SV TOC-3853 this a wxp-08.1.40 req */
211-133
211-134 if (A < B)
211-135 {
211-136 A = B + C;
211-137 D = E + F;
211-138 }
211-139
211-140 // max LOC 40
211-141
211-142 }
211-143
211 211 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-08.c
212 212 Source: source/ft-app/ft-app-B1.0/wxp/wxp-09.c
212-0 /*
212-1 ----------------------------------------------------------------------------
212-2 --| BEGIN PROLOGUE
212-3 --|
212-4 --| CLASSIFICATION: UNCLASSIFIED
212-5 --|
212-6 --| FILE NAME: wxp-09.c
212-7 --|
212-8 --| ABSTRACT:
212-9 --| This file contains the 3 functions that do file wxp stuff.
212-10 --|
212-11 --| HISTORY:
212-12 --| CCCQ_NAME:
212-13 --| CCCQ_VER:
212-14 --|
212-15 --| END PROLOGUE
212-16 ----------------------------------------------------------------------------
212-17 */
212-18
212-19 float B;
212-20 double C;
212-21 #define B;
212-22 #define A;
212-23 #include A;
212-24 double C;
212-25 int A;
212-26
212-27
212-28
212-29 /*
212-30 -----------------------------------------------------------------------------
212-31 --| NAME: wxp.9.1
212-32 --|
212-33 --| ABSTRACT:
212-34 --| This function does wxp stuff.
212-35 --|
212-36 --| RETURNS:
212-37 --| NONE.
212-38 --|
212-39 ----------------------------------------------------------------------------
212-40 */
212-41 static void wxp.9.1(void)
212-42 {
212-43 A = B-C;
212-44 A = B*C;
212-45 A = B/C;
212-46 A = B/C;
212-47 A = B*C;
212-48 A = B*C;
212-49 A = B-C;
212-50 A = B-C;
212-51 A = B/C;
212-52 A = B/C;
212-53 A = B/C;
212-54 A = B/C;
212-55 A = B-C;
212-56 A = B+C;
212-57
212-58 switch (wxp stuff)
212-59 {
212-60 case one:
212-61 {
212-62 run_this;
212-63 break;
212-64 }
212-65 case two:
212-66 {
212-67 run_this;
212-68 break;
212-69 }
212-70 default:
212-71 {
212-72 SwError;
212-73 }
212-74 }
212-75
212-76 A = B-C;
212-77
212-78 if (A < B)
212-79 {
212-80 A = B + C;
212-81 D = E + F;
212-82 }
212-83
212-84
212-85 if (A eq B)
212-86 {
212-87 A = B + C;
212-88 D = E + F;
212-89 }
212-90
212-91 A = B/C;
212-92 A = B*C;
212-93 rcv_buffer = (U16 *) alloc(size+1);
212-94 A = B-C;
212-95 A = B/C;
212-96 A = B-C;
212-97 A = B+C;
212-98 A = B*C;
212-99 A = B+C;
212-100 A = B-C;
212-101 /* LE SV TOC-3854 this a wxp-09.1.28 req */
212-102 A = B-C;
212-103 A = B+C;
212-104
212-105 if (A ne B)
212-106 {
212-107 A = B + C;
212-108 D = E + F;
212-109 }
212-110
212-111 A = B+C;
212-112 A = B-C;
212-113
212-114 if (A < = B)
212-115 {
212-116 A = B + C;
212-117 D = E + F;
212-118 }
212-119
212-120 A = B*C;
212-121 A = B-C;
212-122
212-123 if (A < = B)
212-124 {
212-125 A = B + C;
212-126 D = E + F;
212-127 }
212-128
212-129
212-130 if (A != B)
212-131 {
212-132 A = B + C;
212-133 D = E + F;
212-134 }
212-135
212-136 A = B-C;
212-137 A = B+C;
212-138 A = B*C;
212-139 A = B*C;
212-140 A = B*C;
212-141 A = B/C;
212-142
212-143 if (A == B)
212-144 {
212-145 A = B + C;
212-146 D = E + F;
212-147 }
212-148
212-149 A = B/C;
212-150 A = B+C;
212-151 A = B+C;
212-152 A = B/C;
212-153 A = B+C;
212-154
212-155 if (A > B)
212-156 {
212-157 A = B + C;
212-158 D = E + F;
212-159 }
212-160
212-161 A = B*C;
212-162
212-163 switch (wxp stuff)
212-164 {
212-165 case one:
212-166 {
212-167 run_this;
212-168 break;
212-169 }
212-170 case two:
212-171 {
212-172 run_this;
212-173 break;
212-174 }
212-175 // missing default
212-176 }
212-177
212-178
212-179 if (A lt B)
212-180 {
212-181 A = B + C;
212-182 D = E + F;
212-183 }
212-184
212-185 A = B/C;
212-186
212-187 if (A ne B)
212-188 {
212-189 A = B + C;
212-190 D = E + F;
212-191 }
212-192
212-193 A = B-C;
212-194
212-195 if (A lt B)
212-196 {
212-197 A = B + C;
212-198 D = E + F;
212-199 }
212-200
212-201 A = B/C;
212-202 A = B-C;
212-203 A = B*C;
212-204 A = B/C;
212-205 A = B*C;
212-206 A = B-C;
212-207 A = B-C;
212-208
212-209 if ($wxp stuff > $otherwxp stuff)
212-210 /* LE SV TOC-008 we really should log all error calls */
212-211 {
212-212 A = B + C;
212-213 }
212-214
212-215 A = B*C;
212-216 // max LOC 64
212-217
212-218 }
212-219
212-220
212-221 /*
212-222 -----------------------------------------------------------------------------
212-223 --| NAME: wxp.9.2
212-224 --|
212-225 --| ABSTRACT:
212-226 --| This function does wxp stuff.
212-227 --|
212-228 --| RETURNS:
212-229 --| NONE.
212-230 --|
212-231 ----------------------------------------------------------------------------
212-232 */
212-233 static void wxp.9.2(void)
212-234 {
212-235 /* LE SV TOC-3855 this a wxp-09.2.1 req */
212-236 A = B/C;
212-237 A = (long)B + C;
212-238
212-239 if (A gt B)
212-240 {
212-241 A = B + C;
212-242 D = E + F;
212-243 }
212-244
212-245 A = B-C;
212-246 A = B-C;
212-247 A = B/C;
212-248 A = B/C;
212-249 A = B-C;
212-250 A = B*C;
212-251 A = B+C;
212-252 A = B+C;
212-253
212-254 if (A < = B)
212-255 {
212-256 A = B + C;
212-257 D = E + F;
212-258 }
212-259
212-260
212-261 if (A < = B)
212-262 {
212-263 A = B + C;
212-264 D = E + F;
212-265 }
212-266
212-267 A = B/C;
212-268 A = B*C;
212-269 A = B*C;
212-270 A = B/C;
212-271
212-272 if (A > B)
212-273 {
212-274 A = B + C;
212-275 D = E + F;
212-276 }
212-277
212-278 A = B+C;
212-279 A = B+C;
212-280 A = B/C;
212-281 A = B*C;
212-282
212-283 if (A le B)
212-284 {
212-285 A = B + C;
212-286 D = E + F;
212-287 }
212-288
212-289 A = B+C;
212-290 A = B*C;
212-291
212-292 if (A == B)
212-293 {
212-294 A = B + C;
212-295 D = E + F;
212-296 }
212-297
212-298 A = B-C;
212-299 A = B+C;
212-300 A = B/C;
212-301 A = B+C;
212-302 A = B/C;
212-303 A = B/C;
212-304
212-305 if (A le B)
212-306 {
212-307 A = B + C;
212-308 D = E + F;
212-309 }
212-310
212-311
212-312 if (A == B)
212-313 {
212-314 A = B + C;
212-315 D = E + F;
212-316 }
212-317
212-318
212-319 if (A gt B)
212-320 {
212-321 A = B + C;
212-322 D = E + F;
212-323 }
212-324
212-325
212-326 if (A ge B)
212-327 {
212-328 A = B + C;
212-329 D = E + F;
212-330 }
212-331
212-332
212-333 if (A lt B)
212-334 {
212-335 A = B + C;
212-336 D = E + F;
212-337 }
212-338
212-339
212-340 if (A < B)
212-341 {
212-342 A = B + C;
212-343 D = E + F;
212-344 }
212-345
212-346 A = B-C;
212-347 A = B*C;
212-348 A = B/C;
212-349 A = B-C;
212-350 A = B-C;
212-351 A = B+C;
212-352 A = B*C;
212-353 A = B+C;
212-354 A = B-C;
212-355 A = B*C;
212-356 A = B-C;
212-357 A = B/C;
212-358 /* LE SV TOC-3856 this a wxp-09.2.50 req */
212-359 A = B*C;
212-360 A = B-C;
212-361 // TBD - what do I do now
212-362
212-363 switch (wxp stuff)
212-364 {
212-365 case one:
212-366 {
212-367 run_this;
212-368 break;
212-369 }
212-370 case two:
212-371 {
212-372 run_this;
212-373 break;
212-374 }
212-375 default:
212-376 {
212-377 SwError;
212-378 }
212-379 }
212-380
212-381 A = B-C;
212-382 A = B/C;
212-383 A = B/C;
212-384 A = B-C;
212-385 A = B-C;
212-386 A = B-C;
212-387 A = B/C;
212-388 A = B/C;
212-389 A = B*C;
212-390
212-391 switch (wxp stuff)
212-392 {
212-393 case one:
212-394 {
212-395 run_this;
212-396 // missing break
212-397 }
212-398 case two:
212-399 {
212-400 run_this;
212-401 break;
212-402 }
212-403 default:
212-404 {
212-405 SwError;
212-406 }
212-407 }
212-408
212-409 A = B*C;
212-410 A = B+C;
212-411 A = B+C;
212-412 A = B+C;
212-413 A = (long)B + C;
212-414 A = B-C;
212-415 A = B*C;
212-416
212-417 if (A gt B)
212-418 {
212-419 A = B + C;
212-420 D = E + F;
212-421 }
212-422
212-423
212-424 if (A == B)
212-425 {
212-426 A = B + C;
212-427 D = E + F;
212-428 }
212-429
212-430
212-431 if (A > = B)
212-432 {
212-433 A = B + C;
212-434 D = E + F;
212-435 }
212-436
212-437 A = B-C;
212-438 A = B-C;
212-439 // max LOC 72
212-440
212-441 }
212-442
212-443
212-444 /*
212-445 -----------------------------------------------------------------------------
212-446 --| NAME: wxp.9.3
212-447 --|
212-448 --| ABSTRACT:
212-449 --| This function does wxp stuff.
212-450 --|
212-451 --| RETURNS:
212-452 --| NONE.
212-453 --|
212-454 ----------------------------------------------------------------------------
212-455 */
212-456 static void wxp.9.3(void)
212-457 {
212-458
212-459 if (A < = B)
212-460 {
212-461 A = B + C;
212-462 D = E + F;
212-463 }
212-464
212-465 A = B-C;
212-466 A = B*C;
212-467 A = B/C;
212-468
212-469 if (A ne B)
212-470 {
212-471 A = B + C;
212-472 D = E + F;
212-473 }
212-474
212-475 A = B+C;
212-476 A = B-C;
212-477 A = B*C;
212-478
212-479 if (A ge B)
212-480 {
212-481 A = B + C;
212-482 D = E + F;
212-483 }
212-484
212-485 A = B+C;
212-486 A = B*C;
212-487 A = B-C;
212-488 A = B-C;
212-489 A = B/C;
212-490 A = B/C;
212-491 A = B*C;
212-492 A = B/C;
212-493 A = B+C;
212-494
212-495 if {
212-496 X = Y + Z;
212-497 }
212-498 else {
212-499 halt;
212-500 }
212-501
212-502 A = B-C;
212-503
212-504 if (A eq B)
212-505 {
212-506 A = B + C;
212-507 D = E + F;
212-508 }
212-509
212-510 A = B+C;
212-511 A = B/C;
212-512 A = B/C;
212-513 A = B/C;
212-514 A = B*C;
212-515 A = B+C;
212-516 /* LE SV TOC-3857 this a wxp-09.3.27 req */
212-517 A = B-C;
212-518 A = B-C;
212-519 A = B/C;
212-520 A = B-C;
212-521 A = B/C;
212-522
212-523 if (A ne B)
212-524 {
212-525 A = B + C;
212-526 D = E + F;
212-527 }
212-528
212-529 A = B/C;
212-530 A = B+C;
212-531 A = B+C;
212-532
212-533 if (A ne B)
212-534 {
212-535 A = B + C;
212-536 D = E + F;
212-537 }
212-538
212-539 A = B+C;
212-540
212-541 if (A le B)
212-542 {
212-543 A = B + C;
212-544 D = E + F;
212-545 }
212-546
212-547 A = B*C;
212-548 A = B/C;
212-549
212-550 if (A == B)
212-551 {
212-552 A = B + C;
212-553 D = E + F;
212-554 }
212-555
212-556
212-557 if (A ne B)
212-558 {
212-559 A = B + C;
212-560 D = E + F;
212-561 }
212-562
212-563 A = B+C;
212-564
212-565 if (A > = B)
212-566 {
212-567 A = B + C;
212-568 D = E + F;
212-569 }
212-570
212-571 /* LE SV TOC-3858 this a wxp-09.3.45 req */
212-572 A = B+C;
212-573 A = B-C;
212-574 A = B*C;
212-575
212-576 if (A > B)
212-577 {
212-578 A = B + C;
212-579 D = E + F;
212-580 }
212-581
212-582 A = B*C;
212-583
212-584 if (A < = B)
212-585 {
212-586 A = B + C;
212-587 D = E + F;
212-588 }
212-589
212-590 // max LOC 50
212-591
212-592 }
212-593
212 212 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-09.c
213 213 Source: source/ft-app/ft-app-B1.0/wxp/wxp-10.c
213-0 /*
213-1 ----------------------------------------------------------------------------
213-2 --| BEGIN PROLOGUE
213-3 --|
213-4 --| CLASSIFICATION: UNCLASSIFIED
213-5 --|
213-6 --| FILE NAME: wxp-10.c
213-7 --|
213-8 --| ABSTRACT:
213-9 --| This file contains the 5 functions that do file wxp stuff.
213-10 --|
213-11 --| HISTORY:
213-12 --| CCCQ_NAME:
213-13 --| CCCQ_VER:
213-14 --|
213-15 --| END PROLOGUE
213-16 ----------------------------------------------------------------------------
213-17 */
213-18
213-19 int A;
213-20 double C;
213-21
213-22
213-23
213-24 /*
213-25 -----------------------------------------------------------------------------
213-26 --| NAME: wxp.10.1
213-27 --|
213-28 --| ABSTRACT:
213-29 --| This function does wxp stuff.
213-30 --|
213-31 --| RETURNS:
213-32 --| NONE.
213-33 --|
213-34 ----------------------------------------------------------------------------
213-35 */
213-36 static void wxp.10.1(void)
213-37 {
213-38 A = B/C;
213-39 A = B+C;
213-40 A = B*C;
213-41 A = B*C;
213-42 A = B/C;
213-43 A = B-C;
213-44 A = B+C;
213-45
213-46 if (A ne B)
213-47 {
213-48 A = B + C;
213-49 D = E + F;
213-50 }
213-51
213-52 /* LE SV TOC-3859 this a wxp-10.1.9 req */
213-53 A = B-C;
213-54 A = B*C;
213-55
213-56 if (A ge B)
213-57 {
213-58 A = B + C;
213-59 D = E + F;
213-60 }
213-61
213-62 A = B/C;
213-63 A = B+C;
213-64 rcv_buffer = (U16 *) alloc(size+1);
213-65 A = B*C;
213-66 A = B*C;
213-67 A = B-C;
213-68
213-69 if (A > B)
213-70 {
213-71 A = B + C;
213-72 D = E + F;
213-73 }
213-74
213-75 A = B*C;
213-76 A = B*C;
213-77 /* LE SV TOC-3860 this a wxp-10.1.20 req */
213-78 A = B+C;
213-79 free(FreePtr);
213-80 A = B*C;
213-81
213-82 if (A lt B)
213-83 {
213-84 A = B + C;
213-85 D = E + F;
213-86 }
213-87
213-88 A = B+C;
213-89 A = B/C;
213-90 A = B+C;
213-91
213-92 if (A < B)
213-93 {
213-94 A = B + C;
213-95 D = E + F;
213-96 }
213-97
213-98 A = B+C;
213-99 A = B-C;
213-100 A = B*C;
213-101
213-102 if (A gt B)
213-103 {
213-104 A = B + C;
213-105 D = E + F;
213-106 }
213-107
213-108 A = B/C;
213-109 A = B-C;
213-110 A = B+C;
213-111 A = B-C;
213-112 /* LE SV TOC-3861 this a wxp-10.1.35 req */
213-113 A = B+C;
213-114 A = B+C;
213-115 A = B-C;
213-116 A = B*C;
213-117 A = 0x0004;
213-118
213-119 switch (wxp stuff)
213-120 {
213-121 case one:
213-122 {
213-123 run_this;
213-124 break;
213-125 }
213-126 case two:
213-127 {
213-128 run_this;
213-129 break;
213-130 }
213-131 default:
213-132 {
213-133 SwError;
213-134 }
213-135 }
213-136
213-137 A = B+C;
213-138 A = B-C;
213-139 /* LE SV TOC-3862 this a wxp-10.1.42 req */
213-140
213-141 switch (wxp stuff)
213-142 {
213-143 case one:
213-144 {
213-145 run_this;
213-146 break;
213-147 }
213-148 case two:
213-149 {
213-150 run_this;
213-151 break;
213-152 }
213-153 default:
213-154 {
213-155 SwError;
213-156 }
213-157 }
213-158
213-159 A = B*C;
213-160 A = B-C;
213-161 A = B+C;
213-162 A = B*C;
213-163 A = B-C;
213-164 A = B/C;
213-165 A = B*C;
213-166 /* LE SV TOC-3863 this a wxp-10.1.50 req */
213-167 A = B*C;
213-168 A = B/C;
213-169 A = B*C;
213-170 A = B*C;
213-171 A = B-C;
213-172 A = B/C;
213-173 // max LOC 55
213-174
213-175 }
213-176
213-177
213-178 /*
213-179 -----------------------------------------------------------------------------
213-180 --| NAME: wxp.10.2
213-181 --|
213-182 --| ABSTRACT:
213-183 --| This function does wxp stuff.
213-184 --|
213-185 --| RETURNS:
213-186 --| NONE.
213-187 --|
213-188 ----------------------------------------------------------------------------
213-189 */
213-190 static void wxp.10.2(void)
213-191 {
213-192 A = B/C;
213-193 A = B*C;
213-194 A = B/C;
213-195 A = B/C;
213-196
213-197 if (A le B)
213-198 {
213-199 A = B + C;
213-200 D = E + F;
213-201 }
213-202
213-203 A = B+C;
213-204
213-205 if (A < = B)
213-206 {
213-207 A = B + C;
213-208 D = E + F;
213-209 }
213-210
213-211 A = B*C;
213-212 A = B-C;
213-213 /* LE SV TOC-3864 this a wxp-10.2.10 req */
213-214 A = B/C;
213-215 A = B+C;
213-216 A = B-C;
213-217
213-218 if (A eq B)
213-219 {
213-220 A = B + C;
213-221 D = E + F;
213-222 }
213-223
213-224
213-225 if (A != B)
213-226 {
213-227 A = B + C;
213-228 D = E + F;
213-229 }
213-230
213-231
213-232 if (A < B)
213-233 {
213-234 A = B + C;
213-235 D = E + F;
213-236 }
213-237
213-238 A = B-C;
213-239 A = B-C;
213-240 A = B-C;
213-241 A = B/C;
213-242 A = B/C;
213-243 A = B-C;
213-244 A = B/C;
213-245 A = B*C;
213-246 A = B+C;
213-247 A = B/C;
213-248 A = B/C;
213-249 A = B-C;
213-250
213-251 switch (wxp stuff)
213-252 {
213-253 case one:
213-254 {
213-255 run_this;
213-256 break;
213-257 }
213-258 case two:
213-259 {
213-260 run_this;
213-261 break;
213-262 }
213-263 default:
213-264 {
213-265 SwError;
213-266 }
213-267 }
213-268
213-269
213-270 if (A > B)
213-271 {
213-272 A = B + C;
213-273 D = E + F;
213-274 }
213-275
213-276
213-277 if (A > B)
213-278 {
213-279 A = B + C;
213-280 D = E + F;
213-281 }
213-282
213-283 A = B*C;
213-284 A = B/C;
213-285 A = B/C;
213-286 A = B*C;
213-287 A = B+C;
213-288
213-289 if (A < = B)
213-290 {
213-291 A = B + C;
213-292 D = E + F;
213-293 }
213-294
213-295 A = B*C;
213-296 A = B*C;
213-297 A = B/C;
213-298
213-299 if (A < = B)
213-300 {
213-301 A = B + C;
213-302 D = E + F;
213-303 }
213-304
213-305 A = B/C;
213-306 A = B/C;
213-307 /* LE SV TOC-3865 this a wxp-10.2.43 req */
213-308 A = B+C;
213-309 A = B+C;
213-310
213-311 if (A < = B)
213-312 {
213-313 A = B + C;
213-314 D = E + F;
213-315 }
213-316
213-317 A = B/C;
213-318 A = B/C;
213-319
213-320 if (A > = B)
213-321 {
213-322 A = B + C;
213-323 D = E + F;
213-324 }
213-325
213-326 A = B*C;
213-327
213-328 if (A < = B)
213-329 {
213-330 A = B + C;
213-331 D = E + F;
213-332 }
213-333
213-334 A = B*C;
213-335 A = B-C;
213-336 A = B-C;
213-337 A = B/C;
213-338 A = B/C;
213-339 A = B-C;
213-340 /* LE SV TOC-3866 this a wxp-10.2.57 req */
213-341 A = B-C;
213-342 A = B+C;
213-343 A = B/C;
213-344 A = B*C;
213-345 A = B*C;
213-346 A = B-C;
213-347 A = B*C;
213-348 /* LE SV TOC-3867 this a wxp-10.2.64 req */
213-349 A = B-C;
213-350 A = B+C;
213-351 A = B-C;
213-352 A = B/C;
213-353 A = B*C;
213-354
213-355 switch (wxp stuff)
213-356 {
213-357 case one:
213-358 {
213-359 run_this;
213-360 break;
213-361 }
213-362 case two:
213-363 {
213-364 run_this;
213-365 break;
213-366 }
213-367 default:
213-368 {
213-369 SwError;
213-370 }
213-371 }
213-372
213-373 A = B*C;
213-374 A = B-C;
213-375 A = B*C;
213-376 A = B/C;
213-377 A = B/C;
213-378 A = B+C;
213-379 A = B/C;
213-380 A = B+C;
213-381 A = B/C;
213-382 A = B/C;
213-383 A = B/C;
213-384 A = B/C;
213-385 // max LOC 81
213-386
213-387 }
213-388
213-389
213-390 /*
213-391 -----------------------------------------------------------------------------
213-392 --| NAME: wxp.10.3
213-393 --|
213-394 --| ABSTRACT:
213-395 --| This function does wxp stuff.
213-396 --|
213-397 --| RETURNS:
213-398 --| NONE.
213-399 --|
213-400 ----------------------------------------------------------------------------
213-401 */
213-402 static void wxp.10.3(void)
213-403 {
213-404 A = B-C;
213-405 A = B*C;
213-406
213-407 if (A ge B)
213-408 {
213-409 A = B + C;
213-410 D = E + F;
213-411 }
213-412
213-413 A = 0x0001;
213-414 A = B-C;
213-415 A = B*C;
213-416 A = B+C;
213-417 A = B*C;
213-418 A = B+C;
213-419 A = B-C;
213-420
213-421 if (A > B)
213-422 {
213-423 A = B + C;
213-424 D = E + F;
213-425 }
213-426
213-427 A = B+C;
213-428 A = B+C;
213-429 A = B-C;
213-430 A = B/C;
213-431 A = B/C;
213-432 send_buffer = (U16 *) malloc(size+1);
213-433 A = B+C;
213-434 A = B*C;
213-435 A = B*C;
213-436 A = B-C;
213-437 /* LE SV TOC-3868 this a wxp-10.3.20 req */
213-438 A = B-C;
213-439
213-440 if (A eq B)
213-441 {
213-442 A = B + C;
213-443 D = E + F;
213-444 }
213-445
213-446
213-447 if (A lt B)
213-448 {
213-449 A = B + C;
213-450 D = E + F;
213-451 }
213-452
213-453 // max LOC 22
213-454
213-455 }
213-456
213-457
213-458 /*
213-459 -----------------------------------------------------------------------------
213-460 --| NAME: wxp.10.4
213-461 --|
213-462 --| ABSTRACT:
213-463 --| This function does wxp stuff.
213-464 --|
213-465 --| RETURNS:
213-466 --| NONE.
213-467 --|
213-468 ----------------------------------------------------------------------------
213-469 */
213-470 static void wxp.10.4(void)
213-471 {
213-472 A = B-C;
213-473 A = B+C;
213-474
213-475 if (A > = B)
213-476 {
213-477 A = B + C;
213-478 D = E + F;
213-479 }
213-480
213-481 A = B-C;
213-482 A = B*C;
213-483 A = B-C;
213-484 /* dead_code = B + C; */
213-485 A = B/C;
213-486 A = B*C;
213-487 A = B*C;
213-488
213-489 switch (wxp stuff)
213-490 {
213-491 case one:
213-492 {
213-493 run_this;
213-494 break;
213-495 }
213-496 case two:
213-497 {
213-498 run_this;
213-499 break;
213-500 }
213-501 default:
213-502 {
213-503 // missing error call
213-504 }
213-505 }
213-506
213-507
213-508 if (A ne B)
213-509 {
213-510 A = B + C;
213-511 D = E + F;
213-512 }
213-513
213-514 A = B-C;
213-515 A = B+C;
213-516
213-517 if (A > = B)
213-518 {
213-519 A = B + C;
213-520 D = E + F;
213-521 }
213-522
213-523 A = B-C;
213-524 A = B*C;
213-525 A = B/C;
213-526
213-527 if (A ne B)
213-528 {
213-529 A = B + C;
213-530 D = E + F;
213-531 }
213-532
213-533 A = B-C;
213-534 A = B/C;
213-535 A = B/C;
213-536 A = B+C;
213-537 A = B-C;
213-538 A = B/C;
213-539
213-540 if (A > = B)
213-541 {
213-542 A = B + C;
213-543 D = E + F;
213-544 }
213-545
213-546 A = B-C;
213-547 A = 0x0004;
213-548 A = B*C;
213-549 A = B*C;
213-550 A = B-C;
213-551 A = B+C;
213-552 A = B-C;
213-553
213-554 if (A > B)
213-555 {
213-556 A = B + C;
213-557 D = E + F;
213-558 }
213-559
213-560 A = B+C;
213-561
213-562 if (A lt B)
213-563 {
213-564 A = B + C;
213-565 D = E + F;
213-566 }
213-567
213-568 A = B-C;
213-569 A = B/C;
213-570 A = B*C;
213-571 // max LOC 36
213-572
213-573 }
213-574
213-575
213-576 /*
213-577 -----------------------------------------------------------------------------
213-578 --| NAME: wxp.10.5
213-579 --|
213-580 --| ABSTRACT:
213-581 --| This function does wxp stuff.
213-582 --|
213-583 --| RETURNS:
213-584 --| NONE.
213-585 --|
213-586 ----------------------------------------------------------------------------
213-587 */
213-588 static void wxp.10.5(void)
213-589 {
213-590 A = B-C;
213-591
213-592 if (A < B)
213-593 {
213-594 A = B + C;
213-595 D = E + F;
213-596 }
213-597
213-598 A = B*C;
213-599
213-600 switch (wxp stuff)
213-601 {
213-602 case one:
213-603 {
213-604 run_this;
213-605 break;
213-606 }
213-607 case two:
213-608 {
213-609 run_this;
213-610 break;
213-611 }
213-612 default:
213-613 {
213-614 SwError;
213-615 }
213-616 }
213-617
213-618 A = B-C;
213-619 A = 0x0009;
213-620
213-621 if (A ne B)
213-622 {
213-623 A = B + C;
213-624 D = E + F;
213-625 }
213-626
213-627
213-628 switch (wxp stuff)
213-629 {
213-630 case one:
213-631 {
213-632 run_this;
213-633 // missing break
213-634 }
213-635 case two:
213-636 {
213-637 run_this;
213-638 break;
213-639 }
213-640 default:
213-641 {
213-642 SwError;
213-643 }
213-644 }
213-645
213-646 A = B-C;
213-647 A = B+C;
213-648 A = 0x0001;
213-649 A = B-C;
213-650 A = B*C;
213-651 A = B*C;
213-652 A = B-C;
213-653 A = B+C;
213-654 A = B/C;
213-655
213-656 if (A eq B)
213-657 {
213-658 A = B + C;
213-659 D = E + F;
213-660 }
213-661
213-662 A = B-C;
213-663
213-664 if (A == B)
213-665 {
213-666 A = B + C;
213-667 D = E + F;
213-668 }
213-669
213-670 A = B-C;
213-671
213-672 if (A eq B)
213-673 {
213-674 A = B + C;
213-675 D = E + F;
213-676 }
213-677
213-678
213-679 if {
213-680 X = Y + Z;
213-681 }
213-682 else {
213-683 halt;
213-684 }
213-685
213-686 A = B*C;
213-687 A = B/C;
213-688 A = B+C;
213-689 A = B-C;
213-690 A = B-C;
213-691 A = B-C;
213-692 A = B-C;
213-693 A = B+C;
213-694 A = B/C;
213-695 A = B*C;
213-696 A = B*C;
213-697 A = B+C;
213-698 A = B/C;
213-699 A = B-C;
213-700 A = B-C;
213-701 A = B/C;
213-702 A = B+C;
213-703 A = B/C;
213-704 A = B+C;
213-705 // max LOC 38
213-706
213-707 }
213-708
213 213 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-10.c
214 214 Source: source/ft-app/ft-app-B1.0/wxp/wxp-11.c
214-0 /*
214-1 ----------------------------------------------------------------------------
214-2 --| BEGIN PROLOGUE
214-3 --|
214-4 --| CLASSIFICATION: UNCLASSIFIED
214-5 --|
214-6 --| FILE NAME: wxp-11.c
214-7 --|
214-8 --| ABSTRACT:
214-9 --| This file contains the 1 functions that do file wxp stuff.
214-10 --|
214-11 --| HISTORY:
214-12 --| CCCQ_NAME:
214-13 --| CCCQ_VER:
214-14 --|
214-15 --| END PROLOGUE
214-16 ----------------------------------------------------------------------------
214-17 */
214-18
214-19 int A;
214-20 float B;
214-21 double C;
214-22
214-23
214-24
214-25 /*
214-26 -----------------------------------------------------------------------------
214-27 --| NAME: wxp.11.1
214-28 --|
214-29 --| ABSTRACT:
214-30 --| This function does wxp stuff.
214-31 --|
214-32 --| RETURNS:
214-33 --| NONE.
214-34 --|
214-35 ----------------------------------------------------------------------------
214-36 */
214-37 static void wxp.11.1(void)
214-38 {
214-39 A = B/C;
214-40 A = B+C;
214-41 A = B+C;
214-42 /* LE SV TOC-3869 this a wxp-11.1.4 req */
214-43 A = B-C;
214-44 A = B-C;
214-45 goto error;
214-46 A = B*C;
214-47
214-48 if (A ne B)
214-49 {
214-50 A = B + C;
214-51 D = E + F;
214-52 }
214-53
214-54 A = B/C;
214-55 A = B-C;
214-56 A = 0x0004;
214-57
214-58 if (A le B)
214-59 {
214-60 A = B + C;
214-61 D = E + F;
214-62 }
214-63
214-64 A = B/C;
214-65 /* LE SV TOC-3870 this a wxp-11.1.12 req */
214-66 A = B*C;
214-67 A = B/C;
214-68 A = B/C;
214-69 A = B-C;
214-70 A = B-C;
214-71 A = B+C;
214-72 /* LE SV TOC-3871 this a wxp-11.1.18 req */
214-73
214-74 if (A < B)
214-75 {
214-76 A = B + C;
214-77 D = E + F;
214-78 }
214-79
214-80 A = B/C;
214-81 // max LOC 19
214-82
214-83 }
214-84
214 214 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-11.c
215 215 Source: source/ft-app/ft-app-B1.0/wxp/wxp-12.c
215-0 /*
215-1 ----------------------------------------------------------------------------
215-2 --| BEGIN PROLOGUE
215-3 --|
215-4 --| CLASSIFICATION: UNCLASSIFIED
215-5 --|
215-6 --| FILE NAME: wxp-12.c
215-7 --|
215-8 --| ABSTRACT:
215-9 --| This file contains the 2 functions that do file wxp stuff.
215-10 --|
215-11 --| HISTORY:
215-12 --| CCCQ_NAME:
215-13 --| CCCQ_VER:
215-14 --|
215-15 --| END PROLOGUE
215-16 ----------------------------------------------------------------------------
215-17 */
215-18
215-19 #include D;
215-20 #include A;
215-21 #define B;
215-22 #include D;
215-23
215-24
215-25
215-26 /*
215-27 -----------------------------------------------------------------------------
215-28 --| NAME: wxp.12.1
215-29 --|
215-30 --| ABSTRACT:
215-31 --| This function does wxp stuff.
215-32 --|
215-33 --| RETURNS:
215-34 --| NONE.
215-35 --|
215-36 ----------------------------------------------------------------------------
215-37 */
215-38 static void wxp.12.1(void)
215-39 {
215-40 A = B-C;
215-41 A = B*C;
215-42 A = B-C;
215-43 A = B/C;
215-44 A = B-C;
215-45 A = B+C;
215-46 A = B*C;
215-47
215-48 if (A ne B)
215-49 {
215-50 A = B + C;
215-51 D = E + F;
215-52 }
215-53
215-54 A = B/C;
215-55 A = B/C;
215-56 A = B+C;
215-57 A = B*C;
215-58
215-59 if (A < = B)
215-60 {
215-61 A = B + C;
215-62 D = E + F;
215-63 }
215-64
215-65 A = B*C;
215-66 A = B-C;
215-67 A = B*C;
215-68 A = B/C;
215-69 A = B-C;
215-70 A = B+C;
215-71
215-72 if (A > B)
215-73 {
215-74 A = B + C;
215-75 D = E + F;
215-76 }
215-77
215-78 A = B-C;
215-79
215-80 if (A < B)
215-81 {
215-82 A = B + C;
215-83 D = E + F;
215-84 }
215-85
215-86 A = B*C;
215-87 /* LE SV TOC-3872 this a wxp-12.1.24 req */
215-88 A = B-C;
215-89 A = B+C;
215-90 A = B-C;
215-91 A = B-C;
215-92 A = B*C;
215-93 // max LOC 28
215-94
215-95 }
215-96
215-97
215-98 /*
215-99 -----------------------------------------------------------------------------
215-100 --| NAME: wxp.12.2
215-101 --|
215-102 --| ABSTRACT:
215-103 --| This function does wxp stuff.
215-104 --|
215-105 --| RETURNS:
215-106 --| NONE.
215-107 --|
215-108 ----------------------------------------------------------------------------
215-109 */
215-110 static void wxp.12.2(void)
215-111 {
215-112 A = B-C;
215-113 A = B-C;
215-114 A = B-C;
215-115 A = B*C;
215-116 A = B+C;
215-117 A = B*C;
215-118 A = B/C;
215-119 A = B*C;
215-120 A = B-C;
215-121 A = B-C;
215-122 A = B+C;
215-123 A = B/C;
215-124
215-125 if (A < B)
215-126 {
215-127 A = B + C;
215-128 D = E + F;
215-129 }
215-130
215-131 A = B-C;
215-132 // max LOC 14
215-133
215-134 }
215-135
215 215 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-12.c
216 216 Source: source/ft-app/ft-app-B1.0/wxp/wxp-13.c
216-0 /*
216-1 ----------------------------------------------------------------------------
216-2 --| BEGIN PROLOGUE
216-3 --|
216-4 --| CLASSIFICATION: UNCLASSIFIED
216-5 --|
216-6 --| FILE NAME: wxp-13.c
216-7 --|
216-8 --| ABSTRACT:
216-9 --| This file contains the 4 functions that do file wxp stuff.
216-10 --|
216-11 --| HISTORY:
216-12 --| CCCQ_NAME:
216-13 --| CCCQ_VER:
216-14 --|
216-15 --| END PROLOGUE
216-16 ----------------------------------------------------------------------------
216-17 */
216-18
216-19 #define A;
216-20 int A;
216-21 #define D;
216-22 #include C;
216-23
216-24
216-25
216-26 /*
216-27 -----------------------------------------------------------------------------
216-28 --| NAME: wxp.13.1
216-29 --|
216-30 --| ABSTRACT:
216-31 --| This function does wxp stuff.
216-32 --|
216-33 --| RETURNS:
216-34 --| NONE.
216-35 --|
216-36 ----------------------------------------------------------------------------
216-37 */
216-38 static void wxp.13.1(void)
216-39 {
216-40 A = B-C;
216-41 /* LE SV TOC-3873 this a wxp-13.1.2 req */
216-42 A = B+C;
216-43
216-44 if (A gt B)
216-45 {
216-46 A = B + C;
216-47 D = E + F;
216-48 }
216-49
216-50 A = B*C;
216-51
216-52 switch (wxp stuff)
216-53 {
216-54 case one:
216-55 {
216-56 run_this;
216-57 break;
216-58 }
216-59 case two:
216-60 {
216-61 run_this;
216-62 break;
216-63 }
216-64 default:
216-65 {
216-66 SwError;
216-67 }
216-68 }
216-69
216-70 A = B+C;
216-71 A = B-C;
216-72 A = B*C;
216-73
216-74 if (A > B)
216-75 {
216-76 A = B + C;
216-77 D = E + F;
216-78 }
216-79
216-80 A = B*C;
216-81 A = B/C;
216-82
216-83 if (A > = B)
216-84 {
216-85 A = B + C;
216-86 D = E + F;
216-87 }
216-88
216-89 A = B+C;
216-90 A = B*C;
216-91 A = B/C;
216-92 A = B+C;
216-93 A = B*C;
216-94 A = B/C;
216-95 A = B+C;
216-96 A = B+C;
216-97 A = B-C;
216-98 A = B+C;
216-99 /* LE SV TOC-3874 this a wxp-13.1.23 req */
216-100
216-101 if (A > = B)
216-102 {
216-103 A = B + C;
216-104 D = E + F;
216-105 }
216-106
216-107
216-108 if (A == B)
216-109 {
216-110 A = B + C;
216-111 D = E + F;
216-112 }
216-113
216-114 A = B-C;
216-115 /* LE SV TOC-3875 this a wxp-13.1.26 req */
216-116 A = B/C;
216-117 A = B*C;
216-118 A = B/C;
216-119 A = B+C;
216-120 // max LOC 29
216-121
216-122 }
216-123
216-124
216-125 /*
216-126 -----------------------------------------------------------------------------
216-127 --| NAME: wxp.13.2
216-128 --|
216-129 --| ABSTRACT:
216-130 --| This function does wxp stuff.
216-131 --|
216-132 --| RETURNS:
216-133 --| NONE.
216-134 --|
216-135 ----------------------------------------------------------------------------
216-136 */
216-137 static void wxp.13.2(void)
216-138 {
216-139
216-140 if (A le B)
216-141 {
216-142 A = B + C;
216-143 D = E + F;
216-144 }
216-145
216-146 A = B+C;
216-147 A = B*C;
216-148 /* LE SV TOC-3876 this a wxp-13.2.4 req */
216-149 A = B+C;
216-150 A = B-C;
216-151 A = B*C;
216-152 A = B-C;
216-153 A = B-C;
216-154
216-155 if (A ge B)
216-156 {
216-157 A = B + C;
216-158 D = E + F;
216-159 }
216-160
216-161 A = B+C;
216-162 A = B*C;
216-163
216-164 if (A ge B)
216-165 {
216-166 A = B + C;
216-167 D = E + F;
216-168 }
216-169
216-170 A = B*C;
216-171 A = B/C;
216-172 A = B-C;
216-173 A = (long)B + C;
216-174 A = B-C;
216-175 A = B+C;
216-176 A = B*C;
216-177 A = B-C;
216-178 A = B-C;
216-179
216-180 if (A < = B)
216-181 {
216-182 A = B + C;
216-183 D = E + F;
216-184 }
216-185
216-186 /* LE SV TOC-3877 this a wxp-13.2.22 req */
216-187 A = B+C;
216-188 /* LE SV TOC-3878 this a wxp-13.2.23 req */
216-189
216-190 if (A == B)
216-191 {
216-192 A = B + C;
216-193 D = E + F;
216-194 }
216-195
216-196 A = B/C;
216-197 A = B+C;
216-198 A = B+C;
216-199
216-200 if (A gt B)
216-201 {
216-202 A = B + C;
216-203 D = E + F;
216-204 }
216-205
216-206 A = B*C;
216-207 A = B/C;
216-208
216-209 if (A le B)
216-210 {
216-211 A = B + C;
216-212 D = E + F;
216-213 }
216-214
216-215 FreePtr = HmiStringPtr;
216-216 A = B+C;
216-217 A = B-C;
216-218 A = B/C;
216-219 A = B-C;
216-220 A = B+C;
216-221 A = B-C;
216-222 A = B*C;
216-223 A = B-C;
216-224 A = B/C;
216-225 A = B*C;
216-226 A = B+C;
216-227 A = B+C;
216-228
216-229 if (A < = B)
216-230 {
216-231 A = B + C;
216-232 D = E + F;
216-233 }
216-234
216-235 A = B+C;
216-236 A = B/C;
216-237 A = B*C;
216-238 A = B*C;
216-239 A = B*C;
216-240 // max LOC 48
216-241
216-242 }
216-243
216-244
216-245 /*
216-246 -----------------------------------------------------------------------------
216-247 --| NAME: wxp.13.3
216-248 --|
216-249 --| ABSTRACT:
216-250 --| This function does wxp stuff.
216-251 --|
216-252 --| RETURNS:
216-253 --| NONE.
216-254 --|
216-255 ----------------------------------------------------------------------------
216-256 */
216-257 static void wxp.13.3(void)
216-258 {
216-259 A = 0x0002;
216-260 A = B-C;
216-261 A = B/C;
216-262 A = B-C;
216-263
216-264 if (A ge B)
216-265 {
216-266 A = B + C;
216-267 D = E + F;
216-268 }
216-269
216-270 A = B+C;
216-271 A = B/C;
216-272 A = B-C;
216-273 A = B*C;
216-274
216-275 if (A < B)
216-276 {
216-277 A = B + C;
216-278 D = E + F;
216-279 }
216-280
216-281 A = B+C;
216-282 A = B+C;
216-283 A = B/C;
216-284 A = B/C;
216-285
216-286 switch (wxp stuff)
216-287 {
216-288 case one:
216-289 {
216-290 run_this;
216-291 break;
216-292 }
216-293 case two:
216-294 {
216-295 run_this;
216-296 break;
216-297 }
216-298 default:
216-299 {
216-300 SwError;
216-301 }
216-302 }
216-303
216-304 rcv_buffer = (U16 *) alloc(size+1);
216-305 A = B-C;
216-306
216-307 if (A > = B)
216-308 {
216-309 A = B + C;
216-310 D = E + F;
216-311 }
216-312
216-313 A = B-C;
216-314 A = B*C;
216-315
216-316 if (A gt B)
216-317 {
216-318 A = B + C;
216-319 D = E + F;
216-320 }
216-321
216-322
216-323 switch (wxp stuff)
216-324 {
216-325 case one:
216-326 {
216-327 run_this;
216-328 break;
216-329 }
216-330 case two:
216-331 {
216-332 run_this;
216-333 break;
216-334 }
216-335 default:
216-336 {
216-337 SwError;
216-338 }
216-339 }
216-340
216-341 A = B*C;
216-342
216-343 if (A < = B)
216-344 {
216-345 A = B + C;
216-346 D = E + F;
216-347 }
216-348
216-349
216-350 if (A ge B)
216-351 {
216-352 A = B + C;
216-353 D = E + F;
216-354 }
216-355
216-356 A = B+C;
216-357
216-358 if (A lt B)
216-359 {
216-360 A = B + C;
216-361 D = E + F;
216-362 }
216-363
216-364 A = B/C;
216-365 A = B*C;
216-366 rcv_buffer = (U16 *) alloc(size+1);
216-367 A = B+C;
216-368 /* LE SV TOC-3879 this a wxp-13.3.29 req */
216-369 A = B-C;
216-370 A = B*C;
216-371 A = B/C;
216-372
216-373 if (A > B)
216-374 {
216-375 A = B + C;
216-376 D = E + F;
216-377 }
216-378
216-379
216-380 if (A < = B)
216-381 {
216-382 A = B + C;
216-383 D = E + F;
216-384 }
216-385
216-386 A = B+C;
216-387 A = B+C;
216-388
216-389 if (A eq B)
216-390 {
216-391 A = B + C;
216-392 D = E + F;
216-393 }
216-394
216-395 A = B/C;
216-396
216-397 if (A ne B)
216-398 {
216-399 A = B + C;
216-400 D = E + F;
216-401 }
216-402
216-403 A = B-C;
216-404 A = B*C;
216-405 A = B/C;
216-406 A = B/C;
216-407
216-408 if (A gt B)
216-409 {
216-410 A = B + C;
216-411 D = E + F;
216-412 }
216-413
216-414 A = B-C;
216-415 A = B-C;
216-416 A = B-C;
216-417 A = B+C;
216-418 A = B*C;
216-419
216-420 if (A ge B)
216-421 {
216-422 A = B + C;
216-423 D = E + F;
216-424 }
216-425
216-426 A = B/C;
216-427 A = B-C;
216-428 A = B*C;
216-429 A = B*C;
216-430 // max LOC 53
216-431
216-432 }
216-433
216-434
216-435 /*
216-436 -----------------------------------------------------------------------------
216-437 --| NAME: wxp.13.4
216-438 --|
216-439 --| ABSTRACT:
216-440 --| This function does wxp stuff.
216-441 --|
216-442 --| RETURNS:
216-443 --| NONE.
216-444 --|
216-445 ----------------------------------------------------------------------------
216-446 */
216-447 static void wxp.13.4(void)
216-448 {
216-449 A = B*C;
216-450 A = B/C;
216-451 A = B+C;
216-452 A = B+C;
216-453
216-454 switch (wxp stuff)
216-455 {
216-456 case one:
216-457 {
216-458 run_this;
216-459 // missing break
216-460 }
216-461 case two:
216-462 {
216-463 run_this;
216-464 break;
216-465 }
216-466 default:
216-467 {
216-468 SwError;
216-469 }
216-470 }
216-471
216-472 A = B+C;
216-473 A = B*C;
216-474 A = B*C;
216-475 A = B/C;
216-476 A = B/C;
216-477 A = B/C;
216-478 A = B*C;
216-479 A = B-C;
216-480 A = B*C;
216-481 A = B+C;
216-482 // max LOC 14
216-483
216-484 }
216-485
216 216 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-13.c
217 217 Source: source/ft-app/ft-app-B1.0/wxp/wxp-14.c
217-0 /*
217-1 ----------------------------------------------------------------------------
217-2 --| BEGIN PROLOGUE
217-3 --|
217-4 --| CLASSIFICATION: UNCLASSIFIED
217-5 --|
217-6 --| FILE NAME: wxp-14.c
217-7 --|
217-8 --| ABSTRACT:
217-9 --| This file contains the 4 functions that do file wxp stuff.
217-10 --|
217-11 --| HISTORY:
217-12 --| CCCQ_NAME:
217-13 --| CCCQ_VER:
217-14 --|
217-15 --| END PROLOGUE
217-16 ----------------------------------------------------------------------------
217-17 */
217-18
217-19 float B;
217-20 float B;
217-21 char D;
217-22 #include A;
217-23 #define A;
217-24 #define A;
217-25
217-26
217-27
217-28 /*
217-29 -----------------------------------------------------------------------------
217-30 --| NAME: wxp.14.1
217-31 --|
217-32 --| ABSTRACT:
217-33 --| This function does wxp stuff.
217-34 --|
217-35 --| RETURNS:
217-36 --| NONE.
217-37 --|
217-38 ----------------------------------------------------------------------------
217-39 */
217-40 static void wxp.14.1(void)
217-41 {
217-42 A = B/C;
217-43 A = B-C;
217-44 send_buffer = (U16 *) malloc(size+1);
217-45 A = B-C;
217-46 A = B/C;
217-47 A = B/C;
217-48 A = B/C;
217-49 A = B/C;
217-50
217-51 if (A > = B)
217-52 {
217-53 A = B + C;
217-54 D = E + F;
217-55 }
217-56
217-57 A = B-C;
217-58 A = B*C;
217-59
217-60 if (A lt B)
217-61 {
217-62 A = B + C;
217-63 D = E + F;
217-64 }
217-65
217-66 A = B*C;
217-67 A = B-C;
217-68 A = B+C;
217-69 A = B*C;
217-70 A = B+C;
217-71 A = B*C;
217-72 A = B+C;
217-73 A = B-C;
217-74 A = B/C;
217-75
217-76 if (A != B)
217-77 {
217-78 A = B + C;
217-79 D = E + F;
217-80 }
217-81
217-82 A = B+C;
217-83
217-84 if (A le B)
217-85 {
217-86 A = B + C;
217-87 D = E + F;
217-88 }
217-89
217-90 A = B*C;
217-91 A = B-C;
217-92 /* LE SV TOC-3880 this a wxp-14.1.26 req */
217-93 A = B-C;
217-94 A = B/C;
217-95
217-96 switch (wxp stuff)
217-97 {
217-98 case one:
217-99 {
217-100 run_this;
217-101 break;
217-102 }
217-103 case two:
217-104 {
217-105 run_this;
217-106 break;
217-107 }
217-108 default:
217-109 {
217-110 SwError;
217-111 }
217-112 }
217-113
217-114 A = B-C;
217-115 /* LE SV TOC-3881 this a wxp-14.1.30 req */
217-116
217-117 if (A eq B)
217-118 {
217-119 A = B + C;
217-120 D = E + F;
217-121 }
217-122
217-123
217-124 if (A > = B)
217-125 {
217-126 A = B + C;
217-127 D = E + F;
217-128 }
217-129
217-130 A = B*C;
217-131 A = B*C;
217-132 A = B+C;
217-133 A = B*C;
217-134 A = B-C;
217-135 A = B-C;
217-136 A = B*C;
217-137 rcv_buffer = (U16 *) alloc(size+1);
217-138 A = B+C;
217-139
217-140 if (A > = B)
217-141 {
217-142 A = B + C;
217-143 D = E + F;
217-144 }
217-145
217-146 A = 0x0001;
217-147 A = B/C;
217-148
217-149 if (A gt B)
217-150 {
217-151 A = B + C;
217-152 D = E + F;
217-153 }
217-154
217-155 A = B-C;
217-156 A = B-C;
217-157 A = B+C;
217-158 A = B+C;
217-159
217-160 if (A gt B)
217-161 {
217-162 A = B + C;
217-163 D = E + F;
217-164 }
217-165
217-166 A = B*C;
217-167 A = B-C;
217-168 A = B+C;
217-169 A = B+C;
217-170 A = B*C;
217-171 A = B-C;
217-172 A = B*C;
217-173 FreePtr = HmiStringPtr;
217-174 A = B-C;
217-175 A = B*C;
217-176
217-177 if (A eq B)
217-178 {
217-179 A = B + C;
217-180 D = E + F;
217-181 }
217-182
217-183
217-184 if (A < B)
217-185 {
217-186 A = B + C;
217-187 D = E + F;
217-188 }
217-189
217-190 A = B/C;
217-191 // max LOC 59
217-192
217-193 }
217-194
217-195
217-196 /*
217-197 -----------------------------------------------------------------------------
217-198 --| NAME: wxp.14.2
217-199 --|
217-200 --| ABSTRACT:
217-201 --| This function does wxp stuff.
217-202 --|
217-203 --| RETURNS:
217-204 --| NONE.
217-205 --|
217-206 ----------------------------------------------------------------------------
217-207 */
217-208 static void wxp.14.2(void)
217-209 {
217-210 A = B*C;
217-211 A = B*C;
217-212 A = B*C;
217-213
217-214 if (A ge B)
217-215 {
217-216 A = B + C;
217-217 D = E + F;
217-218 }
217-219
217-220 A = B-C;
217-221 A = B+C;
217-222
217-223 if (A < = B)
217-224 {
217-225 A = B + C;
217-226 D = E + F;
217-227 }
217-228
217-229 A = B-C;
217-230 A = B-C;
217-231 A = B*C;
217-232 A = B/C;
217-233
217-234 if (A eq B)
217-235 {
217-236 A = B + C;
217-237 D = E + F;
217-238 }
217-239
217-240 A = B*C;
217-241 A = B+C;
217-242
217-243 if (A > = B)
217-244 {
217-245 A = B + C;
217-246 D = E + F;
217-247 }
217-248
217-249
217-250 if (A == B)
217-251 {
217-252 A = B + C;
217-253 D = E + F;
217-254 }
217-255
217-256
217-257 if (A < = B)
217-258 {
217-259 A = B + C;
217-260 D = E + F;
217-261 }
217-262
217-263 A = B/C;
217-264 // max LOC 18
217-265
217-266 }
217-267
217-268
217-269 /*
217-270 -----------------------------------------------------------------------------
217-271 --| NAME: wxp.14.3
217-272 --|
217-273 --| ABSTRACT:
217-274 --| This function does wxp stuff.
217-275 --|
217-276 --| RETURNS:
217-277 --| NONE.
217-278 --|
217-279 ----------------------------------------------------------------------------
217-280 */
217-281 static void wxp.14.3(void)
217-282 {
217-283 A = B/C;
217-284
217-285 if (A != B)
217-286 {
217-287 A = B + C;
217-288 D = E + F;
217-289 }
217-290
217-291
217-292 if (A < B)
217-293 {
217-294 A = B + C;
217-295 D = E + F;
217-296 }
217-297
217-298 /* LE SV TOC-3882 this a wxp-14.3.4 req */
217-299 A = B+C;
217-300 FreePtr = HmiStringPtr;
217-301 A = B-C;
217-302 A = B+C;
217-303 A = B-C;
217-304 A = B-C;
217-305 A = B/C;
217-306
217-307 if (A ge B)
217-308 {
217-309 A = B + C;
217-310 D = E + F;
217-311 }
217-312
217-313 A = B*C;
217-314 A = B-C;
217-315 A = B/C;
217-316 A = B/C;
217-317 A = B*C;
217-318 A = B-C;
217-319 A = B/C;
217-320
217-321 if (A > = B)
217-322 {
217-323 A = B + C;
217-324 D = E + F;
217-325 }
217-326
217-327 A = B/C;
217-328 A = B/C;
217-329 A = B*C;
217-330 A = B+C;
217-331 A = B/C;
217-332 A = B*C;
217-333 A = B*C;
217-334 // TBS - I need to figure this out
217-335 A = B/C;
217-336
217-337 if (A < = B)
217-338 {
217-339 A = B + C;
217-340 D = E + F;
217-341 }
217-342
217-343 A = B-C;
217-344 A = B*C;
217-345
217-346 if (A != B)
217-347 {
217-348 A = B + C;
217-349 D = E + F;
217-350 }
217-351
217-352 A = B*C;
217-353 A = B-C;
217-354 A = B/C;
217-355 A = B*C;
217-356 A = B*C;
217-357
217-358 if (A le B)
217-359 {
217-360 A = B + C;
217-361 D = E + F;
217-362 }
217-363
217-364 A = B-C;
217-365 A = B-C;
217-366
217-367 if (A == B)
217-368 {
217-369 A = B + C;
217-370 D = E + F;
217-371 }
217-372
217-373 A = B+C;
217-374 A = B*C;
217-375
217-376 if (A ge B)
217-377 {
217-378 A = B + C;
217-379 D = E + F;
217-380 }
217-381
217-382 A = B-C;
217-383 A = B/C;
217-384 A = B-C;
217-385 A = B-C;
217-386 A = B*C;
217-387 A = B-C;
217-388 A = B-C;
217-389 A = B*C;
217-390 A = B*C;
217-391 A = B-C;
217-392 /* LE SV TOC-3883 this a wxp-14.3.53 req */
217-393 A = B/C;
217-394
217-395 if (A > = B)
217-396 {
217-397 A = B + C;
217-398 D = E + F;
217-399 }
217-400
217-401
217-402 if (A eq B)
217-403 {
217-404 A = B + C;
217-405 D = E + F;
217-406 }
217-407
217-408 /* LE SV TOC-3884 this a wxp-14.3.56 req */
217-409 A = B+C;
217-410 // max LOC 56
217-411
217-412 }
217-413
217-414
217-415 /*
217-416 -----------------------------------------------------------------------------
217-417 --| NAME: wxp.14.4
217-418 --|
217-419 --| ABSTRACT:
217-420 --| This function does wxp stuff.
217-421 --|
217-422 --| RETURNS:
217-423 --| NONE.
217-424 --|
217-425 ----------------------------------------------------------------------------
217-426 */
217-427 static void wxp.14.4(void)
217-428 {
217-429
217-430 switch (wxp stuff)
217-431 {
217-432 case one:
217-433 {
217-434 run_this;
217-435 break;
217-436 }
217-437 case two:
217-438 {
217-439 run_this;
217-440 break;
217-441 }
217-442 default:
217-443 {
217-444 // missing error call
217-445 }
217-446 }
217-447
217-448 A = B-C;
217-449 A = B*C;
217-450 A = B/C;
217-451
217-452 if (A > B)
217-453 {
217-454 A = B + C;
217-455 D = E + F;
217-456 }
217-457
217-458 // (P) this is really improtant
217-459 A = B+C;
217-460 A = B+C;
217-461 A = B/C;
217-462 A = B/C;
217-463 A = B/C;
217-464 A = B/C;
217-465 A = B+C;
217-466
217-467 if (A > B)
217-468 {
217-469 A = B + C;
217-470 D = E + F;
217-471 }
217-472
217-473 A = B+C;
217-474
217-475 if (A ge B)
217-476 {
217-477 A = B + C;
217-478 D = E + F;
217-479 }
217-480
217-481
217-482 if (A > B)
217-483 {
217-484 A = B + C;
217-485 D = E + F;
217-486 }
217-487
217-488 A = B+C;
217-489 A = B/C;
217-490 A = B-C;
217-491 A = B/C;
217-492 // max LOC 19
217-493
217-494 }
217-495
217 217 Result: result/source/ft-app/ft-app-B1.0/wxp/wxp-14.c
done
11/17/2003 17:56:03 start
11/17/2003 17:57:41 end