open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename BITSPERBYTE to BITS_PER_BYTE to avoid conflict with <values.h>

Browse Source 
on some platforms.
REL7_1_STABLE
Tom Lane 26 years ago
parent 662f6a557c
commit d70bf0dd35
7 changed files with 44 additions and 44 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 14
      src/backend/lib/bit.c
  2. 6
      src/backend/parser/gram.y
  3. 4
      src/backend/utils/adt/format_type.c
  4. 48
      src/backend/utils/adt/varbit.c
  5. 4
      src/include/config.h.in
  6. 8
      src/include/utils/varbit.h
  7. 4
      src/interfaces/ecpg/preproc/preproc.y

14
src/backend/lib/bit.c
Unescape View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/lib/Attic/bit.c,v 1.10 2000/08/20 19:31:37 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/lib/Attic/bit.c,v 1.11 2000/08/26 21:53:42 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -21,21 +21,21 @@
void
BitArraySetBit(BitArray bitArray, BitIndex bitIndex)
{
bitArray[bitIndex / BITSPERBYTE] |=
(1 << (BITSPERBYTE - 1 - (bitIndex % BITSPERBYTE)));
bitArray[bitIndex / BITS_PER_BYTE] |=
(1 << (BITS_PER_BYTE - 1 - (bitIndex % BITS_PER_BYTE)));
}
void
BitArrayClearBit(BitArray bitArray, BitIndex bitIndex)
{
bitArray[bitIndex / BITSPERBYTE] &=
~(1 << (BITSPERBYTE - 1 - (bitIndex % BITSPERBYTE)));
bitArray[bitIndex / BITS_PER_BYTE] &=
~(1 << (BITS_PER_BYTE - 1 - (bitIndex % BITS_PER_BYTE)));
}
bool
BitArrayBitIsSet(BitArray bitArray, BitIndex bitIndex)
{
return ((bitArray[bitIndex / BITSPERBYTE] &
(1 << (BITSPERBYTE - 1 - (bitIndex % BITSPERBYTE)))
return ((bitArray[bitIndex / BITS_PER_BYTE] &
(1 << (BITS_PER_BYTE - 1 - (bitIndex % BITS_PER_BYTE)))
) != 0);
}

6
src/backend/parser/gram.y
Unescape View File

@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.186 2000/08/12 05:15:21 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.187 2000/08/26 21:53:43 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@ -4163,9 +4163,9 @@ Bit: bit '(' Iconst ')'
if ($3 < 1)
elog(ERROR,"length for type '%s' must be at least 1",
$1);
else if ($3 > (MaxAttrSize * BITSPERBYTE))
else if ($3 > (MaxAttrSize * BITS_PER_BYTE))
elog(ERROR,"length for type '%s' cannot exceed %d",
$1, (MaxAttrSize * BITSPERBYTE));
$1, (MaxAttrSize * BITS_PER_BYTE));
$$->typmod = $3;
}
| bit

4
src/backend/utils/adt/format_type.c
Unescape View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/format_type.c,v 1.4 2000/08/25 18:05:54 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/format_type.c,v 1.5 2000/08/26 21:53:41 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -254,7 +254,7 @@ type_maximum_size(Oid type_oid, int32 typemod)
case VARBITOID:
case ZPBITOID:
/* typemod is the (max) number of bits */
return (typemod + (BITSPERBYTE-1)) / BITSPERBYTE
return (typemod + (BITS_PER_BYTE-1)) / BITS_PER_BYTE
+ 2 * sizeof(int32);
}

48
src/backend/utils/adt/varbit.c
Unescape View File

@ -9,7 +9,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varbit.c,v 1.8 2000/08/21 04:48:50 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varbit.c,v 1.9 2000/08/26 21:53:41 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -161,7 +161,7 @@ zpbit_in(PG_FUNCTION_ARGS)
* The bottom ipad bits of the byte pointed to by r need to be
* zero
*/
if (((*r << (BITSPERBYTE - ipad)) & BITMASK) != 0)
if (((*r << (BITS_PER_BYTE - ipad)) & BITMASK) != 0)
elog(ERROR, "zpbit_in: bit string too long for bit(%d)",
atttypmod);
}
@ -387,7 +387,7 @@ varbit_in(PG_FUNCTION_ARGS)
* The bottom ipad bits of the byte pointed to by r need to be
* zero
*/
if (((*r << (BITSPERBYTE - ipad)) & BITMASK) != 0)
if (((*r << (BITS_PER_BYTE - ipad)) & BITMASK) != 0)
elog(ERROR, "varbit_in: bit string too long for bit varying(%d)",
atttypmod);
}
@ -415,10 +415,10 @@ varbit_out(PG_FUNCTION_ARGS)
sp = VARBITS(s);
r = result;
*r++ = 'B';
for (i = 0; i < len - BITSPERBYTE; i += BITSPERBYTE, sp++)
for (i = 0; i < len - BITS_PER_BYTE; i += BITS_PER_BYTE, sp++)
{
x = *sp;
for (k = 0; k < BITSPERBYTE; k++)
for (k = 0; k < BITS_PER_BYTE; k++)
{
*r++ = (x & BITHIGH) ? '1' : '0';
x <<= 1;
@ -704,7 +704,7 @@ bitcat(PG_FUNCTION_ARGS)
else if (bitlen2 > 0)
{
/* We need to shift all the bits to fit */
bit2shift = BITSPERBYTE - bit1pad;
bit2shift = BITS_PER_BYTE - bit1pad;
pr = VARBITS(result) + VARBITBYTES(arg1) - 1;
for (pa = VARBITS(arg2); pa < VARBITEND(arg2); pa++)
{
@ -768,23 +768,23 @@ bitsubstr(PG_FUNCTION_ARGS)
VARBITLEN(result) = rbitlen;
len -= VARHDRSZ + VARBITHDRSZ;
/* Are we copying from a byte boundary? */
if ((s1 - 1) % BITSPERBYTE == 0)
if ((s1 - 1) % BITS_PER_BYTE == 0)
{
/* Yep, we are copying bytes */
memcpy(VARBITS(result), VARBITS(arg) + (s1 - 1) / BITSPERBYTE,
memcpy(VARBITS(result), VARBITS(arg) + (s1 - 1) / BITS_PER_BYTE,
len);
}
else
{
/* Figure out how much we need to shift the sequence by */
ishift = (s1 - 1) % BITSPERBYTE;
ishift = (s1 - 1) % BITS_PER_BYTE;
r = VARBITS(result);
ps = VARBITS(arg) + (s1 - 1) / BITSPERBYTE;
ps = VARBITS(arg) + (s1 - 1) / BITS_PER_BYTE;
for (i = 0; i < len; i++)
{
*r = (*ps << ishift) & BITMASK;
if ((++ps) < VARBITEND(arg))
*r |= *ps >> (BITSPERBYTE - ishift);
*r |= *ps >> (BITS_PER_BYTE - ishift);
r++;
}
}
@ -1009,8 +1009,8 @@ bitshiftleft(PG_FUNCTION_ARGS)
PG_RETURN_VARBIT_P(result);
}
byte_shift = shft / BITSPERBYTE;
ishift = shft % BITSPERBYTE;
byte_shift = shft / BITS_PER_BYTE;
ishift = shft % BITS_PER_BYTE;
p = VARBITS(arg) + byte_shift;
if (ishift == 0)
@ -1026,7 +1026,7 @@ bitshiftleft(PG_FUNCTION_ARGS)
{
*r = *p << ishift;
if ((++p) < VARBITEND(arg))
*r |= *p >> (BITSPERBYTE - ishift);
*r |= *p >> (BITS_PER_BYTE - ishift);
}
for (; r < VARBITEND(result); r++)
*r = 0;
@ -1068,8 +1068,8 @@ bitshiftright(PG_FUNCTION_ARGS)
PG_RETURN_VARBIT_P(result);
}
byte_shift = shft / BITSPERBYTE;
ishift = shft % BITSPERBYTE;
byte_shift = shft / BITS_PER_BYTE;
ishift = shft % BITS_PER_BYTE;
p = VARBITS(arg);
/* Set the first part of the result to 0 */
@ -1090,7 +1090,7 @@ bitshiftright(PG_FUNCTION_ARGS)
{
*r |= *p >> ishift;
if ((++r) < VARBITEND(result))
*r = (*p << (BITSPERBYTE - ishift)) & BITMASK;
*r = (*p << (BITS_PER_BYTE - ishift)) & BITMASK;
}
}
@ -1109,17 +1109,17 @@ bitfromint4(PG_FUNCTION_ARGS)
int len;
/* allocate enough space for the bits in an int4 */
len = VARBITTOTALLEN(sizeof(int4)*BITSPERBYTE);
len = VARBITTOTALLEN(sizeof(int4)*BITS_PER_BYTE);
result = (VarBit *) palloc(len);
VARATT_SIZEP(result) = len;
VARBITLEN(result) = sizeof(int4)*BITSPERBYTE;
VARBITLEN(result) = sizeof(int4)*BITS_PER_BYTE;
/* masks and shifts here are just too painful and we know that an int4 has
* got 4 bytes
*/
r = VARBITS(result);
r[0] = (bits8) ((a >> (3*BITSPERBYTE)) & BITMASK);
r[1] = (bits8) ((a >> (2*BITSPERBYTE)) & BITMASK);
r[2] = (bits8) ((a >> (1*BITSPERBYTE)) & BITMASK);
r[0] = (bits8) ((a >> (3*BITS_PER_BYTE)) & BITMASK);
r[1] = (bits8) ((a >> (2*BITS_PER_BYTE)) & BITMASK);
r[2] = (bits8) ((a >> (1*BITS_PER_BYTE)) & BITMASK);
r[3] = (bits8) (a & BITMASK);
PG_RETURN_VARBIT_P(result);
@ -1133,12 +1133,12 @@ bittoint4(PG_FUNCTION_ARGS)
bits8 *r;
/* Check that the bit string is not too long */
if (VARBITLEN(arg) > sizeof(int4)*BITSPERBYTE)
if (VARBITLEN(arg) > sizeof(int4)*BITS_PER_BYTE)
elog(ERROR, "Bit string is too large to fit in an int4");
result = 0;
for (r = VARBITS(arg); r < VARBITEND(arg); r++)
{
result <<= BITSPERBYTE;
result <<= BITS_PER_BYTE;
result |= *r;
}
/* Now shift the result to take account of the padding at the end */

4
src/include/config.h.in
Unescape View File

@ -8,7 +8,7 @@
* or in config.h afterwards. Of course, if you edit config.h, then your
* changes will be overwritten the next time you run configure.
*
* $Id: config.h.in,v 1.131 2000/08/20 10:55:34 petere Exp $
* $Id: config.h.in,v 1.132 2000/08/26 21:53:40 tgl Exp $
*/
#ifndef CONFIG_H
@ -221,7 +221,7 @@
* You can try changing this if you have a machine with bytes of another
* size, but no guarantee...
*/
#define BITSPERBYTE 8
#define BITS_PER_BYTE 8
/*
* Define this is your operating system kernel supports AF_UNIX family

8
src/include/utils/varbit.h
Unescape View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: varbit.h,v 1.6 2000/08/21 04:48:54 tgl Exp $
* $Id: varbit.h,v 1.7 2000/08/26 21:53:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -49,13 +49,13 @@ typedef struct
/* Number of bytes in the data section of a bit string */
#define VARBITBYTES(PTR) (VARSIZE(PTR) - VARHDRSZ - VARBITHDRSZ)
/* Padding of the bit string at the end (in bits) */
#define VARBITPAD(PTR) (VARBITBYTES(PTR)*BITSPERBYTE - VARBITLEN(PTR))
#define VARBITPAD(PTR) (VARBITBYTES(PTR)*BITS_PER_BYTE - VARBITLEN(PTR))
/* Number of bytes needed to store a bit string of a given length */
#define VARBITTOTALLEN(BITLEN) (((BITLEN) + BITSPERBYTE-1)/BITSPERBYTE + \
#define VARBITTOTALLEN(BITLEN) (((BITLEN) + BITS_PER_BYTE-1)/BITS_PER_BYTE + \
VARHDRSZ + VARBITHDRSZ)
/* pointer beyond the end of the bit string (like end() in STL containers) */
#define VARBITEND(PTR) (((bits8 *) (PTR)) + VARSIZE(PTR))
/* Mask that will cover exactly one byte, i.e. BITSPERBYTE bits */
/* Mask that will cover exactly one byte, i.e. BITS_PER_BYTE bits */
#define BITMASK 0xFF
#define BITHIGH 0x80

4
src/interfaces/ecpg/preproc/preproc.y
Unescape View File

@ -3116,10 +3116,10 @@ Bit: bit '(' Iconst ')'
sprintf(errortext,"length for type '%s' must be at least 1",$1);
mmerror(ET_ERROR, errortext);
}
else if (atol($3) > (MaxAttrSize * BITSPERBYTE))
else if (atol($3) > (MaxAttrSize * BITS_PER_BYTE))
{
sprintf(errortext, "length for type '%s' cannot exceed %d", $1,
(MaxAttrSize * BITSPERBYTE));
(MaxAttrSize * BITS_PER_BYTE));
mmerror(ET_ERROR, errortext);
}
}

Write Preview
Loading…
Cancel
Save