IBM390lib.c

filter: Statementstmt 70.6% 113 / 160 Branchbran 58.3% 49 / 84 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 66.3% 162 / 244 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« blib/lib/Convert/IBM390/CP01149.pm ↑ Summary IBM390.xs »
1 #define USE_OPTS 1
2  
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <time.h>
6 #if USE_OPTS
7 #include <limits.h>
8 #include <string.h>
9 #endif /* USE_OPTS */
10 #include "IBM390lib.h"
11 /*-------------------------------------------------------------------
12 Module: Convert::IBM390
13 The C functions defined here are faster than straight Perl code.
14 -------------------------------------------------------------------*/
15  
16  
17 /* Powers of 10 */
18 static const double pows_of_10[32] = { 1.0, 10.0, 100.0, 1000.0,
19 10000.0, 100000.0, 1000000.0, 10000000.0,
20 1.0E8, 1.0E9, 1.0E10, 1.0E11, 1.0E12, 1.0E13, 1.0E14, 1.0E15,
21 1.0E16, 1.0E17, 1.0E18, 1.0E19, 1.0E20, 1.0E21, 1.0E22, 1.0E23,
22 1.0E24, 1.0E25, 1.0E26, 1.0E27, 1.0E28, 1.0E29, 1.0E30, 1.0E31 };
23  
24 /* Numeric values of packed digits (e.g. x'23' (decimal 23) = 0x17) */
25 unsigned char packed_digits[256] = {
26 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff,
27 0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0xff,0xff,0xff,0xff,0xff,0xff,
28 0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0xff,0xff,0xff,0xff,0xff,0xff,
29 0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0xff,0xff,0xff,0xff,0xff,0xff,
30 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0xff,0xff,0xff,0xff,0xff,0xff,
31 0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0xff,0xff,0xff,0xff,0xff,0xff,
32 0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0xff,0xff,0xff,0xff,0xff,0xff,
33 0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0xff,0xff,0xff,0xff,0xff,0xff,
34 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0xff,0xff,0xff,0xff,0xff,0xff,
35 0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0x61,0x62,0x63,0xff,0xff,0xff,0xff,0xff,0xff,
36 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
37 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
38 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
39 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
40 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
41 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
42 };
43  
44 /* Numeric values for last packed byte (digit + sign) */
45 unsigned char packed_lastbyte[256] = {
46 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,
47 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x01,0x01,0x01,0x01,0x01,0x01,
48 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x02,0x02,0x02,0x02,0x02,0x02,
49 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x03,0x03,0x03,0x03,0x03,0x03,
50 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x04,0x04,0x04,0x04,0x04,0x04,
51 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x05,0x05,0x05,0x05,0x05,0x05,
52 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x06,0x06,0x06,0x06,0x06,0x06,
53 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0x07,0x07,0x07,0x07,0x07,
54 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x08,0x08,0x08,0x08,0x08,0x08,
55 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x09,0x09,0x09,0x09,0x09,0x09,
56 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
57 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
58 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
59 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
60 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
61 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
62 };
63  
64 /*---------- Packed decimal to Perl number ----------*/
65 4 double CF_packed2num
66 ( const char * packed,
67 int plength,
68 int ndec )
69 {
70 double out_num;
71 short i;
72 char * packed_ptr;
73 unsigned char pdigits, zonepart, numpart, signum;
74 unsigned char val;
75 unsigned long long out_long;
76 4 out_long = 0;
77  
78 #ifdef DEBUG390
79 fprintf(stderr, "*D* CF_packed2num: beginning\n");
80 #endif
81 4 out_num = 0.0;
82 4 packed_ptr = packed;
83 4 ▶ if (plength <= 9) {
Branch: 1 branch
BranchTrueFalseTotal
if (plength <= 9) { 4 0 4
84 8 ▶ for (i = 0; i < plength-1; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < plength-1; i++) { 5 3 8
85 5 val = packed_digits[(unsigned char) *packed_ptr];
86 5 ▶ if (val == 255)
Branch: 1 branch
BranchTrueFalseTotal
if (val == 255) 1 4 5
87 1 { return INVALID_390NUM; }
88 4 out_long = (out_long * 100) + val;
89 4 packed_ptr++;
90 }
91 3 ▶ if (i < plength) {
Branch: 1 branch
BranchTrueFalseTotal
if (i < plength) { 3 0 3
92 3 pdigits = (unsigned char) *packed_ptr;
93 3 val = packed_lastbyte[pdigits];
94 3 ▶ if (val == 255)
Branch: 1 branch
BranchTrueFalseTotal
if (val == 255) 0 3 3
95 0 { return INVALID_390NUM; }
96 3 out_long = (out_long * 10) + val;
97 3 signum = pdigits & 0x0F;
98 }
99 3 out_num = out_long;
100 } else {
101 0 ▶ for (i = 0; i < plength-1; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < plength-1; i++) { 0 0 0
102 0 val = packed_digits[(unsigned char) *packed_ptr];
103 0 ▶ if (val == 255)
Branch: 1 branch
BranchTrueFalseTotal
if (val == 255) 0 0 0
104 0 { return INVALID_390NUM; }
105 0 out_num = (out_num * 100) + val;
106 0 packed_ptr++;
107 }
108 0 ▶ if (i < plength) {
Branch: 1 branch
BranchTrueFalseTotal
if (i < plength) { 0 0 0
109 0 pdigits = (unsigned char) *packed_ptr;
110 0 val = packed_lastbyte[pdigits];
111 0 ▶ if (val == 255)
Branch: 1 branch
BranchTrueFalseTotal
if (val == 255) 0 0 0
112 0 { return INVALID_390NUM; }
113 0 out_num = (out_num * 10) + val;
114 0 signum = pdigits & 0x0F;
115 }
116 }
117 3 ▶ if (signum == 0x0D || signum == 0x0B) {
Branch: 2 branches
BranchTrueFalseTotal
if (signum == 0x0D || signum == 0x0B) { 2 1 3
if (signum == 0x0D || signum == 0x0B) { 0 2 2
118 1 out_num = -out_num;
119 }
120  
121 /* If ndec is 0, we're finished; if it's nonzero,
122 correct the number of decimal places. */
123 3 ▶ if ( ndec != 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ( ndec != 0 ) { 1 2 3
124 1 out_num = out_num / pows_of_10[ndec];
125 }
126  
127 #ifdef DEBUG390
128 fprintf(stderr, "*D* CF_packed2num: returning %f\n", out_num);
129 #endif
130 3 return out_num;
131 }
132  
133 #if USE_OPTS
134 void
135 0 fmt_num(char *buf, int sz, int len, unsigned long long val)
136 {
137 0 char *ptr = buf + len;
138 unsigned long long x;
139 0 *ptr-- = 0x00;
140 0 ▶ while (val > 0) {
Branch: 1 branch
BranchTrueFalseTotal
while (val > 0) { 0 0 0
141 0 x = val / 10;
142 0 *ptr-- = val - x * 10 + 0x30;
143 0 val = x;
144 }
145 0 memset(buf, 0x30, ptr-buf+1);
146 0 }
147 #endif /* USE_OPTS */
148  
149 unsigned char to_packed[100] = {
150 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
151 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
152 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
153 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
154 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
155 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
156 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
157 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
158 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
159 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99
160 };
161
162  
163 /*---------- Perl number to packed decimal ----------*/
164 6 int CF_num2packed
165 ( char *packed_ptr,
166 double perlnum,
167 int outbytes,
168 int ndec,
169 int fsign )
170 {
171 int outdigits, i;
172 double perl_absval;
173 long long int ll_absval;
174 char digits[36];
175 char *digit_ptr, *out_ptr;
176 char signum;
177  
178 #ifdef DEBUG390
179 fprintf(stderr, "*D* CF_num2packed: beginning\n");
180 #endif
181 6 ▶ if (perlnum >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (perlnum >= 0) { 5 1 6
182 5 ▶ perl_absval = perlnum; signum = (fsign) ? 0x0F : 0x0C;
Branch: 1 branch
BranchTrueFalseTotal
perl_absval = perlnum; signum = (fsign) ? 0x0F : 0x0C; 1 4 5
183 } else {
184 1 perl_absval = 0 - perlnum; signum = 0x0D;
185 }
186 6 ▶ if (ndec > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (ndec > 0) { 2 4 6
187 2 perl_absval *= pows_of_10[ndec];
188 }
189 /* Check for an excessively high value. */
190 6 ▶ if (perl_absval >= 1.0E31) {
Branch: 1 branch
BranchTrueFalseTotal
if (perl_absval >= 1.0E31) { 1 5 6
191 1 return 0;
192 }
193  
194 /* If the number is less than LLONG_MAX, we can use integer functions.
195 Otherwise, we convert to a printed string and then pack it. */
196 5 ▶ if (perl_absval < LLONG_MAX) {
Branch: 1 branch
BranchTrueFalseTotal
if (perl_absval < LLONG_MAX) { 5 0 5
197 5 ll_absval = (long long) (perl_absval + 0.5000001);
198 5 out_ptr = packed_ptr + outbytes - 1;
199 /* Last digit + sign */
200 5 outdigits = ll_absval % 10;
201 5 *out_ptr-- = ((unsigned char)(outdigits << 4)) | signum;
202 5 ll_absval = ll_absval / 10; /* no remainder */
203 /* Remaining digits */
204 18 ▶ for (i = 0; i < outbytes - 1; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < outbytes - 1; i++) { 13 5 18
205 13 outdigits = ll_absval % 100;
206 13 *out_ptr = to_packed[outdigits];
207 13 ll_absval = ll_absval / 100; /* no remainder */
208 13 out_ptr--;
209 }
210 } else {
211 /* sprintf will round to an "integral" value. */
212 0 sprintf(digits, "%031.0f", perl_absval);
213 0 outdigits = outbytes * 2 - 1;
214 0 digit_ptr = digits;
215 0 out_ptr = packed_ptr;
216 0 ▶ for (i = 31 - outdigits; i < 31; i += 2) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 31 - outdigits; i < 31; i += 2) { 0 0 0
217 0 ▶ if (i < 30) {
Branch: 1 branch
BranchTrueFalseTotal
if (i < 30) { 0 0 0
218 0 (*out_ptr) = ((*(digit_ptr + i)) << 4) |
219 0 ((*(digit_ptr + i + 1)) & 0x0F) ;
220 } else {
221 0 (*out_ptr) = ((*(digit_ptr + i)) << 4) | signum;
222 }
223 0 out_ptr++;
224 }
225 }
226  
227 #ifdef DEBUG390
228 fprintf(stderr, "*D* CF_num2packed: returning\n");
229 #endif
230 5 return 1;
231 }
232  
233  
234 /*---------- Zoned decimal to Perl number ----------*/
235 1 double CF_zoned2num
236 ( const char * zoned,
237 int plength,
238 int ndec )
239 {
240 double out_num;
241 short i;
242 unsigned char zdigit, signum;
243  
244 #ifdef DEBUG390
245 fprintf(stderr, "*D* CF_zoned2num: beginning\n");
246 #endif
247 1 out_num = 0.0;
248 4 ▶ for (i = 0; i < plength - 1; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < plength - 1; i++) { 3 1 4
249 3 zdigit = (unsigned char) *(zoned + i);
250 3 ▶ if (zdigit < 0xF0 || zdigit > 0xF9)
Branch: 2 branches
BranchTrueFalseTotal
if (zdigit < 0xF0 || zdigit > 0xF9) 3 0 3
if (zdigit < 0xF0 || zdigit > 0xF9) 0 3 3
251 0 { return INVALID_390NUM; }
252 3 out_num = (out_num * 10) + (zdigit - 240); /* i.e. 0xF0 */
253 }
254 /* Last digit (may have a zone overpunch) */
255 1 zdigit = (unsigned char) *(zoned + i);
256 1 ▶ if ((zdigit & 0xF0) < 0xA0 || (zdigit & 0x0F) > 0x09)
Branch: 2 branches
BranchTrueFalseTotal
if ((zdigit & 0xF0) < 0xA0 || (zdigit & 0x0F) > 0x09) 1 0 1
if ((zdigit & 0xF0) < 0xA0 || (zdigit & 0x0F) > 0x09) 0 1 1
257 0 { return INVALID_390NUM; }
258 1 out_num = (out_num * 10) + (zdigit & 0x0F);
259 1 signum = zdigit & 0xF0;
260  
261 1 ▶ if (signum == 0xD0 || signum == 0xB0) {
Branch: 2 branches
BranchTrueFalseTotal
if (signum == 0xD0 || signum == 0xB0) { 0 1 1
if (signum == 0xD0 || signum == 0xB0) { 0 0 0
262 1 out_num = -out_num;
263 }
264  
265 /* If ndec is 0, we're finished; if it's nonzero,
266 correct the number of decimal places. */
267 1 ▶ if ( ndec != 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ( ndec != 0 ) { 0 1 1
268 0 out_num = out_num / pows_of_10[ndec];
269 }
270  
271 #ifdef DEBUG390
272 fprintf(stderr, "*D* CF_zoned2num: returning %f\n", out_num);
273 #endif
274 1 return out_num;
275 }
276  
277 unsigned char to_zoned[10] =
278 {0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9 };
279  
280 /*---------- Perl number to zoned decimal ----------*/
281 4 int CF_num2zoned
282 ( char *zoned_ptr,
283 double perlnum,
284 int outbytes,
285 int ndec,
286 int fsign )
287 {
288 int outdigits, i;
289 double perl_absval;
290 long long int ll_absval;
291 char digits[36];
292 char *digit_ptr, *out_ptr;
293 unsigned char signum;
294  
295 #ifdef DEBUG390
296 fprintf(stderr, "*D* CF_num2zoned: beginning\n");
297 #endif
298 4 ▶ if (perlnum >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (perlnum >= 0) { 2 2 4
299 2 ▶ perl_absval = perlnum; signum = (fsign) ? 0xF0 : 0xC0;
Branch: 1 branch
BranchTrueFalseTotal
perl_absval = perlnum; signum = (fsign) ? 0xF0 : 0xC0; 1 1 2
300 } else {
301 2 perl_absval = 0 - perlnum; signum = 0xD0;
302 }
303 4 ▶ if (ndec > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (ndec > 0) { 0 4 4
304 0 perl_absval *= pows_of_10[ndec];
305 }
306 /* Check for an excessively high value. */
307 4 ▶ if (perl_absval >= 1.0E31) {
Branch: 1 branch
BranchTrueFalseTotal
if (perl_absval >= 1.0E31) { 1 3 4
308 1 return 0;
309 }
310  
311 /* If the number is less than LLONG_MAX, we can use integer functions
312 without having to convert to a formatted string first.
313 Otherwise, we use sprintf to format the number and then convert to
314 EBCDIC (zoned). */
315 3 ▶ if (perl_absval < LLONG_MAX) {
Branch: 1 branch
BranchTrueFalseTotal
if (perl_absval < LLONG_MAX) { 3 0 3
316 3 ll_absval = (long long) (perl_absval + 0.5000001);
317 3 out_ptr = zoned_ptr + outbytes - 1;
318 /* Last digit + sign */
319 3 outdigits = ll_absval % 10;
320 3 *out_ptr-- = ((unsigned char) outdigits) | signum;
321 3 ll_absval = ll_absval / 10; /* no remainder */
322 /* Remaining digits */
323 29 ▶ for (i = 0; i < outbytes - 1; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < outbytes - 1; i++) { 26 3 29
324 26 outdigits = ll_absval % 10;
325 26 *out_ptr = to_zoned[outdigits];
326 26 ll_absval = ll_absval / 10; /* no remainder */
327 26 out_ptr--;
328 }
329 } else {
330 /* sprintf will round to an "integral" value. */
331 0 sprintf(digits, "%031.0f", perl_absval);
332 0 digit_ptr = digits + 31 - outbytes;
333 0 out_ptr = zoned_ptr;
334 0 ▶ for (i = 31 - outbytes; i < 31; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 31 - outbytes; i < 31; i++) { 0 0 0
335 0 ▶ if (i < 30) {
Branch: 1 branch
BranchTrueFalseTotal
if (i < 30) { 0 0 0
336 0 *out_ptr = to_zoned[*digit_ptr - '0'];
337 } else {
338 0 *out_ptr = (*digit_ptr - '0') | signum;
339 }
340 0 digit_ptr++;
341 0 out_ptr++;
342 }
343 }
344  
345 #ifdef DEBUG390
346 fprintf(stderr, "*D* CF_num2zoned: returning\n");
347 #endif
348 3 return 1;
349 }
350  
351  
352 /*---------- Full Collating Sequence Translate ----------
353 * This function is like tr/// but assumes that the searchstring
354 * is a complete 8-bit collating sequence (x'00' - x'FF').
355 * The last argument is one of the translation tables defined
356 * in IBM390.xs (a2e_table, etc.).
357 *-------------------------------------------------------*/
358 15 void CF_fcs_xlate
359 ( char *outstring,
360 char *instring,
361 int instring_len,
362 unsigned char *to_table )
363 {
364 char *out_ptr;
365 unsigned char offset;
366 register int i;
367  
368 #ifdef DEBUG390
369 fprintf(stderr, "*D* CF_fcs_xlate: beginning\n");
370 #endif
371 15 out_ptr = outstring;
372 122 ▶ for (i = 0; i < instring_len; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < instring_len; i++) { 107 15 122
373 107 offset = (unsigned char) *(instring + i);
374 107 (*out_ptr) = *(to_table + offset);
375 107 out_ptr++;
376 }
377  
378 #ifdef DEBUG390
379 fprintf(stderr, "*D* CF_fcs_xlate: returning\n");
380 #endif
381 15 return;
382 }
383  
384  
385 /*---------- Long integer to System/390 fullword ----------*/
386 12 void _to_S390fw (
387 char * out_word,
388 long n )
389 {
390 long comp;
391  
392 12 ▶ if (n >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (n >= 0) { 9 3 12
393 9 out_word[0] = (char) (n / 16777216);
394 9 out_word[1] = (char) (n / 65536) % 256;
395 9 out_word[2] = (char) (n / 256) % 256;
396 9 out_word[3] = (char) (n % 256);
397 } else {
398 3 comp = (-n) - 1; /* Complement */
399 3 out_word[0] = (char) (comp / 16777216);
400 3 out_word[1] = (char) (comp / 65536) % 256;
401 3 out_word[2] = (char) (comp / 256) % 256;
402 3 out_word[3] = (char) (comp % 256);
403 /* Invert all bits. */
404 3 out_word[0] = out_word[0] ^ 0xFF;
405 3 out_word[1] = out_word[1] ^ 0xFF;
406 3 out_word[2] = out_word[2] ^ 0xFF;
407 3 out_word[3] = out_word[3] ^ 0xFF;
408 }
409 12 return;
410 }
411  
412  
413 /*---------- Long integer to System/390 halfword ----------*/
414 10 void _to_S390hw (
415 char * out_word,
416 long n )
417 {
418 long comp;
419  
420 10 ▶ if (n > 32767 || n < -32768) {
Branch: 2 branches
BranchTrueFalseTotal
if (n > 32767 || n < -32768) { 10 0 10
if (n > 32767 || n < -32768) { 0 10 10
421 0 n = n % 32768;
422 }
423 10 ▶ if (n >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (n >= 0) { 6 4 10
424 6 out_word[0] = (char) (n / 256);
425 6 out_word[1] = (char) (n % 256);
426 } else {
427 4 comp = (-n) - 1; /* Complement */
428 4 out_word[0] = (char) (comp / 256);
429 4 out_word[1] = (char) (comp % 256);
430 /* Invert all bits. */
431 4 out_word[0] = out_word[0] ^ 0xFF;
432 4 out_word[1] = out_word[1] ^ 0xFF;
433 }
434 10 return;
435 }
436  
437  
438 /*---------- _halfword ----------*/
439 /* This function returns the value of a Sys/390 halfword (a signed
440 16-bit big-endian integer). */
441 16 int _halfword (
442 char * hw_ptr )
443 {
444 16 return (((signed char) hw_ptr[0]) << 8)
445 16 + (unsigned char) hw_ptr[1];
446 }
447  
« blib/lib/Convert/IBM390/CP01149.pm ↑ Summary IBM390.xs »