Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * varbit.c
4 : * Functions for the SQL datatypes BIT() and BIT VARYING().
5 : *
6 : * The data structure contains the following elements:
7 : * header -- length of the whole data structure (incl header)
8 : * in bytes (as with all varying length datatypes)
9 : * data section -- private data section for the bits data structures
10 : * bitlength -- length of the bit string in bits
11 : * bitdata -- bit string, most significant byte first
12 : *
13 : * The length of the bitdata vector should always be exactly as many
14 : * bytes as are needed for the given bitlength. If the bitlength is
15 : * not a multiple of 8, the extra low-order padding bits of the last
16 : * byte must be zeroes.
17 : *
18 : * attypmod is defined as the length of the bit string in bits, or for
19 : * varying bits the maximum length.
20 : *
21 : * Code originally contributed by Adriaan Joubert.
22 : *
23 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
24 : * Portions Copyright (c) 1994, Regents of the University of California
25 : *
26 : * IDENTIFICATION
27 : * src/backend/utils/adt/varbit.c
28 : *
29 : *-------------------------------------------------------------------------
30 : */
31 :
32 : #include "postgres.h"
33 :
34 : #include "access/htup_details.h"
35 : #include "common/int.h"
36 : #include "libpq/pqformat.h"
37 : #include "nodes/nodeFuncs.h"
38 : #include "nodes/supportnodes.h"
39 : #include "port/pg_bitutils.h"
40 : #include "utils/array.h"
41 : #include "utils/fmgrprotos.h"
42 : #include "utils/varbit.h"
43 :
44 : #define HEXDIG(z) ((z)<10 ? ((z)+'0') : ((z)-10+'A'))
45 :
46 : /* Mask off any bits that should be zero in the last byte of a bitstring */
47 : #define VARBIT_PAD(vb) \
48 : do { \
49 : int32 pad_ = VARBITPAD(vb); \
50 : Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE); \
51 : if (pad_ > 0) \
52 : *(VARBITS(vb) + VARBITBYTES(vb) - 1) &= BITMASK << pad_; \
53 : } while (0)
54 :
55 : /*
56 : * Many functions work byte-by-byte, so they have a pointer handy to the
57 : * last-plus-one byte, which saves a cycle or two.
58 : */
59 : #define VARBIT_PAD_LAST(vb, ptr) \
60 : do { \
61 : int32 pad_ = VARBITPAD(vb); \
62 : Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE); \
63 : if (pad_ > 0) \
64 : *((ptr) - 1) &= BITMASK << pad_; \
65 : } while (0)
66 :
67 : /* Assert proper padding of a bitstring */
68 : #ifdef USE_ASSERT_CHECKING
69 : #define VARBIT_CORRECTLY_PADDED(vb) \
70 : do { \
71 : int32 pad_ = VARBITPAD(vb); \
72 : Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE); \
73 : Assert(pad_ == 0 || \
74 : (*(VARBITS(vb) + VARBITBYTES(vb) - 1) & ~(BITMASK << pad_)) == 0); \
75 : } while (0)
76 : #else
77 : #define VARBIT_CORRECTLY_PADDED(vb) ((void) 0)
78 : #endif
79 :
80 : static VarBit *bit_catenate(VarBit *arg1, VarBit *arg2);
81 : static VarBit *bitsubstring(VarBit *arg, int32 s, int32 l,
82 : bool length_not_specified);
83 : static VarBit *bit_overlay(VarBit *t1, VarBit *t2, int sp, int sl);
84 :
85 :
86 : /*
87 : * common code for bittypmodin and varbittypmodin
88 : */
89 : static int32
90 2126 : anybit_typmodin(ArrayType *ta, const char *typename)
91 : {
92 : int32 typmod;
93 : int32 *tl;
94 : int n;
95 :
96 2126 : tl = ArrayGetIntegerTypmods(ta, &n);
97 :
98 : /*
99 : * we're not too tense about good error message here because grammar
100 : * shouldn't allow wrong number of modifiers for BIT
101 : */
102 2126 : if (n != 1)
103 0 : ereport(ERROR,
104 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
105 : errmsg("invalid type modifier")));
106 :
107 2126 : if (*tl < 1)
108 0 : ereport(ERROR,
109 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
110 : errmsg("length for type %s must be at least 1",
111 : typename)));
112 2126 : if (*tl > (MaxAttrSize * BITS_PER_BYTE))
113 0 : ereport(ERROR,
114 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
115 : errmsg("length for type %s cannot exceed %d",
116 : typename, MaxAttrSize * BITS_PER_BYTE)));
117 :
118 2126 : typmod = *tl;
119 :
120 2126 : return typmod;
121 : }
122 :
123 : /*
124 : * common code for bittypmodout and varbittypmodout
125 : */
126 : static char *
127 352 : anybit_typmodout(int32 typmod)
128 : {
129 352 : char *res = (char *) palloc(64);
130 :
131 352 : if (typmod >= 0)
132 352 : snprintf(res, 64, "(%d)", typmod);
133 : else
134 0 : *res = '\0';
135 :
136 352 : return res;
137 : }
138 :
139 :
140 : /*
141 : * bit_in -
142 : * converts a char string to the internal representation of a bitstring.
143 : * The length is determined by the number of bits required plus
144 : * VARHDRSZ bytes or from atttypmod.
145 : */
146 : Datum
147 5718 : bit_in(PG_FUNCTION_ARGS)
148 : {
149 5718 : char *input_string = PG_GETARG_CSTRING(0);
150 : #ifdef NOT_USED
151 : Oid typelem = PG_GETARG_OID(1);
152 : #endif
153 5718 : int32 atttypmod = PG_GETARG_INT32(2);
154 5718 : Node *escontext = fcinfo->context;
155 : VarBit *result; /* The resulting bit string */
156 : char *sp; /* pointer into the character string */
157 : bits8 *r; /* pointer into the result */
158 : int len, /* Length of the whole data structure */
159 : bitlen, /* Number of bits in the bit string */
160 : slen; /* Length of the input string */
161 : bool bit_not_hex; /* false = hex string true = bit string */
162 : int bc;
163 5718 : bits8 x = 0;
164 :
165 : /* Check that the first character is a b or an x */
166 5718 : if (input_string[0] == 'b' || input_string[0] == 'B')
167 : {
168 772 : bit_not_hex = true;
169 772 : sp = input_string + 1;
170 : }
171 4946 : else if (input_string[0] == 'x' || input_string[0] == 'X')
172 : {
173 3434 : bit_not_hex = false;
174 3434 : sp = input_string + 1;
175 : }
176 : else
177 : {
178 : /*
179 : * Otherwise it's binary. This allows things like cast('1001' as bit)
180 : * to work transparently.
181 : */
182 1512 : bit_not_hex = true;
183 1512 : sp = input_string;
184 : }
185 :
186 : /*
187 : * Determine bitlength from input string. MaxAllocSize ensures a regular
188 : * input is small enough, but we must check hex input.
189 : */
190 5718 : slen = strlen(sp);
191 5718 : if (bit_not_hex)
192 2284 : bitlen = slen;
193 : else
194 : {
195 3434 : if (slen > VARBITMAXLEN / 4)
196 0 : ereturn(escontext, (Datum) 0,
197 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
198 : errmsg("bit string length exceeds the maximum allowed (%d)",
199 : VARBITMAXLEN)));
200 3434 : bitlen = slen * 4;
201 : }
202 :
203 : /*
204 : * Sometimes atttypmod is not supplied. If it is supplied we need to make
205 : * sure that the bitstring fits.
206 : */
207 5718 : if (atttypmod <= 0)
208 4332 : atttypmod = bitlen;
209 1386 : else if (bitlen != atttypmod)
210 24 : ereturn(escontext, (Datum) 0,
211 : (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
212 : errmsg("bit string length %d does not match type bit(%d)",
213 : bitlen, atttypmod)));
214 :
215 5694 : len = VARBITTOTALLEN(atttypmod);
216 : /* set to 0 so that *r is always initialised and string is zero-padded */
217 5694 : result = (VarBit *) palloc0(len);
218 5694 : SET_VARSIZE(result, len);
219 5694 : VARBITLEN(result) = atttypmod;
220 :
221 5694 : r = VARBITS(result);
222 5694 : if (bit_not_hex)
223 : {
224 : /* Parse the bit representation of the string */
225 : /* We know it fits, as bitlen was compared to atttypmod */
226 2260 : x = HIGHBIT;
227 64766 : for (; *sp; sp++)
228 : {
229 62530 : if (*sp == '1')
230 31768 : *r |= x;
231 30762 : else if (*sp != '0')
232 24 : ereturn(escontext, (Datum) 0,
233 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
234 : errmsg("\"%.*s\" is not a valid binary digit",
235 : pg_mblen(sp), sp)));
236 :
237 62506 : x >>= 1;
238 62506 : if (x == 0)
239 : {
240 7328 : x = HIGHBIT;
241 7328 : r++;
242 : }
243 : }
244 : }
245 : else
246 : {
247 : /* Parse the hex representation of the string */
248 40572 : for (bc = 0; *sp; sp++)
249 : {
250 37162 : if (*sp >= '0' && *sp <= '9')
251 25496 : x = (bits8) (*sp - '0');
252 11666 : else if (*sp >= 'A' && *sp <= 'F')
253 278 : x = (bits8) (*sp - 'A') + 10;
254 11388 : else if (*sp >= 'a' && *sp <= 'f')
255 11364 : x = (bits8) (*sp - 'a') + 10;
256 : else
257 24 : ereturn(escontext, (Datum) 0,
258 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
259 : errmsg("\"%.*s\" is not a valid hexadecimal digit",
260 : pg_mblen(sp), sp)));
261 :
262 37138 : if (bc)
263 : {
264 18456 : *r++ |= x;
265 18456 : bc = 0;
266 : }
267 : else
268 : {
269 18682 : *r = x << 4;
270 18682 : bc = 1;
271 : }
272 : }
273 : }
274 :
275 5646 : PG_RETURN_VARBIT_P(result);
276 : }
277 :
278 :
279 : Datum
280 4242 : bit_out(PG_FUNCTION_ARGS)
281 : {
282 : #if 1
283 : /* same as varbit output */
284 4242 : return varbit_out(fcinfo);
285 : #else
286 :
287 : /*
288 : * This is how one would print a hex string, in case someone wants to
289 : * write a formatting function.
290 : */
291 : VarBit *s = PG_GETARG_VARBIT_P(0);
292 : char *result,
293 : *r;
294 : bits8 *sp;
295 : int i,
296 : len,
297 : bitlen;
298 :
299 : /* Assertion to help catch any bit functions that don't pad correctly */
300 : VARBIT_CORRECTLY_PADDED(s);
301 :
302 : bitlen = VARBITLEN(s);
303 : len = (bitlen + 3) / 4;
304 : result = (char *) palloc(len + 2);
305 : sp = VARBITS(s);
306 : r = result;
307 : *r++ = 'X';
308 : /* we cheat by knowing that we store full bytes zero padded */
309 : for (i = 0; i < len; i += 2, sp++)
310 : {
311 : *r++ = HEXDIG((*sp) >> 4);
312 : *r++ = HEXDIG((*sp) & 0xF);
313 : }
314 :
315 : /*
316 : * Go back one step if we printed a hex number that was not part of the
317 : * bitstring anymore
318 : */
319 : if (i > len)
320 : r--;
321 : *r = '\0';
322 :
323 : PG_RETURN_CSTRING(result);
324 : #endif
325 : }
326 :
327 : /*
328 : * bit_recv - converts external binary format to bit
329 : */
330 : Datum
331 0 : bit_recv(PG_FUNCTION_ARGS)
332 : {
333 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
334 :
335 : #ifdef NOT_USED
336 : Oid typelem = PG_GETARG_OID(1);
337 : #endif
338 0 : int32 atttypmod = PG_GETARG_INT32(2);
339 : VarBit *result;
340 : int len,
341 : bitlen;
342 :
343 0 : bitlen = pq_getmsgint(buf, sizeof(int32));
344 0 : if (bitlen < 0 || bitlen > VARBITMAXLEN)
345 0 : ereport(ERROR,
346 : (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
347 : errmsg("invalid length in external bit string")));
348 :
349 : /*
350 : * Sometimes atttypmod is not supplied. If it is supplied we need to make
351 : * sure that the bitstring fits.
352 : */
353 0 : if (atttypmod > 0 && bitlen != atttypmod)
354 0 : ereport(ERROR,
355 : (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
356 : errmsg("bit string length %d does not match type bit(%d)",
357 : bitlen, atttypmod)));
358 :
359 0 : len = VARBITTOTALLEN(bitlen);
360 0 : result = (VarBit *) palloc(len);
361 0 : SET_VARSIZE(result, len);
362 0 : VARBITLEN(result) = bitlen;
363 :
364 0 : pq_copymsgbytes(buf, (char *) VARBITS(result), VARBITBYTES(result));
365 :
366 : /* Make sure last byte is correctly zero-padded */
367 0 : VARBIT_PAD(result);
368 :
369 0 : PG_RETURN_VARBIT_P(result);
370 : }
371 :
372 : /*
373 : * bit_send - converts bit to binary format
374 : */
375 : Datum
376 0 : bit_send(PG_FUNCTION_ARGS)
377 : {
378 : /* Exactly the same as varbit_send, so share code */
379 0 : return varbit_send(fcinfo);
380 : }
381 :
382 : /*
383 : * bit()
384 : * Converts a bit() type to a specific internal length.
385 : * len is the bitlength specified in the column definition.
386 : *
387 : * If doing implicit cast, raise error when source data is wrong length.
388 : * If doing explicit cast, silently truncate or zero-pad to specified length.
389 : */
390 : Datum
391 984 : bit(PG_FUNCTION_ARGS)
392 : {
393 984 : VarBit *arg = PG_GETARG_VARBIT_P(0);
394 984 : int32 len = PG_GETARG_INT32(1);
395 984 : bool isExplicit = PG_GETARG_BOOL(2);
396 : VarBit *result;
397 : int rlen;
398 :
399 : /* No work if typmod is invalid or supplied data matches it already */
400 984 : if (len <= 0 || len > VARBITMAXLEN || len == VARBITLEN(arg))
401 372 : PG_RETURN_VARBIT_P(arg);
402 :
403 612 : if (!isExplicit)
404 18 : ereport(ERROR,
405 : (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
406 : errmsg("bit string length %d does not match type bit(%d)",
407 : VARBITLEN(arg), len)));
408 :
409 594 : rlen = VARBITTOTALLEN(len);
410 : /* set to 0 so that string is zero-padded */
411 594 : result = (VarBit *) palloc0(rlen);
412 594 : SET_VARSIZE(result, rlen);
413 594 : VARBITLEN(result) = len;
414 :
415 594 : memcpy(VARBITS(result), VARBITS(arg),
416 594 : Min(VARBITBYTES(result), VARBITBYTES(arg)));
417 :
418 : /*
419 : * Make sure last byte is zero-padded if needed. This is useless but safe
420 : * if source data was shorter than target length (we assume the last byte
421 : * of the source data was itself correctly zero-padded).
422 : */
423 594 : VARBIT_PAD(result);
424 :
425 594 : PG_RETURN_VARBIT_P(result);
426 : }
427 :
428 : Datum
429 1876 : bittypmodin(PG_FUNCTION_ARGS)
430 : {
431 1876 : ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0);
432 :
433 1876 : PG_RETURN_INT32(anybit_typmodin(ta, "bit"));
434 : }
435 :
436 : Datum
437 220 : bittypmodout(PG_FUNCTION_ARGS)
438 : {
439 220 : int32 typmod = PG_GETARG_INT32(0);
440 :
441 220 : PG_RETURN_CSTRING(anybit_typmodout(typmod));
442 : }
443 :
444 :
445 : /*
446 : * varbit_in -
447 : * converts a string to the internal representation of a bitstring.
448 : * This is the same as bit_in except that atttypmod is taken as
449 : * the maximum length, not the exact length to force the bitstring to.
450 : */
451 : Datum
452 1870 : varbit_in(PG_FUNCTION_ARGS)
453 : {
454 1870 : char *input_string = PG_GETARG_CSTRING(0);
455 : #ifdef NOT_USED
456 : Oid typelem = PG_GETARG_OID(1);
457 : #endif
458 1870 : int32 atttypmod = PG_GETARG_INT32(2);
459 1870 : Node *escontext = fcinfo->context;
460 : VarBit *result; /* The resulting bit string */
461 : char *sp; /* pointer into the character string */
462 : bits8 *r; /* pointer into the result */
463 : int len, /* Length of the whole data structure */
464 : bitlen, /* Number of bits in the bit string */
465 : slen; /* Length of the input string */
466 : bool bit_not_hex; /* false = hex string true = bit string */
467 : int bc;
468 1870 : bits8 x = 0;
469 :
470 : /* Check that the first character is a b or an x */
471 1870 : if (input_string[0] == 'b' || input_string[0] == 'B')
472 : {
473 0 : bit_not_hex = true;
474 0 : sp = input_string + 1;
475 : }
476 1870 : else if (input_string[0] == 'x' || input_string[0] == 'X')
477 : {
478 132 : bit_not_hex = false;
479 132 : sp = input_string + 1;
480 : }
481 : else
482 : {
483 1738 : bit_not_hex = true;
484 1738 : sp = input_string;
485 : }
486 :
487 : /*
488 : * Determine bitlength from input string. MaxAllocSize ensures a regular
489 : * input is small enough, but we must check hex input.
490 : */
491 1870 : slen = strlen(sp);
492 1870 : if (bit_not_hex)
493 1738 : bitlen = slen;
494 : else
495 : {
496 132 : if (slen > VARBITMAXLEN / 4)
497 0 : ereturn(escontext, (Datum) 0,
498 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
499 : errmsg("bit string length exceeds the maximum allowed (%d)",
500 : VARBITMAXLEN)));
501 132 : bitlen = slen * 4;
502 : }
503 :
504 : /*
505 : * Sometimes atttypmod is not supplied. If it is supplied we need to make
506 : * sure that the bitstring fits.
507 : */
508 1870 : if (atttypmod <= 0)
509 1738 : atttypmod = bitlen;
510 132 : else if (bitlen > atttypmod)
511 12 : ereturn(escontext, (Datum) 0,
512 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
513 : errmsg("bit string too long for type bit varying(%d)",
514 : atttypmod)));
515 :
516 1858 : len = VARBITTOTALLEN(bitlen);
517 : /* set to 0 so that *r is always initialised and string is zero-padded */
518 1858 : result = (VarBit *) palloc0(len);
519 1858 : SET_VARSIZE(result, len);
520 1858 : VARBITLEN(result) = Min(bitlen, atttypmod);
521 :
522 1858 : r = VARBITS(result);
523 1858 : if (bit_not_hex)
524 : {
525 : /* Parse the bit representation of the string */
526 : /* We know it fits, as bitlen was compared to atttypmod */
527 1726 : x = HIGHBIT;
528 66888 : for (; *sp; sp++)
529 : {
530 65174 : if (*sp == '1')
531 32508 : *r |= x;
532 32666 : else if (*sp != '0')
533 12 : ereturn(escontext, (Datum) 0,
534 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
535 : errmsg("\"%.*s\" is not a valid binary digit",
536 : pg_mblen(sp), sp)));
537 :
538 65162 : x >>= 1;
539 65162 : if (x == 0)
540 : {
541 7500 : x = HIGHBIT;
542 7500 : r++;
543 : }
544 : }
545 : }
546 : else
547 : {
548 : /* Parse the hex representation of the string */
549 552 : for (bc = 0; *sp; sp++)
550 : {
551 432 : if (*sp >= '0' && *sp <= '9')
552 318 : x = (bits8) (*sp - '0');
553 114 : else if (*sp >= 'A' && *sp <= 'F')
554 102 : x = (bits8) (*sp - 'A') + 10;
555 12 : else if (*sp >= 'a' && *sp <= 'f')
556 0 : x = (bits8) (*sp - 'a') + 10;
557 : else
558 12 : ereturn(escontext, (Datum) 0,
559 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
560 : errmsg("\"%.*s\" is not a valid hexadecimal digit",
561 : pg_mblen(sp), sp)));
562 :
563 420 : if (bc)
564 : {
565 204 : *r++ |= x;
566 204 : bc = 0;
567 : }
568 : else
569 : {
570 216 : *r = x << 4;
571 216 : bc = 1;
572 : }
573 : }
574 : }
575 :
576 1834 : PG_RETURN_VARBIT_P(result);
577 : }
578 :
579 : /*
580 : * varbit_out -
581 : * Prints the string as bits to preserve length accurately
582 : *
583 : * XXX varbit_recv() and hex input to varbit_in() can load a value that this
584 : * cannot emit. Consider using hex output for such values.
585 : */
586 : Datum
587 6206 : varbit_out(PG_FUNCTION_ARGS)
588 : {
589 6206 : VarBit *s = PG_GETARG_VARBIT_P(0);
590 : char *result,
591 : *r;
592 : bits8 *sp;
593 : bits8 x;
594 : int i,
595 : k,
596 : len;
597 :
598 : /* Assertion to help catch any bit functions that don't pad correctly */
599 : VARBIT_CORRECTLY_PADDED(s);
600 :
601 6206 : len = VARBITLEN(s);
602 6206 : result = (char *) palloc(len + 1);
603 6206 : sp = VARBITS(s);
604 6206 : r = result;
605 14522 : for (i = 0; i <= len - BITS_PER_BYTE; i += BITS_PER_BYTE, sp++)
606 : {
607 : /* print full bytes */
608 8316 : x = *sp;
609 74844 : for (k = 0; k < BITS_PER_BYTE; k++)
610 : {
611 66528 : *r++ = IS_HIGHBIT_SET(x) ? '1' : '0';
612 66528 : x <<= 1;
613 : }
614 : }
615 6206 : if (i < len)
616 : {
617 : /* print the last partial byte */
618 2984 : x = *sp;
619 14452 : for (k = i; k < len; k++)
620 : {
621 11468 : *r++ = IS_HIGHBIT_SET(x) ? '1' : '0';
622 11468 : x <<= 1;
623 : }
624 : }
625 6206 : *r = '\0';
626 :
627 6206 : PG_RETURN_CSTRING(result);
628 : }
629 :
630 : /*
631 : * varbit_recv - converts external binary format to varbit
632 : *
633 : * External format is the bitlen as an int32, then the byte array.
634 : */
635 : Datum
636 0 : varbit_recv(PG_FUNCTION_ARGS)
637 : {
638 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
639 :
640 : #ifdef NOT_USED
641 : Oid typelem = PG_GETARG_OID(1);
642 : #endif
643 0 : int32 atttypmod = PG_GETARG_INT32(2);
644 : VarBit *result;
645 : int len,
646 : bitlen;
647 :
648 0 : bitlen = pq_getmsgint(buf, sizeof(int32));
649 0 : if (bitlen < 0 || bitlen > VARBITMAXLEN)
650 0 : ereport(ERROR,
651 : (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
652 : errmsg("invalid length in external bit string")));
653 :
654 : /*
655 : * Sometimes atttypmod is not supplied. If it is supplied we need to make
656 : * sure that the bitstring fits.
657 : */
658 0 : if (atttypmod > 0 && bitlen > atttypmod)
659 0 : ereport(ERROR,
660 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
661 : errmsg("bit string too long for type bit varying(%d)",
662 : atttypmod)));
663 :
664 0 : len = VARBITTOTALLEN(bitlen);
665 0 : result = (VarBit *) palloc(len);
666 0 : SET_VARSIZE(result, len);
667 0 : VARBITLEN(result) = bitlen;
668 :
669 0 : pq_copymsgbytes(buf, (char *) VARBITS(result), VARBITBYTES(result));
670 :
671 : /* Make sure last byte is correctly zero-padded */
672 0 : VARBIT_PAD(result);
673 :
674 0 : PG_RETURN_VARBIT_P(result);
675 : }
676 :
677 : /*
678 : * varbit_send - converts varbit to binary format
679 : */
680 : Datum
681 0 : varbit_send(PG_FUNCTION_ARGS)
682 : {
683 0 : VarBit *s = PG_GETARG_VARBIT_P(0);
684 : StringInfoData buf;
685 :
686 0 : pq_begintypsend(&buf);
687 0 : pq_sendint32(&buf, VARBITLEN(s));
688 0 : pq_sendbytes(&buf, VARBITS(s), VARBITBYTES(s));
689 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
690 : }
691 :
692 : /*
693 : * varbit_support()
694 : *
695 : * Planner support function for the varbit() length coercion function.
696 : *
697 : * Currently, the only interesting thing we can do is flatten calls that set
698 : * the new maximum length >= the previous maximum length. We can ignore the
699 : * isExplicit argument, since that only affects truncation cases.
700 : */
701 : Datum
702 120 : varbit_support(PG_FUNCTION_ARGS)
703 : {
704 120 : Node *rawreq = (Node *) PG_GETARG_POINTER(0);
705 120 : Node *ret = NULL;
706 :
707 120 : if (IsA(rawreq, SupportRequestSimplify))
708 : {
709 60 : SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
710 60 : FuncExpr *expr = req->fcall;
711 : Node *typmod;
712 :
713 : Assert(list_length(expr->args) >= 2);
714 :
715 60 : typmod = (Node *) lsecond(expr->args);
716 :
717 60 : if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
718 : {
719 60 : Node *source = (Node *) linitial(expr->args);
720 60 : int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
721 60 : int32 old_max = exprTypmod(source);
722 60 : int32 new_max = new_typmod;
723 :
724 : /* Note: varbit() treats typmod 0 as invalid, so we do too */
725 60 : if (new_max <= 0 || (old_max > 0 && old_max <= new_max))
726 0 : ret = relabel_to_typmod(source, new_typmod);
727 : }
728 : }
729 :
730 120 : PG_RETURN_POINTER(ret);
731 : }
732 :
733 : /*
734 : * varbit()
735 : * Converts a varbit() type to a specific internal length.
736 : * len is the maximum bitlength specified in the column definition.
737 : *
738 : * If doing implicit cast, raise error when source data is too long.
739 : * If doing explicit cast, silently truncate to max length.
740 : */
741 : Datum
742 996 : varbit(PG_FUNCTION_ARGS)
743 : {
744 996 : VarBit *arg = PG_GETARG_VARBIT_P(0);
745 996 : int32 len = PG_GETARG_INT32(1);
746 996 : bool isExplicit = PG_GETARG_BOOL(2);
747 : VarBit *result;
748 : int rlen;
749 :
750 : /* No work if typmod is invalid or supplied data matches it already */
751 996 : if (len <= 0 || len >= VARBITLEN(arg))
752 984 : PG_RETURN_VARBIT_P(arg);
753 :
754 12 : if (!isExplicit)
755 12 : ereport(ERROR,
756 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
757 : errmsg("bit string too long for type bit varying(%d)",
758 : len)));
759 :
760 0 : rlen = VARBITTOTALLEN(len);
761 0 : result = (VarBit *) palloc(rlen);
762 0 : SET_VARSIZE(result, rlen);
763 0 : VARBITLEN(result) = len;
764 :
765 0 : memcpy(VARBITS(result), VARBITS(arg), VARBITBYTES(result));
766 :
767 : /* Make sure last byte is correctly zero-padded */
768 0 : VARBIT_PAD(result);
769 :
770 0 : PG_RETURN_VARBIT_P(result);
771 : }
772 :
773 : Datum
774 250 : varbittypmodin(PG_FUNCTION_ARGS)
775 : {
776 250 : ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0);
777 :
778 250 : PG_RETURN_INT32(anybit_typmodin(ta, "varbit"));
779 : }
780 :
781 : Datum
782 132 : varbittypmodout(PG_FUNCTION_ARGS)
783 : {
784 132 : int32 typmod = PG_GETARG_INT32(0);
785 :
786 132 : PG_RETURN_CSTRING(anybit_typmodout(typmod));
787 : }
788 :
789 :
790 : /*
791 : * Comparison operators
792 : *
793 : * We only need one set of comparison operators for bitstrings, as the lengths
794 : * are stored in the same way for zero-padded and varying bit strings.
795 : *
796 : * Note that the standard is not unambiguous about the comparison between
797 : * zero-padded bit strings and varying bitstrings. If the same value is written
798 : * into a zero padded bitstring as into a varying bitstring, but the zero
799 : * padded bitstring has greater length, it will be bigger.
800 : *
801 : * Zeros from the beginning of a bitstring cannot simply be ignored, as they
802 : * may be part of a bit string and may be significant.
803 : *
804 : * Note: btree indexes need these routines not to leak memory; therefore,
805 : * be careful to free working copies of toasted datums. Most places don't
806 : * need to be so careful.
807 : */
808 :
809 : /*
810 : * bit_cmp
811 : *
812 : * Compares two bitstrings and returns <0, 0, >0 depending on whether the first
813 : * string is smaller, equal, or bigger than the second. All bits are considered
814 : * and additional zero bits may make one string smaller/larger than the other,
815 : * even if their zero-padded values would be the same.
816 : */
817 : static int32
818 42690 : bit_cmp(VarBit *arg1, VarBit *arg2)
819 : {
820 : int bitlen1,
821 : bytelen1,
822 : bitlen2,
823 : bytelen2;
824 : int32 cmp;
825 :
826 42690 : bytelen1 = VARBITBYTES(arg1);
827 42690 : bytelen2 = VARBITBYTES(arg2);
828 :
829 42690 : cmp = memcmp(VARBITS(arg1), VARBITS(arg2), Min(bytelen1, bytelen2));
830 42690 : if (cmp == 0)
831 : {
832 6206 : bitlen1 = VARBITLEN(arg1);
833 6206 : bitlen2 = VARBITLEN(arg2);
834 6206 : if (bitlen1 != bitlen2)
835 42 : cmp = (bitlen1 < bitlen2) ? -1 : 1;
836 : }
837 42690 : return cmp;
838 : }
839 :
840 : Datum
841 5306 : biteq(PG_FUNCTION_ARGS)
842 : {
843 5306 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
844 5306 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
845 : bool result;
846 : int bitlen1,
847 : bitlen2;
848 :
849 5306 : bitlen1 = VARBITLEN(arg1);
850 5306 : bitlen2 = VARBITLEN(arg2);
851 :
852 : /* fast path for different-length inputs */
853 5306 : if (bitlen1 != bitlen2)
854 1502 : result = false;
855 : else
856 3804 : result = (bit_cmp(arg1, arg2) == 0);
857 :
858 5306 : PG_FREE_IF_COPY(arg1, 0);
859 5306 : PG_FREE_IF_COPY(arg2, 1);
860 :
861 5306 : PG_RETURN_BOOL(result);
862 : }
863 :
864 : Datum
865 968 : bitne(PG_FUNCTION_ARGS)
866 : {
867 968 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
868 968 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
869 : bool result;
870 : int bitlen1,
871 : bitlen2;
872 :
873 968 : bitlen1 = VARBITLEN(arg1);
874 968 : bitlen2 = VARBITLEN(arg2);
875 :
876 : /* fast path for different-length inputs */
877 968 : if (bitlen1 != bitlen2)
878 6 : result = true;
879 : else
880 962 : result = (bit_cmp(arg1, arg2) != 0);
881 :
882 968 : PG_FREE_IF_COPY(arg1, 0);
883 968 : PG_FREE_IF_COPY(arg2, 1);
884 :
885 968 : PG_RETURN_BOOL(result);
886 : }
887 :
888 : Datum
889 9876 : bitlt(PG_FUNCTION_ARGS)
890 : {
891 9876 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
892 9876 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
893 : bool result;
894 :
895 9876 : result = (bit_cmp(arg1, arg2) < 0);
896 :
897 9876 : PG_FREE_IF_COPY(arg1, 0);
898 9876 : PG_FREE_IF_COPY(arg2, 1);
899 :
900 9876 : PG_RETURN_BOOL(result);
901 : }
902 :
903 : Datum
904 8556 : bitle(PG_FUNCTION_ARGS)
905 : {
906 8556 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
907 8556 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
908 : bool result;
909 :
910 8556 : result = (bit_cmp(arg1, arg2) <= 0);
911 :
912 8556 : PG_FREE_IF_COPY(arg1, 0);
913 8556 : PG_FREE_IF_COPY(arg2, 1);
914 :
915 8556 : PG_RETURN_BOOL(result);
916 : }
917 :
918 : Datum
919 10400 : bitgt(PG_FUNCTION_ARGS)
920 : {
921 10400 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
922 10400 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
923 : bool result;
924 :
925 10400 : result = (bit_cmp(arg1, arg2) > 0);
926 :
927 10400 : PG_FREE_IF_COPY(arg1, 0);
928 10400 : PG_FREE_IF_COPY(arg2, 1);
929 :
930 10400 : PG_RETURN_BOOL(result);
931 : }
932 :
933 : Datum
934 8336 : bitge(PG_FUNCTION_ARGS)
935 : {
936 8336 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
937 8336 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
938 : bool result;
939 :
940 8336 : result = (bit_cmp(arg1, arg2) >= 0);
941 :
942 8336 : PG_FREE_IF_COPY(arg1, 0);
943 8336 : PG_FREE_IF_COPY(arg2, 1);
944 :
945 8336 : PG_RETURN_BOOL(result);
946 : }
947 :
948 : Datum
949 756 : bitcmp(PG_FUNCTION_ARGS)
950 : {
951 756 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
952 756 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
953 : int32 result;
954 :
955 756 : result = bit_cmp(arg1, arg2);
956 :
957 756 : PG_FREE_IF_COPY(arg1, 0);
958 756 : PG_FREE_IF_COPY(arg2, 1);
959 :
960 756 : PG_RETURN_INT32(result);
961 : }
962 :
963 : /*
964 : * bitcat
965 : * Concatenation of bit strings
966 : */
967 : Datum
968 162 : bitcat(PG_FUNCTION_ARGS)
969 : {
970 162 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
971 162 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
972 :
973 162 : PG_RETURN_VARBIT_P(bit_catenate(arg1, arg2));
974 : }
975 :
976 : static VarBit *
977 210 : bit_catenate(VarBit *arg1, VarBit *arg2)
978 : {
979 : VarBit *result;
980 : int bitlen1,
981 : bitlen2,
982 : bytelen,
983 : bit1pad,
984 : bit2shift;
985 : bits8 *pr,
986 : *pa;
987 :
988 210 : bitlen1 = VARBITLEN(arg1);
989 210 : bitlen2 = VARBITLEN(arg2);
990 :
991 210 : if (bitlen1 > VARBITMAXLEN - bitlen2)
992 0 : ereport(ERROR,
993 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
994 : errmsg("bit string length exceeds the maximum allowed (%d)",
995 : VARBITMAXLEN)));
996 210 : bytelen = VARBITTOTALLEN(bitlen1 + bitlen2);
997 :
998 210 : result = (VarBit *) palloc(bytelen);
999 210 : SET_VARSIZE(result, bytelen);
1000 210 : VARBITLEN(result) = bitlen1 + bitlen2;
1001 :
1002 : /* Copy the first bitstring in */
1003 210 : memcpy(VARBITS(result), VARBITS(arg1), VARBITBYTES(arg1));
1004 :
1005 : /* Copy the second bit string */
1006 210 : bit1pad = VARBITPAD(arg1);
1007 210 : if (bit1pad == 0)
1008 : {
1009 36 : memcpy(VARBITS(result) + VARBITBYTES(arg1), VARBITS(arg2),
1010 36 : VARBITBYTES(arg2));
1011 : }
1012 174 : else if (bitlen2 > 0)
1013 : {
1014 : /* We need to shift all the bits to fit */
1015 162 : bit2shift = BITS_PER_BYTE - bit1pad;
1016 162 : pr = VARBITS(result) + VARBITBYTES(arg1) - 1;
1017 378 : for (pa = VARBITS(arg2); pa < VARBITEND(arg2); pa++)
1018 : {
1019 216 : *pr |= ((*pa >> bit2shift) & BITMASK);
1020 216 : pr++;
1021 216 : if (pr < VARBITEND(result))
1022 138 : *pr = (*pa << bit1pad) & BITMASK;
1023 : }
1024 : }
1025 :
1026 : /* The pad bits should be already zero at this point */
1027 :
1028 210 : return result;
1029 : }
1030 :
1031 : /*
1032 : * bitsubstr
1033 : * retrieve a substring from the bit string.
1034 : * Note, s is 1-based.
1035 : * SQL draft 6.10 9)
1036 : */
1037 : Datum
1038 120 : bitsubstr(PG_FUNCTION_ARGS)
1039 : {
1040 120 : PG_RETURN_VARBIT_P(bitsubstring(PG_GETARG_VARBIT_P(0),
1041 : PG_GETARG_INT32(1),
1042 : PG_GETARG_INT32(2),
1043 : false));
1044 : }
1045 :
1046 : Datum
1047 42 : bitsubstr_no_len(PG_FUNCTION_ARGS)
1048 : {
1049 42 : PG_RETURN_VARBIT_P(bitsubstring(PG_GETARG_VARBIT_P(0),
1050 : PG_GETARG_INT32(1),
1051 : -1, true));
1052 : }
1053 :
1054 : static VarBit *
1055 210 : bitsubstring(VarBit *arg, int32 s, int32 l, bool length_not_specified)
1056 : {
1057 : VarBit *result;
1058 : int bitlen,
1059 : rbitlen,
1060 : len,
1061 : ishift,
1062 : i;
1063 : int32 e,
1064 : s1,
1065 : e1;
1066 : bits8 *r,
1067 : *ps;
1068 :
1069 210 : bitlen = VARBITLEN(arg);
1070 210 : s1 = Max(s, 1);
1071 : /* If we do not have an upper bound, use end of string */
1072 210 : if (length_not_specified)
1073 : {
1074 66 : e1 = bitlen + 1;
1075 : }
1076 144 : else if (l < 0)
1077 : {
1078 : /* SQL99 says to throw an error for E < S, i.e., negative length */
1079 12 : ereport(ERROR,
1080 : (errcode(ERRCODE_SUBSTRING_ERROR),
1081 : errmsg("negative substring length not allowed")));
1082 : e1 = -1; /* silence stupider compilers */
1083 : }
1084 132 : else if (pg_add_s32_overflow(s, l, &e))
1085 : {
1086 : /*
1087 : * L could be large enough for S + L to overflow, in which case the
1088 : * substring must run to end of string.
1089 : */
1090 12 : e1 = bitlen + 1;
1091 : }
1092 : else
1093 : {
1094 120 : e1 = Min(e, bitlen + 1);
1095 : }
1096 198 : if (s1 > bitlen || e1 <= s1)
1097 : {
1098 : /* Need to return a zero-length bitstring */
1099 54 : len = VARBITTOTALLEN(0);
1100 54 : result = (VarBit *) palloc(len);
1101 54 : SET_VARSIZE(result, len);
1102 54 : VARBITLEN(result) = 0;
1103 : }
1104 : else
1105 : {
1106 : /*
1107 : * OK, we've got a true substring starting at position s1-1 and ending
1108 : * at position e1-1
1109 : */
1110 144 : rbitlen = e1 - s1;
1111 144 : len = VARBITTOTALLEN(rbitlen);
1112 144 : result = (VarBit *) palloc(len);
1113 144 : SET_VARSIZE(result, len);
1114 144 : VARBITLEN(result) = rbitlen;
1115 144 : len -= VARHDRSZ + VARBITHDRSZ;
1116 : /* Are we copying from a byte boundary? */
1117 144 : if ((s1 - 1) % BITS_PER_BYTE == 0)
1118 : {
1119 : /* Yep, we are copying bytes */
1120 42 : memcpy(VARBITS(result), VARBITS(arg) + (s1 - 1) / BITS_PER_BYTE,
1121 : len);
1122 : }
1123 : else
1124 : {
1125 : /* Figure out how much we need to shift the sequence by */
1126 102 : ishift = (s1 - 1) % BITS_PER_BYTE;
1127 102 : r = VARBITS(result);
1128 102 : ps = VARBITS(arg) + (s1 - 1) / BITS_PER_BYTE;
1129 204 : for (i = 0; i < len; i++)
1130 : {
1131 102 : *r = (*ps << ishift) & BITMASK;
1132 102 : if ((++ps) < VARBITEND(arg))
1133 78 : *r |= *ps >> (BITS_PER_BYTE - ishift);
1134 102 : r++;
1135 : }
1136 : }
1137 :
1138 : /* Make sure last byte is correctly zero-padded */
1139 144 : VARBIT_PAD(result);
1140 : }
1141 :
1142 198 : return result;
1143 : }
1144 :
1145 : /*
1146 : * bitoverlay
1147 : * Replace specified substring of first string with second
1148 : *
1149 : * The SQL standard defines OVERLAY() in terms of substring and concatenation.
1150 : * This code is a direct implementation of what the standard says.
1151 : */
1152 : Datum
1153 6 : bitoverlay(PG_FUNCTION_ARGS)
1154 : {
1155 6 : VarBit *t1 = PG_GETARG_VARBIT_P(0);
1156 6 : VarBit *t2 = PG_GETARG_VARBIT_P(1);
1157 6 : int sp = PG_GETARG_INT32(2); /* substring start position */
1158 6 : int sl = PG_GETARG_INT32(3); /* substring length */
1159 :
1160 6 : PG_RETURN_VARBIT_P(bit_overlay(t1, t2, sp, sl));
1161 : }
1162 :
1163 : Datum
1164 18 : bitoverlay_no_len(PG_FUNCTION_ARGS)
1165 : {
1166 18 : VarBit *t1 = PG_GETARG_VARBIT_P(0);
1167 18 : VarBit *t2 = PG_GETARG_VARBIT_P(1);
1168 18 : int sp = PG_GETARG_INT32(2); /* substring start position */
1169 : int sl;
1170 :
1171 18 : sl = VARBITLEN(t2); /* defaults to length(t2) */
1172 18 : PG_RETURN_VARBIT_P(bit_overlay(t1, t2, sp, sl));
1173 : }
1174 :
1175 : static VarBit *
1176 24 : bit_overlay(VarBit *t1, VarBit *t2, int sp, int sl)
1177 : {
1178 : VarBit *result;
1179 : VarBit *s1;
1180 : VarBit *s2;
1181 : int sp_pl_sl;
1182 :
1183 : /*
1184 : * Check for possible integer-overflow cases. For negative sp, throw a
1185 : * "substring length" error because that's what should be expected
1186 : * according to the spec's definition of OVERLAY().
1187 : */
1188 24 : if (sp <= 0)
1189 0 : ereport(ERROR,
1190 : (errcode(ERRCODE_SUBSTRING_ERROR),
1191 : errmsg("negative substring length not allowed")));
1192 24 : if (pg_add_s32_overflow(sp, sl, &sp_pl_sl))
1193 0 : ereport(ERROR,
1194 : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1195 : errmsg("integer out of range")));
1196 :
1197 24 : s1 = bitsubstring(t1, 1, sp - 1, false);
1198 24 : s2 = bitsubstring(t1, sp_pl_sl, -1, true);
1199 24 : result = bit_catenate(s1, t2);
1200 24 : result = bit_catenate(result, s2);
1201 :
1202 24 : return result;
1203 : }
1204 :
1205 : /*
1206 : * bit_count
1207 : *
1208 : * Returns the number of bits set in a bit string.
1209 : */
1210 : Datum
1211 36 : bit_bit_count(PG_FUNCTION_ARGS)
1212 : {
1213 36 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1214 :
1215 36 : PG_RETURN_INT64(pg_popcount((char *) VARBITS(arg), VARBITBYTES(arg)));
1216 : }
1217 :
1218 : /*
1219 : * bitlength, bitoctetlength
1220 : * Return the length of a bit string
1221 : */
1222 : Datum
1223 42 : bitlength(PG_FUNCTION_ARGS)
1224 : {
1225 42 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1226 :
1227 42 : PG_RETURN_INT32(VARBITLEN(arg));
1228 : }
1229 :
1230 : Datum
1231 0 : bitoctetlength(PG_FUNCTION_ARGS)
1232 : {
1233 0 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1234 :
1235 0 : PG_RETURN_INT32(VARBITBYTES(arg));
1236 : }
1237 :
1238 : /*
1239 : * bit_and
1240 : * perform a logical AND on two bit strings.
1241 : */
1242 : Datum
1243 138 : bit_and(PG_FUNCTION_ARGS)
1244 : {
1245 138 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
1246 138 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
1247 : VarBit *result;
1248 : int len,
1249 : bitlen1,
1250 : bitlen2,
1251 : i;
1252 : bits8 *p1,
1253 : *p2,
1254 : *r;
1255 :
1256 138 : bitlen1 = VARBITLEN(arg1);
1257 138 : bitlen2 = VARBITLEN(arg2);
1258 138 : if (bitlen1 != bitlen2)
1259 6 : ereport(ERROR,
1260 : (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
1261 : errmsg("cannot AND bit strings of different sizes")));
1262 :
1263 132 : len = VARSIZE(arg1);
1264 132 : result = (VarBit *) palloc(len);
1265 132 : SET_VARSIZE(result, len);
1266 132 : VARBITLEN(result) = bitlen1;
1267 :
1268 132 : p1 = VARBITS(arg1);
1269 132 : p2 = VARBITS(arg2);
1270 132 : r = VARBITS(result);
1271 354 : for (i = 0; i < VARBITBYTES(arg1); i++)
1272 222 : *r++ = *p1++ & *p2++;
1273 :
1274 : /* Padding is not needed as & of 0 pads is 0 */
1275 :
1276 132 : PG_RETURN_VARBIT_P(result);
1277 : }
1278 :
1279 : /*
1280 : * bit_or
1281 : * perform a logical OR on two bit strings.
1282 : */
1283 : Datum
1284 168 : bit_or(PG_FUNCTION_ARGS)
1285 : {
1286 168 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
1287 168 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
1288 : VarBit *result;
1289 : int len,
1290 : bitlen1,
1291 : bitlen2,
1292 : i;
1293 : bits8 *p1,
1294 : *p2,
1295 : *r;
1296 :
1297 168 : bitlen1 = VARBITLEN(arg1);
1298 168 : bitlen2 = VARBITLEN(arg2);
1299 168 : if (bitlen1 != bitlen2)
1300 6 : ereport(ERROR,
1301 : (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
1302 : errmsg("cannot OR bit strings of different sizes")));
1303 162 : len = VARSIZE(arg1);
1304 162 : result = (VarBit *) palloc(len);
1305 162 : SET_VARSIZE(result, len);
1306 162 : VARBITLEN(result) = bitlen1;
1307 :
1308 162 : p1 = VARBITS(arg1);
1309 162 : p2 = VARBITS(arg2);
1310 162 : r = VARBITS(result);
1311 474 : for (i = 0; i < VARBITBYTES(arg1); i++)
1312 312 : *r++ = *p1++ | *p2++;
1313 :
1314 : /* Padding is not needed as | of 0 pads is 0 */
1315 :
1316 162 : PG_RETURN_VARBIT_P(result);
1317 : }
1318 :
1319 : /*
1320 : * bitxor
1321 : * perform a logical XOR on two bit strings.
1322 : */
1323 : Datum
1324 138 : bitxor(PG_FUNCTION_ARGS)
1325 : {
1326 138 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
1327 138 : VarBit *arg2 = PG_GETARG_VARBIT_P(1);
1328 : VarBit *result;
1329 : int len,
1330 : bitlen1,
1331 : bitlen2,
1332 : i;
1333 : bits8 *p1,
1334 : *p2,
1335 : *r;
1336 :
1337 138 : bitlen1 = VARBITLEN(arg1);
1338 138 : bitlen2 = VARBITLEN(arg2);
1339 138 : if (bitlen1 != bitlen2)
1340 6 : ereport(ERROR,
1341 : (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
1342 : errmsg("cannot XOR bit strings of different sizes")));
1343 :
1344 132 : len = VARSIZE(arg1);
1345 132 : result = (VarBit *) palloc(len);
1346 132 : SET_VARSIZE(result, len);
1347 132 : VARBITLEN(result) = bitlen1;
1348 :
1349 132 : p1 = VARBITS(arg1);
1350 132 : p2 = VARBITS(arg2);
1351 132 : r = VARBITS(result);
1352 354 : for (i = 0; i < VARBITBYTES(arg1); i++)
1353 222 : *r++ = *p1++ ^ *p2++;
1354 :
1355 : /* Padding is not needed as ^ of 0 pads is 0 */
1356 :
1357 132 : PG_RETURN_VARBIT_P(result);
1358 : }
1359 :
1360 : /*
1361 : * bitnot
1362 : * perform a logical NOT on a bit string.
1363 : */
1364 : Datum
1365 120 : bitnot(PG_FUNCTION_ARGS)
1366 : {
1367 120 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1368 : VarBit *result;
1369 : bits8 *p,
1370 : *r;
1371 :
1372 120 : result = (VarBit *) palloc(VARSIZE(arg));
1373 120 : SET_VARSIZE(result, VARSIZE(arg));
1374 120 : VARBITLEN(result) = VARBITLEN(arg);
1375 :
1376 120 : p = VARBITS(arg);
1377 120 : r = VARBITS(result);
1378 330 : for (; p < VARBITEND(arg); p++)
1379 210 : *r++ = ~*p;
1380 :
1381 : /* Must zero-pad the result, because extra bits are surely 1's here */
1382 120 : VARBIT_PAD_LAST(result, r);
1383 :
1384 120 : PG_RETURN_VARBIT_P(result);
1385 : }
1386 :
1387 : /*
1388 : * bitshiftleft
1389 : * do a left shift (i.e. towards the beginning of the string)
1390 : */
1391 : Datum
1392 696 : bitshiftleft(PG_FUNCTION_ARGS)
1393 : {
1394 696 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1395 696 : int32 shft = PG_GETARG_INT32(1);
1396 : VarBit *result;
1397 : int byte_shift,
1398 : ishift,
1399 : len;
1400 : bits8 *p,
1401 : *r;
1402 :
1403 : /* Negative shift is a shift to the right */
1404 696 : if (shft < 0)
1405 : {
1406 : /* Prevent integer overflow in negation */
1407 0 : if (shft < -VARBITMAXLEN)
1408 0 : shft = -VARBITMAXLEN;
1409 0 : PG_RETURN_DATUM(DirectFunctionCall2(bitshiftright,
1410 : VarBitPGetDatum(arg),
1411 : Int32GetDatum(-shft)));
1412 : }
1413 :
1414 696 : result = (VarBit *) palloc(VARSIZE(arg));
1415 696 : SET_VARSIZE(result, VARSIZE(arg));
1416 696 : VARBITLEN(result) = VARBITLEN(arg);
1417 696 : r = VARBITS(result);
1418 :
1419 : /* If we shifted all the bits out, return an all-zero string */
1420 696 : if (shft >= VARBITLEN(arg))
1421 : {
1422 24 : MemSet(r, 0, VARBITBYTES(arg));
1423 24 : PG_RETURN_VARBIT_P(result);
1424 : }
1425 :
1426 672 : byte_shift = shft / BITS_PER_BYTE;
1427 672 : ishift = shft % BITS_PER_BYTE;
1428 672 : p = VARBITS(arg) + byte_shift;
1429 :
1430 672 : if (ishift == 0)
1431 : {
1432 : /* Special case: we can do a memcpy */
1433 264 : len = VARBITBYTES(arg) - byte_shift;
1434 264 : memcpy(r, p, len);
1435 264 : MemSet(r + len, 0, byte_shift);
1436 : }
1437 : else
1438 : {
1439 1194 : for (; p < VARBITEND(arg); r++)
1440 : {
1441 786 : *r = *p << ishift;
1442 786 : if ((++p) < VARBITEND(arg))
1443 378 : *r |= *p >> (BITS_PER_BYTE - ishift);
1444 : }
1445 408 : for (; r < VARBITEND(result); r++)
1446 0 : *r = 0;
1447 : }
1448 :
1449 : /* The pad bits should be already zero at this point */
1450 :
1451 672 : PG_RETURN_VARBIT_P(result);
1452 : }
1453 :
1454 : /*
1455 : * bitshiftright
1456 : * do a right shift (i.e. towards the end of the string)
1457 : */
1458 : Datum
1459 876 : bitshiftright(PG_FUNCTION_ARGS)
1460 : {
1461 876 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1462 876 : int32 shft = PG_GETARG_INT32(1);
1463 : VarBit *result;
1464 : int byte_shift,
1465 : ishift,
1466 : len;
1467 : bits8 *p,
1468 : *r;
1469 :
1470 : /* Negative shift is a shift to the left */
1471 876 : if (shft < 0)
1472 : {
1473 : /* Prevent integer overflow in negation */
1474 0 : if (shft < -VARBITMAXLEN)
1475 0 : shft = -VARBITMAXLEN;
1476 0 : PG_RETURN_DATUM(DirectFunctionCall2(bitshiftleft,
1477 : VarBitPGetDatum(arg),
1478 : Int32GetDatum(-shft)));
1479 : }
1480 :
1481 876 : result = (VarBit *) palloc(VARSIZE(arg));
1482 876 : SET_VARSIZE(result, VARSIZE(arg));
1483 876 : VARBITLEN(result) = VARBITLEN(arg);
1484 876 : r = VARBITS(result);
1485 :
1486 : /* If we shifted all the bits out, return an all-zero string */
1487 876 : if (shft >= VARBITLEN(arg))
1488 : {
1489 24 : MemSet(r, 0, VARBITBYTES(arg));
1490 24 : PG_RETURN_VARBIT_P(result);
1491 : }
1492 :
1493 852 : byte_shift = shft / BITS_PER_BYTE;
1494 852 : ishift = shft % BITS_PER_BYTE;
1495 852 : p = VARBITS(arg);
1496 :
1497 : /* Set the first part of the result to 0 */
1498 852 : MemSet(r, 0, byte_shift);
1499 852 : r += byte_shift;
1500 :
1501 852 : if (ishift == 0)
1502 : {
1503 : /* Special case: we can do a memcpy */
1504 360 : len = VARBITBYTES(arg) - byte_shift;
1505 360 : memcpy(r, p, len);
1506 360 : r += len;
1507 : }
1508 : else
1509 : {
1510 492 : if (r < VARBITEND(result))
1511 492 : *r = 0; /* initialize first byte */
1512 1428 : for (; r < VARBITEND(result); p++)
1513 : {
1514 936 : *r |= *p >> ishift;
1515 936 : if ((++r) < VARBITEND(result))
1516 444 : *r = (*p << (BITS_PER_BYTE - ishift)) & BITMASK;
1517 : }
1518 : }
1519 :
1520 : /* We may have shifted 1's into the pad bits, so fix that */
1521 852 : VARBIT_PAD_LAST(result, r);
1522 :
1523 852 : PG_RETURN_VARBIT_P(result);
1524 : }
1525 :
1526 : /*
1527 : * This is not defined in any standard. We retain the natural ordering of
1528 : * bits here, as it just seems more intuitive.
1529 : */
1530 : Datum
1531 3004 : bitfromint4(PG_FUNCTION_ARGS)
1532 : {
1533 3004 : int32 a = PG_GETARG_INT32(0);
1534 3004 : int32 typmod = PG_GETARG_INT32(1);
1535 : VarBit *result;
1536 : bits8 *r;
1537 : int rlen;
1538 : int destbitsleft,
1539 : srcbitsleft;
1540 :
1541 3004 : if (typmod <= 0 || typmod > VARBITMAXLEN)
1542 0 : typmod = 1; /* default bit length */
1543 :
1544 3004 : rlen = VARBITTOTALLEN(typmod);
1545 3004 : result = (VarBit *) palloc(rlen);
1546 3004 : SET_VARSIZE(result, rlen);
1547 3004 : VARBITLEN(result) = typmod;
1548 :
1549 3004 : r = VARBITS(result);
1550 3004 : destbitsleft = typmod;
1551 3004 : srcbitsleft = 32;
1552 : /* drop any input bits that don't fit */
1553 3004 : srcbitsleft = Min(srcbitsleft, destbitsleft);
1554 : /* sign-fill any excess bytes in output */
1555 3004 : while (destbitsleft >= srcbitsleft + 8)
1556 : {
1557 0 : *r++ = (bits8) ((a < 0) ? BITMASK : 0);
1558 0 : destbitsleft -= 8;
1559 : }
1560 : /* store first fractional byte */
1561 3004 : if (destbitsleft > srcbitsleft)
1562 : {
1563 0 : unsigned int val = (unsigned int) (a >> (destbitsleft - 8));
1564 :
1565 : /* Force sign-fill in case the compiler implements >> as zero-fill */
1566 0 : if (a < 0)
1567 0 : val |= ((unsigned int) -1) << (srcbitsleft + 8 - destbitsleft);
1568 0 : *r++ = (bits8) (val & BITMASK);
1569 0 : destbitsleft -= 8;
1570 : }
1571 : /* Now srcbitsleft and destbitsleft are the same, need not track both */
1572 : /* store whole bytes */
1573 11696 : while (destbitsleft >= 8)
1574 : {
1575 8692 : *r++ = (bits8) ((a >> (destbitsleft - 8)) & BITMASK);
1576 8692 : destbitsleft -= 8;
1577 : }
1578 : /* store last fractional byte */
1579 3004 : if (destbitsleft > 0)
1580 666 : *r = (bits8) ((a << (8 - destbitsleft)) & BITMASK);
1581 :
1582 3004 : PG_RETURN_VARBIT_P(result);
1583 : }
1584 :
1585 : Datum
1586 1886 : bittoint4(PG_FUNCTION_ARGS)
1587 : {
1588 1886 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1589 : uint32 result;
1590 : bits8 *r;
1591 :
1592 : /* Check that the bit string is not too long */
1593 1886 : if (VARBITLEN(arg) > sizeof(result) * BITS_PER_BYTE)
1594 0 : ereport(ERROR,
1595 : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1596 : errmsg("integer out of range")));
1597 :
1598 1886 : result = 0;
1599 9220 : for (r = VARBITS(arg); r < VARBITEND(arg); r++)
1600 : {
1601 7334 : result <<= BITS_PER_BYTE;
1602 7334 : result |= *r;
1603 : }
1604 : /* Now shift the result to take account of the padding at the end */
1605 1886 : result >>= VARBITPAD(arg);
1606 :
1607 1886 : PG_RETURN_INT32(result);
1608 : }
1609 :
1610 : Datum
1611 1684 : bitfromint8(PG_FUNCTION_ARGS)
1612 : {
1613 1684 : int64 a = PG_GETARG_INT64(0);
1614 1684 : int32 typmod = PG_GETARG_INT32(1);
1615 : VarBit *result;
1616 : bits8 *r;
1617 : int rlen;
1618 : int destbitsleft,
1619 : srcbitsleft;
1620 :
1621 1684 : if (typmod <= 0 || typmod > VARBITMAXLEN)
1622 0 : typmod = 1; /* default bit length */
1623 :
1624 1684 : rlen = VARBITTOTALLEN(typmod);
1625 1684 : result = (VarBit *) palloc(rlen);
1626 1684 : SET_VARSIZE(result, rlen);
1627 1684 : VARBITLEN(result) = typmod;
1628 :
1629 1684 : r = VARBITS(result);
1630 1684 : destbitsleft = typmod;
1631 1684 : srcbitsleft = 64;
1632 : /* drop any input bits that don't fit */
1633 1684 : srcbitsleft = Min(srcbitsleft, destbitsleft);
1634 : /* sign-fill any excess bytes in output */
1635 1684 : while (destbitsleft >= srcbitsleft + 8)
1636 : {
1637 0 : *r++ = (bits8) ((a < 0) ? BITMASK : 0);
1638 0 : destbitsleft -= 8;
1639 : }
1640 : /* store first fractional byte */
1641 1684 : if (destbitsleft > srcbitsleft)
1642 : {
1643 0 : unsigned int val = (unsigned int) (a >> (destbitsleft - 8));
1644 :
1645 : /* Force sign-fill in case the compiler implements >> as zero-fill */
1646 0 : if (a < 0)
1647 0 : val |= ((unsigned int) -1) << (srcbitsleft + 8 - destbitsleft);
1648 0 : *r++ = (bits8) (val & BITMASK);
1649 0 : destbitsleft -= 8;
1650 : }
1651 : /* Now srcbitsleft and destbitsleft are the same, need not track both */
1652 : /* store whole bytes */
1653 8420 : while (destbitsleft >= 8)
1654 : {
1655 6736 : *r++ = (bits8) ((a >> (destbitsleft - 8)) & BITMASK);
1656 6736 : destbitsleft -= 8;
1657 : }
1658 : /* store last fractional byte */
1659 1684 : if (destbitsleft > 0)
1660 0 : *r = (bits8) ((a << (8 - destbitsleft)) & BITMASK);
1661 :
1662 1684 : PG_RETURN_VARBIT_P(result);
1663 : }
1664 :
1665 : Datum
1666 1370 : bittoint8(PG_FUNCTION_ARGS)
1667 : {
1668 1370 : VarBit *arg = PG_GETARG_VARBIT_P(0);
1669 : uint64 result;
1670 : bits8 *r;
1671 :
1672 : /* Check that the bit string is not too long */
1673 1370 : if (VARBITLEN(arg) > sizeof(result) * BITS_PER_BYTE)
1674 0 : ereport(ERROR,
1675 : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1676 : errmsg("bigint out of range")));
1677 :
1678 1370 : result = 0;
1679 12330 : for (r = VARBITS(arg); r < VARBITEND(arg); r++)
1680 : {
1681 10960 : result <<= BITS_PER_BYTE;
1682 10960 : result |= *r;
1683 : }
1684 : /* Now shift the result to take account of the padding at the end */
1685 1370 : result >>= VARBITPAD(arg);
1686 :
1687 1370 : PG_RETURN_INT64(result);
1688 : }
1689 :
1690 :
1691 : /*
1692 : * Determines the position of S2 in the bitstring S1 (1-based string).
1693 : * If S2 does not appear in S1 this function returns 0.
1694 : * If S2 is of length 0 this function returns 1.
1695 : * Compatible in usage with POSITION() functions for other data types.
1696 : */
1697 : Datum
1698 612 : bitposition(PG_FUNCTION_ARGS)
1699 : {
1700 612 : VarBit *str = PG_GETARG_VARBIT_P(0);
1701 612 : VarBit *substr = PG_GETARG_VARBIT_P(1);
1702 : int substr_length,
1703 : str_length,
1704 : i,
1705 : is;
1706 : bits8 *s, /* pointer into substring */
1707 : *p; /* pointer into str */
1708 : bits8 cmp, /* shifted substring byte to compare */
1709 : mask1, /* mask for substring byte shifted right */
1710 : mask2, /* mask for substring byte shifted left */
1711 : end_mask, /* pad mask for last substring byte */
1712 : str_mask; /* pad mask for last string byte */
1713 : bool is_match;
1714 :
1715 : /* Get the substring length */
1716 612 : substr_length = VARBITLEN(substr);
1717 612 : str_length = VARBITLEN(str);
1718 :
1719 : /* String has zero length or substring longer than string, return 0 */
1720 612 : if ((str_length == 0) || (substr_length > str_length))
1721 24 : PG_RETURN_INT32(0);
1722 :
1723 : /* zero-length substring means return 1 */
1724 588 : if (substr_length == 0)
1725 6 : PG_RETURN_INT32(1);
1726 :
1727 : /* Initialise the padding masks */
1728 582 : end_mask = BITMASK << VARBITPAD(substr);
1729 582 : str_mask = BITMASK << VARBITPAD(str);
1730 936 : for (i = 0; i < VARBITBYTES(str) - VARBITBYTES(substr) + 1; i++)
1731 : {
1732 5136 : for (is = 0; is < BITS_PER_BYTE; is++)
1733 : {
1734 4782 : is_match = true;
1735 4782 : p = VARBITS(str) + i;
1736 4782 : mask1 = BITMASK >> is;
1737 4782 : mask2 = ~mask1;
1738 5340 : for (s = VARBITS(substr);
1739 5226 : is_match && s < VARBITEND(substr); s++)
1740 : {
1741 4992 : cmp = *s >> is;
1742 4992 : if (s == VARBITEND(substr) - 1)
1743 : {
1744 3774 : mask1 &= end_mask >> is;
1745 3774 : if (p == VARBITEND(str) - 1)
1746 : {
1747 : /* Check that there is enough of str left */
1748 990 : if (mask1 & ~str_mask)
1749 : {
1750 60 : is_match = false;
1751 60 : break;
1752 : }
1753 930 : mask1 &= str_mask;
1754 : }
1755 : }
1756 4932 : is_match = ((cmp ^ *p) & mask1) == 0;
1757 4932 : if (!is_match)
1758 4050 : break;
1759 : /* Move on to the next byte */
1760 882 : p++;
1761 882 : if (p == VARBITEND(str))
1762 : {
1763 324 : mask2 = end_mask << (BITS_PER_BYTE - is);
1764 324 : is_match = mask2 == 0;
1765 : #if 0
1766 : elog(DEBUG4, "S. %d %d em=%2x sm=%2x r=%d",
1767 : i, is, end_mask, mask2, is_match);
1768 : #endif
1769 324 : break;
1770 : }
1771 558 : cmp = *s << (BITS_PER_BYTE - is);
1772 558 : if (s == VARBITEND(substr) - 1)
1773 : {
1774 234 : mask2 &= end_mask << (BITS_PER_BYTE - is);
1775 234 : if (p == VARBITEND(str) - 1)
1776 : {
1777 228 : if (mask2 & ~str_mask)
1778 : {
1779 0 : is_match = false;
1780 0 : break;
1781 : }
1782 228 : mask2 &= str_mask;
1783 : }
1784 : }
1785 558 : is_match = ((cmp ^ *p) & mask2) == 0;
1786 : }
1787 : /* Have we found a match? */
1788 4782 : if (is_match)
1789 486 : PG_RETURN_INT32(i * BITS_PER_BYTE + is + 1);
1790 : }
1791 : }
1792 96 : PG_RETURN_INT32(0);
1793 : }
1794 :
1795 :
1796 : /*
1797 : * bitsetbit
1798 : *
1799 : * Given an instance of type 'bit' creates a new one with
1800 : * the Nth bit set to the given value.
1801 : *
1802 : * The bit location is specified left-to-right in a zero-based fashion
1803 : * consistent with the other get_bit and set_bit functions, but
1804 : * inconsistent with the standard substring, position, overlay functions
1805 : */
1806 : Datum
1807 12 : bitsetbit(PG_FUNCTION_ARGS)
1808 : {
1809 12 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
1810 12 : int32 n = PG_GETARG_INT32(1);
1811 12 : int32 newBit = PG_GETARG_INT32(2);
1812 : VarBit *result;
1813 : int len,
1814 : bitlen;
1815 : bits8 *r,
1816 : *p;
1817 : int byteNo,
1818 : bitNo;
1819 :
1820 12 : bitlen = VARBITLEN(arg1);
1821 12 : if (n < 0 || n >= bitlen)
1822 6 : ereport(ERROR,
1823 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1824 : errmsg("bit index %d out of valid range (0..%d)",
1825 : n, bitlen - 1)));
1826 :
1827 : /*
1828 : * sanity check!
1829 : */
1830 6 : if (newBit != 0 && newBit != 1)
1831 0 : ereport(ERROR,
1832 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1833 : errmsg("new bit must be 0 or 1")));
1834 :
1835 6 : len = VARSIZE(arg1);
1836 6 : result = (VarBit *) palloc(len);
1837 6 : SET_VARSIZE(result, len);
1838 6 : VARBITLEN(result) = bitlen;
1839 :
1840 6 : p = VARBITS(arg1);
1841 6 : r = VARBITS(result);
1842 :
1843 6 : memcpy(r, p, VARBITBYTES(arg1));
1844 :
1845 6 : byteNo = n / BITS_PER_BYTE;
1846 6 : bitNo = BITS_PER_BYTE - 1 - (n % BITS_PER_BYTE);
1847 :
1848 : /*
1849 : * Update the byte.
1850 : */
1851 6 : if (newBit == 0)
1852 0 : r[byteNo] &= (~(1 << bitNo));
1853 : else
1854 6 : r[byteNo] |= (1 << bitNo);
1855 :
1856 6 : PG_RETURN_VARBIT_P(result);
1857 : }
1858 :
1859 : /*
1860 : * bitgetbit
1861 : *
1862 : * returns the value of the Nth bit of a bit array (0 or 1).
1863 : *
1864 : * The bit location is specified left-to-right in a zero-based fashion
1865 : * consistent with the other get_bit and set_bit functions, but
1866 : * inconsistent with the standard substring, position, overlay functions
1867 : */
1868 : Datum
1869 6 : bitgetbit(PG_FUNCTION_ARGS)
1870 : {
1871 6 : VarBit *arg1 = PG_GETARG_VARBIT_P(0);
1872 6 : int32 n = PG_GETARG_INT32(1);
1873 : int bitlen;
1874 : bits8 *p;
1875 : int byteNo,
1876 : bitNo;
1877 :
1878 6 : bitlen = VARBITLEN(arg1);
1879 6 : if (n < 0 || n >= bitlen)
1880 0 : ereport(ERROR,
1881 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
1882 : errmsg("bit index %d out of valid range (0..%d)",
1883 : n, bitlen - 1)));
1884 :
1885 6 : p = VARBITS(arg1);
1886 :
1887 6 : byteNo = n / BITS_PER_BYTE;
1888 6 : bitNo = BITS_PER_BYTE - 1 - (n % BITS_PER_BYTE);
1889 :
1890 6 : if (p[byteNo] & (1 << bitNo))
1891 6 : PG_RETURN_INT32(1);
1892 : else
1893 0 : PG_RETURN_INT32(0);
1894 : }
|
