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

on some platforms.

7 files changed, 38 insertions, 38 deletions

diff --git a/src/backend/lib/bit.c b/src/backend/lib/bit.c
index b69338ae68..98e0ef9fd0 100644
--- a/src/backend/lib/bit.c
+++ b/src/backend/lib/bit.c
@@ -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);
 }
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index e43a24b025..53a12f0580 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -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
diff --git a/src/backend/utils/adt/format_type.c b/src/backend/utils/adt/format_type.c
index ed98a0fe84..f485beeba8 100644
--- a/src/backend/utils/adt/format_type.c
+++ b/src/backend/utils/adt/format_type.c
@@ -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);
 	}
 
diff --git a/src/backend/utils/adt/varbit.c b/src/backend/utils/adt/varbit.c
index a31204f094..da10f77782 100644
--- a/src/backend/utils/adt/varbit.c
+++ b/src/backend/utils/adt/varbit.c
@@ -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 */
diff --git a/src/include/config.h.in b/src/include/config.h.in
index 59e9617473..3cd763a58e 100644
--- a/src/include/config.h.in
+++ b/src/include/config.h.in
@@ -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
diff --git a/src/include/utils/varbit.h b/src/include/utils/varbit.h
index 9c1e2525d9..fb92f5a056 100644
--- a/src/include/utils/varbit.h
+++ b/src/include/utils/varbit.h
@@ -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
 
diff --git a/src/interfaces/ecpg/preproc/preproc.y b/src/interfaces/ecpg/preproc/preproc.y
index 0d12a10b8e..b4a9d77756 100644
--- a/src/interfaces/ecpg/preproc/preproc.y
+++ b/src/interfaces/ecpg/preproc/preproc.y
@@ -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);
 					}
                                 }