pgindent run before 6.3 release, with Thomas' requested changes.

contrib/array/array_iterator.h

 #ifndef ARRAY_ITERATOR_H
 #define ARRAY_ITERATOR_H
 
-static int32 array_iterator(Oid elemtype, Oid proc, int and, 
-			    ArrayType *array, Datum value);
-int32 array_texteq(ArrayType *array, char* value);
-int32 array_all_texteq(ArrayType *array, char* value);
-int32 array_textregexeq(ArrayType *array, char* value);
-int32 array_all_textregexeq(ArrayType *array, char* value);
-int32 array_char16eq(ArrayType *array, char* value);
-int32 array_all_char16eq(ArrayType *array, char* value);
-int32 array_char16regexeq(ArrayType *array, char* value);
-int32 array_all_char16regexeq(ArrayType *array, char* value);
-int32 array_int4eq(ArrayType *array, int4 value);
-int32 array_all_int4eq(ArrayType *array, int4 value);
-int32 array_int4ne(ArrayType *array, int4 value);
-int32 array_all_int4ne(ArrayType *array, int4 value);
-int32 array_int4gt(ArrayType *array, int4 value);
-int32 array_all_int4gt(ArrayType *array, int4 value);
-int32 array_int4ge(ArrayType *array, int4 value);
-int32 array_all_int4ge(ArrayType *array, int4 value);
-int32 array_int4lt(ArrayType *array, int4 value);
-int32 array_all_int4lt(ArrayType *array, int4 value);
-int32 array_int4le(ArrayType *array, int4 value);
-int32 array_all_int4le(ArrayType *array, int4 value);
+static int32
+array_iterator(Oid elemtype, Oid proc, int and,
+			   ArrayType *array, Datum value);
+int32		array_texteq(ArrayType *array, char *value);
+int32		array_all_texteq(ArrayType *array, char *value);
+int32		array_textregexeq(ArrayType *array, char *value);
+int32		array_all_textregexeq(ArrayType *array, char *value);
+int32		array_char16eq(ArrayType *array, char *value);
+int32		array_all_char16eq(ArrayType *array, char *value);
+int32		array_char16regexeq(ArrayType *array, char *value);
+int32		array_all_char16regexeq(ArrayType *array, char *value);
+int32		array_int4eq(ArrayType *array, int4 value);
+int32		array_all_int4eq(ArrayType *array, int4 value);
+int32		array_int4ne(ArrayType *array, int4 value);
+int32		array_all_int4ne(ArrayType *array, int4 value);
+int32		array_int4gt(ArrayType *array, int4 value);
+int32		array_all_int4gt(ArrayType *array, int4 value);
+int32		array_int4ge(ArrayType *array, int4 value);
+int32		array_all_int4ge(ArrayType *array, int4 value);
+int32		array_int4lt(ArrayType *array, int4 value);
+int32		array_all_int4lt(ArrayType *array, int4 value);
+int32		array_int4le(ArrayType *array, int4 value);
+int32		array_all_int4le(ArrayType *array, int4 value);
 
 #endif

contrib/datetime/datetime_functions.c

@@ -6,7 +6,7 @@
  * Copyright (c) 1996, Massimo Dal Zotto <dz@cs.unitn.it>
  */
 
-#include <stdio.h>		/* for sprintf() */
+#include <stdio.h>				/* for sprintf() */
 #include <string.h>
 #include <limits.h>
 #ifdef HAVE_FLOAT_H
@@ -32,45 +32,47 @@
  * to hh:mm like in timetables.
  */
 
-TimeADT *
+TimeADT    *
 hhmm_in(char *str)
 {
-    TimeADT *time;
-
-    double fsec;
-    struct tm tt, *tm = &tt;
-
-    int nf;
-    char lowstr[MAXDATELEN+1];
-    char *field[MAXDATEFIELDS];
-    int dtype;
-    int ftype[MAXDATEFIELDS];
-
-    if (!PointerIsValid(str))
-        elog(ERROR,"Bad (null) time external representation",NULL);
-
-    if ((ParseDateTime( str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
-     || (DecodeTimeOnly( field, ftype, nf, &dtype, tm, &fsec) != 0))
-        elog(ERROR,"Bad time external representation '%s'",str);
-
-    if (tm->tm_hour<0 || tm->tm_hour>24 || 
-	(tm->tm_hour==24 && (tm->tm_min!=0 || tm->tm_sec!=0 || fsec!= 0))) {
-        elog(ERROR,
-	     "time_in: hour must be limited to values 0 through 24:00 "
-	     "in \"%s\"",
-	     str);
-    }
-    if ((tm->tm_min < 0) || (tm->tm_min > 59))
-	elog(ERROR,"Minute must be limited to values 0 through 59 in '%s'",str);
-    if ((tm->tm_sec < 0) || ((tm->tm_sec + fsec) >= 60))
-	elog(ERROR,"Second must be limited to values 0 through < 60 in '%s'",
-	     str);
-
-    time = palloc(sizeof(TimeADT));
-
-    *time = ((((tm->tm_hour*60)+tm->tm_min)*60));
-
-    return(time);
+	TimeADT    *time;
+
+	double		fsec;
+	struct tm	tt,
+			   *tm = &tt;
+
+	int			nf;
+	char		lowstr[MAXDATELEN + 1];
+	char	   *field[MAXDATEFIELDS];
+	int			dtype;
+	int			ftype[MAXDATEFIELDS];
+
+	if (!PointerIsValid(str))
+		elog(ERROR, "Bad (null) time external representation", NULL);
+
+	if ((ParseDateTime(str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
+		|| (DecodeTimeOnly(field, ftype, nf, &dtype, tm, &fsec) != 0))
+		elog(ERROR, "Bad time external representation '%s'", str);
+
+	if (tm->tm_hour < 0 || tm->tm_hour > 24 ||
+		(tm->tm_hour == 24 && (tm->tm_min != 0 || tm->tm_sec != 0 || fsec != 0)))
+	{
+		elog(ERROR,
+			 "time_in: hour must be limited to values 0 through 24:00 "
+			 "in \"%s\"",
+			 str);
+	}
+	if ((tm->tm_min < 0) || (tm->tm_min > 59))
+		elog(ERROR, "Minute must be limited to values 0 through 59 in '%s'", str);
+	if ((tm->tm_sec < 0) || ((tm->tm_sec + fsec) >= 60))
+		elog(ERROR, "Second must be limited to values 0 through < 60 in '%s'",
+			 str);
+
+	time = palloc(sizeof(TimeADT));
+
+	*time = ((((tm->tm_hour * 60) + tm->tm_min) * 60));
+
+	return (time);
 }
 
 /*
@@ -82,132 +84,143 @@ hhmm_in(char *str)
 char *
 hhmm_out(TimeADT *time)
 {
-    char *result;
-    struct tm tt, *tm = &tt;
-    char buf[MAXDATELEN+1];
+	char	   *result;
+	struct tm	tt,
+			   *tm = &tt;
+	char		buf[MAXDATELEN + 1];
 
-    if (!PointerIsValid(time))
-	return NULL;
+	if (!PointerIsValid(time))
+		return NULL;
 
-    tm->tm_hour = (*time / (60*60));
-    tm->tm_min = (((int) (*time / 60)) % 60);
-    tm->tm_sec = (((int) *time) % 60);
+	tm->tm_hour = (*time / (60 * 60));
+	tm->tm_min = (((int) (*time / 60)) % 60);
+	tm->tm_sec = (((int) *time) % 60);
 
-    if (tm->tm_sec == 0) {
-	sprintf(buf, "%02d:%02d", tm->tm_hour, tm->tm_min);
-    } else {
-	sprintf(buf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
-    }
+	if (tm->tm_sec == 0)
+	{
+		sprintf(buf, "%02d:%02d", tm->tm_hour, tm->tm_min);
+	}
+	else
+	{
+		sprintf(buf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
+	}
 
-    result = palloc(strlen(buf)+1);
+	result = palloc(strlen(buf) + 1);
 
-    strcpy( result, buf);
+	strcpy(result, buf);
 
-    return(result);
+	return (result);
 }
 
-TimeADT *
+TimeADT    *
 hhmm(TimeADT *time)
 {
-    TimeADT *result = palloc(sizeof(TimeADT));
+	TimeADT    *result = palloc(sizeof(TimeADT));
 
-    *result = (((int) *time) / 60 * 60);
+	*result = (((int) *time) / 60 * 60);
 
-    return(result);
+	return (result);
 }
 
-TimeADT *
+TimeADT    *
 time_difference(TimeADT *time1, TimeADT *time2)
 {
-    TimeADT *time = palloc(sizeof(TimeADT));
+	TimeADT    *time = palloc(sizeof(TimeADT));
 
-    *time = (*time1 - *time2);
-    return(time);
+	*time = (*time1 - *time2);
+	return (time);
 }
 
 int4
 time_hours(TimeADT *time)
 {
-    return (((int) *time) / 3600);
+	return (((int) *time) / 3600);
 }
 
 int4
 time_minutes(TimeADT *time)
 {
-    return ((((int) *time) / 60) % 60);
+	return ((((int) *time) / 60) % 60);
 }
 
 int4
 time_seconds(TimeADT *time)
 {
-    return (((int) *time) % 60);
+	return (((int) *time) % 60);
 }
 
 int4
 as_minutes(TimeADT *time)
 {
-    return (((int) *time) / 60);
+	return (((int) *time) / 60);
 }
 
 int4
 as_seconds(TimeADT *time)
 {
-    return ((int) *time);
+	return ((int) *time);
 }
 
 int4
 date_day(DateADT val)
 {
-    int year, month, day;
+	int			year,
+				month,
+				day;
 
-    j2date(val + JDATE_2000, &year, &month, &day);
+	j2date(val + JDATE_2000, &year, &month, &day);
 
-    return (day);
+	return (day);
 }
 
 int4
 date_month(DateADT val)
 {
-    int year, month, day;
+	int			year,
+				month,
+				day;
 
-    j2date(val + JDATE_2000, &year, &month, &day);
+	j2date(val + JDATE_2000, &year, &month, &day);
 
-    return (month);
+	return (month);
 }
 
 int4
 date_year(DateADT val)
 {
-    int year, month, day;
+	int			year,
+				month,
+				day;
 
-    j2date(val + JDATE_2000, &year, &month, &day);
+	j2date(val + JDATE_2000, &year, &month, &day);
 
-    return (year);
+	return (year);
 }
 
-TimeADT *
+TimeADT    *
 currenttime()
 {
-    TimeADT *result = palloc(sizeof(TimeADT));
-    struct tm *tm;
-    time_t current_time;
+	TimeADT    *result = palloc(sizeof(TimeADT));
+	struct tm  *tm;
+	time_t		current_time;
 
-    current_time = time(NULL);
-    tm = localtime(&current_time);
-    *result = ((((tm->tm_hour*60)+tm->tm_min)*60)+tm->tm_sec);
+	current_time = time(NULL);
+	tm = localtime(&current_time);
+	*result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec);
 
-    return (result);
+	return (result);
 }
 
 DateADT
 currentdate()
 {
-    DateADT date;
-    struct tm tt, *tm = &tt;
+	DateADT		date;
+	struct tm	tt,
+			   *tm = &tt;
 
-    GetCurrentTime(tm);
-    date = (date2j( tm->tm_year, tm->tm_mon, tm->tm_mday) - JDATE_2000);
-    return (date);
+	GetCurrentTime(tm);
+	date = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - JDATE_2000);
+	return (date);
 }
 
 /* end of file */

contrib/datetime/datetime_functions.h

 #ifndef DATETIME_FUNCTIONS_H
 #define DATETIME_FUNCTIONS_H
 
-TimeADT *hhmm_in(char *str);
-char *hhmm_out(TimeADT *time);
-TimeADT *hhmm(TimeADT *time);
-TimeADT *time_difference(TimeADT *time1, TimeADT *time2);
-int4 time_hours(TimeADT *time);
-int4 time_minutes(TimeADT *time);
-int4 time_seconds(TimeADT *time);
-int4 as_minutes(TimeADT *time);
-int4 as_seconds(TimeADT *time);
-int4 date_day(DateADT val);
-int4 date_month(DateADT val);
-int4 date_year(DateADT val);
-TimeADT *currenttime(void);
-DateADT currentdate(void);
+TimeADT    *hhmm_in(char *str);
+char	   *hhmm_out(TimeADT *time);
+TimeADT    *hhmm(TimeADT *time);
+TimeADT    *time_difference(TimeADT *time1, TimeADT *time2);
+int4		time_hours(TimeADT *time);
+int4		time_minutes(TimeADT *time);
+int4		time_seconds(TimeADT *time);
+int4		as_minutes(TimeADT *time);
+int4		as_seconds(TimeADT *time);
+int4		date_day(DateADT val);
+int4		date_month(DateADT val);
+int4		date_year(DateADT val);
+TimeADT    *currenttime(void);
+DateADT		currentdate(void);
 
 #endif

contrib/int8/int8.c

@@ -89,7 +89,7 @@ int64	   *dtoi8(float64 val);
 
 /* int8in()
  */
-int64	   *
+int64 *
 int8in(char *str)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -107,12 +107,12 @@ int8in(char *str)
 #endif
 
 	return (result);
-}								/* int8in() */
+}	/* int8in() */
 
 
 /* int8out()
  */
-char	   *
+char *
 int8out(int64 * val)
 {
 	char	   *result;
@@ -137,7 +137,7 @@ int8out(int64 * val)
 #endif
 
 	return (result);
-}								/* int8out() */
+}	/* int8out() */
 
 
 /*----------------------------------------------------------
@@ -151,37 +151,37 @@ bool
 int8eq(int64 * val1, int64 * val2)
 {
 	return (*val1 == *val2);
-}								/* int8eq() */
+}	/* int8eq() */
 
 bool
 int8ne(int64 * val1, int64 * val2)
 {
 	return (*val1 != *val2);
-}								/* int8ne() */
+}	/* int8ne() */
 
 bool
 int8lt(int64 * val1, int64 * val2)
 {
 	return (*val1 < *val2);
-}								/* int8lt() */
+}	/* int8lt() */
 
 bool
 int8gt(int64 * val1, int64 * val2)
 {
 	return (*val1 > *val2);
-}								/* int8gt() */
+}	/* int8gt() */
 
 bool
 int8le(int64 * val1, int64 * val2)
 {
 	return (*val1 <= *val2);
-}								/* int8le() */
+}	/* int8le() */
 
 bool
 int8ge(int64 * val1, int64 * val2)
 {
 	return (*val1 >= *val2);
-}								/* int8ge() */
+}	/* int8ge() */
 
 
 /* int84relop()
@@ -191,44 +191,44 @@ bool
 int84eq(int64 * val1, int32 val2)
 {
 	return (*val1 == val2);
-}								/* int84eq() */
+}	/* int84eq() */
 
 bool
 int84ne(int64 * val1, int32 val2)
 {
 	return (*val1 != val2);
-}								/* int84ne() */
+}	/* int84ne() */
 
 bool
 int84lt(int64 * val1, int32 val2)
 {
 	return (*val1 < val2);
-}								/* int84lt() */
+}	/* int84lt() */
 
 bool
 int84gt(int64 * val1, int32 val2)
 {
 	return (*val1 > val2);
-}								/* int84gt() */
+}	/* int84gt() */
 
 bool
 int84le(int64 * val1, int32 val2)
 {
 	return (*val1 <= val2);
-}								/* int84le() */
+}	/* int84le() */
 
 bool
 int84ge(int64 * val1, int32 val2)
 {
 	return (*val1 >= val2);
-}								/* int84ge() */
+}	/* int84ge() */
 
 
 /*----------------------------------------------------------
  *	Arithmetic operators on 64-bit integers.
  *---------------------------------------------------------*/
 
-int64	   *
+int64 *
 int8um(int64 * val)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -239,9 +239,9 @@ int8um(int64 * val)
 	*result = (-*val);
 
 	return (result);
-}								/* int8um() */
+}	/* int8um() */
 
-int64	   *
+int64 *
 int8pl(int64 * val1, int64 * val2)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -252,9 +252,9 @@ int8pl(int64 * val1, int64 * val2)
 	*result = *val1 + *val2;
 
 	return (result);
-}								/* int8pl() */
+}	/* int8pl() */
 
-int64	   *
+int64 *
 int8mi(int64 * val1, int64 * val2)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -265,9 +265,9 @@ int8mi(int64 * val1, int64 * val2)
 	*result = *val1 - *val2;
 
 	return (result);
-}								/* int8mi() */
+}	/* int8mi() */
 
-int64	   *
+int64 *
 int8mul(int64 * val1, int64 * val2)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -278,9 +278,9 @@ int8mul(int64 * val1, int64 * val2)
 	*result = *val1 * *val2;
 
 	return (result);
-}								/* int8mul() */
+}	/* int8mul() */
 
-int64	   *
+int64 *
 int8div(int64 * val1, int64 * val2)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -291,14 +291,14 @@ int8div(int64 * val1, int64 * val2)
 	*result = *val1 / *val2;
 
 	return (result);
-}								/* int8div() */
+}	/* int8div() */
 
 
 /*----------------------------------------------------------
  *	Conversion operators.
  *---------------------------------------------------------*/
 
-int64	   *
+int64 *
 int48(int32 val)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -306,7 +306,7 @@ int48(int32 val)
 	*result = val;
 
 	return (result);
-}								/* int48() */
+}	/* int48() */
 
 int32
 int84(int64 * val)
@@ -322,10 +322,10 @@ int84(int64 * val)
 	result = *val;
 
 	return (result);
-}								/* int84() */
+}	/* int84() */
 
 #if FALSE
-int64	   *
+int64 *
 int28		(int16 val)
 {
 	int64	   *result;
@@ -336,7 +336,7 @@ int28		(int16 val)
 	*result = val;
 
 	return (result);
-}								/* int28() */
+}	/* int28() */
 
 int16
 int82(int64 * val)
@@ -349,7 +349,7 @@ int82(int64 * val)
 	result = *val;
 
 	return (result);
-}								/* int82() */
+}	/* int82() */
 
 #endif
 
@@ -361,9 +361,9 @@ i8tod(int64 * val)
 	*result = *val;
 
 	return (result);
-}								/* i8tod() */
+}	/* i8tod() */
 
-int64	   *
+int64 *
 dtoi8(float64 val)
 {
 	int64	   *result = palloc(sizeof(int64));
@@ -374,4 +374,4 @@ dtoi8(float64 val)
 	*result = *val;
 
 	return (result);
-}								/* dtoi8() */
+}	/* dtoi8() */

contrib/ip_and_mac/ip.c

 /*
  *	PostgreSQL type definitions for IP addresses.
  *
- *	$Id: ip.c,v 1.2 1998/02/14 17:58:03 scrappy Exp $
+ *	$Id: ip.c,v 1.3 1998/02/26 04:27:37 momjian Exp $
  */
 
 #include <stdio.h>
@@ -13,83 +13,98 @@
  *	This is the internal storage format for IP addresses:
  */
 
-typedef struct ipaddr {
-  uint32 address;
-  int16 width;
-} ipaddr;
+typedef struct ipaddr
+{
+	uint32		address;
+	int16		width;
+}			ipaddr;
 
 /*
  *	Various forward declarations:
  */
 
-ipaddr *ipaddr_in(char *str);
-char *ipaddr_out(ipaddr *addr);
+ipaddr	   *ipaddr_in(char *str);
+char	   *ipaddr_out(ipaddr * addr);
 
-bool ipaddr_lt(ipaddr *a1, ipaddr *a2);
-bool ipaddr_le(ipaddr *a1, ipaddr *a2);
-bool ipaddr_eq(ipaddr *a1, ipaddr *a2);
-bool ipaddr_ge(ipaddr *a1, ipaddr *a2);
-bool ipaddr_gt(ipaddr *a1, ipaddr *a2);
+bool		ipaddr_lt(ipaddr * a1, ipaddr * a2);
+bool		ipaddr_le(ipaddr * a1, ipaddr * a2);
+bool		ipaddr_eq(ipaddr * a1, ipaddr * a2);
+bool		ipaddr_ge(ipaddr * a1, ipaddr * a2);
+bool		ipaddr_gt(ipaddr * a1, ipaddr * a2);
 
-bool ipaddr_ne(ipaddr *a1, ipaddr *a2);
+bool		ipaddr_ne(ipaddr * a1, ipaddr * a2);
 
-int4 ipaddr_cmp(ipaddr *a1, ipaddr *a2);
+int4		ipaddr_cmp(ipaddr * a1, ipaddr * a2);
 
-bool ipaddr_in_net(ipaddr *a1, ipaddr *a2);
-ipaddr *ipaddr_mask(ipaddr *a);
-ipaddr *ipaddr_bcast(ipaddr *a);
+bool		ipaddr_in_net(ipaddr * a1, ipaddr * a2);
+ipaddr	   *ipaddr_mask(ipaddr * a);
+ipaddr	   *ipaddr_bcast(ipaddr * a);
 
 /*
  *	Build a mask of a given width:
  */
 
-unsigned long build_mask(unsigned char bits) {
-  unsigned long mask = 0;
-  int i;
-  for (i = 0; i < bits; i++)
-    mask = (mask >> 1) | 0x80000000;
-  return mask;
+unsigned long
+build_mask(unsigned char bits)
+{
+	unsigned long mask = 0;
+	int			i;
+
+	for (i = 0; i < bits; i++)
+		mask = (mask >> 1) | 0x80000000;
+	return mask;
 }
 
 /*
- *	IP address reader.  Note how the count returned by sscanf()
+ *	IP address reader.	Note how the count returned by sscanf()
  *	is used to determine whether the mask size was specified.
  */
 
-ipaddr *ipaddr_in(char *str) {
-  int a, b, c, d, w;
-  ipaddr *result;
-  int count;
-
-  if (strlen(str) > 0) {
-
-    count = sscanf(str, "%d.%d.%d.%d/%d", &a, &b, &c, &d, &w);
-
-    if (count < 4) {
-      elog(ERROR, "ipaddr_in: error in parsing \"%s\"", str);
-      return(NULL);
-    }
-
-    if (count == 4)
-      w = 32;
-
-    if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
-	(c < 0) || (c > 255) || (d < 0) || (d > 255) ||
-	(w < 0) || (w > 32)) {
-      elog(ERROR, "ipaddr_in: illegal address \"%s\"", str);
-      return(NULL);
-    }
-  } else {
-    a = b = c = d = w = 0;	/* special case for missing address */
-  }
-
-  result = (ipaddr *)palloc(sizeof(ipaddr));
-
-  result->address = (uint32) ((a<<24)|(b<<16)|(c<<8)|d);
-  result->address &= build_mask(w);
-  result->width = w;
-
-  return(result);
+ipaddr *
+ipaddr_in(char *str)
+{
+	int			a,
+				b,
+				c,
+				d,
+				w;
+	ipaddr	   *result;
+	int			count;
+
+	if (strlen(str) > 0)
+	{
+
+		count = sscanf(str, "%d.%d.%d.%d/%d", &a, &b, &c, &d, &w);
+
+		if (count < 4)
+		{
+			elog(ERROR, "ipaddr_in: error in parsing \"%s\"", str);
+			return (NULL);
+		}
+
+		if (count == 4)
+			w = 32;
+
+		if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
+			(c < 0) || (c > 255) || (d < 0) || (d > 255) ||
+			(w < 0) || (w > 32))
+		{
+			elog(ERROR, "ipaddr_in: illegal address \"%s\"", str);
+			return (NULL);
+		}
+	}
+	else
+	{
+		a = b = c = d = w = 0;	/* special case for missing address */
+	}
+
+	result = (ipaddr *) palloc(sizeof(ipaddr));
+
+	result->address = (uint32) ((a << 24) | (b << 16) | (c << 8) | d);
+	result->address &= build_mask(w);
+	result->width = w;
+
+	return (result);
 }
 
 /*
@@ -97,118 +112,144 @@ ipaddr *ipaddr_in(char *str) {
  *	generated only for subnets, not for plain host addresses.
  */
 
-char *ipaddr_out(ipaddr *addr) {
-  char *result;
-
-  if (addr == NULL)
-    return(NULL);
-
-  result = (char *)palloc(32);
-
-  if (addr->address > 0) {
-    if (addr->width == 32)
-      sprintf(result, "%d.%d.%d.%d",
-	      (addr->address >> 24) & 0xff,
-	      (addr->address >> 16) & 0xff,
-	      (addr->address >> 8) & 0xff,
-	      addr->address & 0xff);
-    else
-      sprintf(result, "%d.%d.%d.%d/%d",
-	      (addr->address >> 24) & 0xff,
-	      (addr->address >> 16) & 0xff,
-	      (addr->address >> 8) & 0xff,
-	      addr->address & 0xff,
-	      addr->width);
-  } else {
-    result[0] = 0;		/* special case for missing address */
-  }
-  return(result);
+char *
+ipaddr_out(ipaddr * addr)
+{
+	char	   *result;
+
+	if (addr == NULL)
+		return (NULL);
+
+	result = (char *) palloc(32);
+
+	if (addr->address > 0)
+	{
+		if (addr->width == 32)
+			sprintf(result, "%d.%d.%d.%d",
+					(addr->address >> 24) & 0xff,
+					(addr->address >> 16) & 0xff,
+					(addr->address >> 8) & 0xff,
+					addr->address & 0xff);
+		else
+			sprintf(result, "%d.%d.%d.%d/%d",
+					(addr->address >> 24) & 0xff,
+					(addr->address >> 16) & 0xff,
+					(addr->address >> 8) & 0xff,
+					addr->address & 0xff,
+					addr->width);
+	}
+	else
+	{
+		result[0] = 0;			/* special case for missing address */
+	}
+	return (result);
 }
 
 /*
  *	Boolean tests for magnitude.
  */
 
-bool ipaddr_lt(ipaddr *a1, ipaddr *a2) {
-  return (a1->address < a2->address);
+bool
+ipaddr_lt(ipaddr * a1, ipaddr * a2)
+{
+	return (a1->address < a2->address);
 };
 
-bool ipaddr_le(ipaddr *a1, ipaddr *a2) {
-  return (a1->address <= a2->address);
+bool
+ipaddr_le(ipaddr * a1, ipaddr * a2)
+{
+	return (a1->address <= a2->address);
 };
 
-bool ipaddr_eq(ipaddr *a1, ipaddr *a2) {
-  return (a1->address == a2->address);
+bool
+ipaddr_eq(ipaddr * a1, ipaddr * a2)
+{
+	return (a1->address == a2->address);
 };
 
-bool ipaddr_ge(ipaddr *a1, ipaddr *a2) {
-  return (a1->address >= a2->address);
+bool
+ipaddr_ge(ipaddr * a1, ipaddr * a2)
+{
+	return (a1->address >= a2->address);
 };
 
-bool ipaddr_gt(ipaddr *a1, ipaddr *a2) {
-  return (a1->address > a2->address);
+bool
+ipaddr_gt(ipaddr * a1, ipaddr * a2)
+{
+	return (a1->address > a2->address);
 };
 
-bool ipaddr_ne(ipaddr *a1, ipaddr *a2) {
-  return (a1->address != a2->address);
+bool
+ipaddr_ne(ipaddr * a1, ipaddr * a2)
+{
+	return (a1->address != a2->address);
 };
 
 /*
  *	Comparison function for sorting:
  */
 
-int4 ipaddr_cmp(ipaddr *a1, ipaddr *a2) {
-  if (a1->address < a2->address)
-    return -1;
-  else if (a1->address > a2->address)
-    return 1;
-  else
-    return 0;
+int4
+ipaddr_cmp(ipaddr * a1, ipaddr * a2)
+{
+	if (a1->address < a2->address)
+		return -1;
+	else if (a1->address > a2->address)
+		return 1;
+	else
+		return 0;
 }
 
 /*
  *	Test whether an address is within a given subnet:
  */
 
-bool ipaddr_in_net(ipaddr *a1, ipaddr *a2) {
-  uint32 maskbits;
-  if (a1->width < a2->width)
-    return FALSE;
-  if ((a1->width == 32) && (a2->width == 32))
-    return ipaddr_eq(a1, a2);
-  maskbits = build_mask(a2->width);
-  if ((a1->address & maskbits) == (a2->address & maskbits))
-    return TRUE;
-  return FALSE;
+bool
+ipaddr_in_net(ipaddr * a1, ipaddr * a2)
+{
+	uint32		maskbits;
+
+	if (a1->width < a2->width)
+		return FALSE;
+	if ((a1->width == 32) && (a2->width == 32))
+		return ipaddr_eq(a1, a2);
+	maskbits = build_mask(a2->width);
+	if ((a1->address & maskbits) == (a2->address & maskbits))
+		return TRUE;
+	return FALSE;
 }
 
 /*
  *	Pick out just the mask of a network:
  */
 
-ipaddr *ipaddr_mask(ipaddr *a) {
-  ipaddr *result;
+ipaddr *
+ipaddr_mask(ipaddr * a)
+{
+	ipaddr	   *result;
 
-  result = (ipaddr *)palloc(sizeof(ipaddr));
-  result->address = build_mask(a->width);
-  result->width = 32;
+	result = (ipaddr *) palloc(sizeof(ipaddr));
+	result->address = build_mask(a->width);
+	result->width = 32;
 
-  return result;
+	return result;
 }
 
 /*
  *	Return the broadcast address of a network:
  */
 
-ipaddr *ipaddr_bcast(ipaddr *a) {
-  ipaddr *result;
+ipaddr *
+ipaddr_bcast(ipaddr * a)
+{
+	ipaddr	   *result;
 
-  result = (ipaddr *)palloc(sizeof(ipaddr));
-  result->address = a->address;
-  result->address |= (build_mask(32 - a->width) >> a->width);
-  result->width = 32;
+	result = (ipaddr *) palloc(sizeof(ipaddr));
+	result->address = a->address;
+	result->address |= (build_mask(32 - a->width) >> a->width);
+	result->width = 32;
 
-  return result;
+	return result;
 }
 
 /*

contrib/ip_and_mac/mac.c

 /*
  *	PostgreSQL type definitions for MAC addresses.
  *
- *	$Id: mac.c,v 1.2 1998/02/14 17:58:05 scrappy Exp $
+ *	$Id: mac.c,v 1.3 1998/02/26 04:27:44 momjian Exp $
  */
 
 #include <stdio.h>
@@ -15,33 +15,34 @@
  *	This is the internal storage format for MAC addresses:
  */
 
-typedef struct macaddr {
-  unsigned char a;
-  unsigned char b;
-  unsigned char c;
-  unsigned char d;
-  unsigned char e;
-  unsigned char f;
-} macaddr;
+typedef struct macaddr
+{
+	unsigned char a;
+	unsigned char b;
+	unsigned char c;
+	unsigned char d;
+	unsigned char e;
+	unsigned char f;
+}			macaddr;
 
 /*
  *	Various forward declarations:
  */
 
-macaddr *macaddr_in(char *str);
-char *macaddr_out(macaddr *addr);
+macaddr    *macaddr_in(char *str);
+char	   *macaddr_out(macaddr * addr);
 
-bool macaddr_lt(macaddr *a1, macaddr *a2);
-bool macaddr_le(macaddr *a1, macaddr *a2);
-bool macaddr_eq(macaddr *a1, macaddr *a2);
-bool macaddr_ge(macaddr *a1, macaddr *a2);
-bool macaddr_gt(macaddr *a1, macaddr *a2);
+bool		macaddr_lt(macaddr * a1, macaddr * a2);
+bool		macaddr_le(macaddr * a1, macaddr * a2);
+bool		macaddr_eq(macaddr * a1, macaddr * a2);
+bool		macaddr_ge(macaddr * a1, macaddr * a2);
+bool		macaddr_gt(macaddr * a1, macaddr * a2);
 
-bool macaddr_ne(macaddr *a1, macaddr *a2);
+bool		macaddr_ne(macaddr * a1, macaddr * a2);
 
-int4 macaddr_cmp(macaddr *a1, macaddr *a2);
+int4		macaddr_cmp(macaddr * a1, macaddr * a2);
 
-text *macaddr_manuf(macaddr *addr);
+text	   *macaddr_manuf(macaddr * addr);
 
 /*
  *	Utility macros used for sorting and comparing:
@@ -57,147 +58,185 @@ text *macaddr_manuf(macaddr *addr);
  *	MAC address reader.  Accepts several common notations.
  */
 
-macaddr *macaddr_in(char *str) {
-  int a, b, c, d, e, f;
-  macaddr *result;
-  int count;
-
-  if (strlen(str) > 0) {
-
-    count = sscanf(str, "%x:%x:%x:%x:%x:%x", &a, &b, &c, &d, &e, &f);
-    if (count != 6)
-      count = sscanf(str, "%x-%x-%x-%x-%x-%x", &a, &b, &c, &d, &e, &f);
-    if (count != 6)
-      count = sscanf(str, "%2x%2x%2x:%2x%2x%2x", &a, &b, &c, &d, &e, &f);
-    if (count != 6)
-      count = sscanf(str, "%2x%2x%2x-%2x%2x%2x", &a, &b, &c, &d, &e, &f);
-    if (count != 6)
-      count = sscanf(str, "%2x%2x.%2x%2x.%2x%2x", &a, &b, &c, &d, &e, &f);
-    
-    if (count != 6) {
-      elog(ERROR, "macaddr_in: error in parsing \"%s\"", str);
-      return(NULL);
-    }
-    
-    if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
-	(c < 0) || (c > 255) || (d < 0) || (d > 255) ||
-	(e < 0) || (e > 255) || (f < 0) || (f > 255)) {
-      elog(ERROR, "macaddr_in: illegal address \"%s\"", str);
-      return(NULL);
-    }
-  } else {
-    a = b = c = d = e = f = 0;	/* special case for missing address */
-  }
-
-  result = (macaddr *)palloc(sizeof(macaddr));
-
-  result->a = a;
-  result->b = b;
-  result->c = c;
-  result->d = d;
-  result->e = e;
-  result->f = f;
-
-  return(result);
+macaddr    *
+macaddr_in(char *str)
+{
+	int			a,
+				b,
+				c,
+				d,
+				e,
+				f;
+	macaddr    *result;
+	int			count;
+
+	if (strlen(str) > 0)
+	{
+
+		count = sscanf(str, "%x:%x:%x:%x:%x:%x", &a, &b, &c, &d, &e, &f);
+		if (count != 6)
+			count = sscanf(str, "%x-%x-%x-%x-%x-%x", &a, &b, &c, &d, &e, &f);
+		if (count != 6)
+			count = sscanf(str, "%2x%2x%2x:%2x%2x%2x", &a, &b, &c, &d, &e, &f);
+		if (count != 6)
+			count = sscanf(str, "%2x%2x%2x-%2x%2x%2x", &a, &b, &c, &d, &e, &f);
+		if (count != 6)
+			count = sscanf(str, "%2x%2x.%2x%2x.%2x%2x", &a, &b, &c, &d, &e, &f);
+
+		if (count != 6)
+		{
+			elog(ERROR, "macaddr_in: error in parsing \"%s\"", str);
+			return (NULL);
+		}
+
+		if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
+			(c < 0) || (c > 255) || (d < 0) || (d > 255) ||
+			(e < 0) || (e > 255) || (f < 0) || (f > 255))
+		{
+			elog(ERROR, "macaddr_in: illegal address \"%s\"", str);
+			return (NULL);
+		}
+	}
+	else
+	{
+		a = b = c = d = e = f = 0;		/* special case for missing
+										 * address */
+	}
+
+	result = (macaddr *) palloc(sizeof(macaddr));
+
+	result->a = a;
+	result->b = b;
+	result->c = c;
+	result->d = d;
+	result->e = e;
+	result->f = f;
+
+	return (result);
 }
 
 /*
  *	MAC address output function.  Fixed format.
  */
 
-char *macaddr_out(macaddr *addr) {
-  char *result;
-
-  if (addr == NULL)
-    return(NULL);
-
-  result = (char *)palloc(32);
-
-  if ((hibits(addr) > 0) || (lobits(addr) > 0)) {
-    sprintf(result, "%02x:%02x:%02x:%02x:%02x:%02x",
-	    addr->a, addr->b, addr->c, addr->d, addr->e, addr->f);
-  } else {
-    result[0] = 0;		/* special case for missing address */
-  }
-  return(result);
+char *
+macaddr_out(macaddr * addr)
+{
+	char	   *result;
+
+	if (addr == NULL)
+		return (NULL);
+
+	result = (char *) palloc(32);
+
+	if ((hibits(addr) > 0) || (lobits(addr) > 0))
+	{
+		sprintf(result, "%02x:%02x:%02x:%02x:%02x:%02x",
+				addr->a, addr->b, addr->c, addr->d, addr->e, addr->f);
+	}
+	else
+	{
+		result[0] = 0;			/* special case for missing address */
+	}
+	return (result);
 }
 
 /*
  *	Boolean tests.
  */
 
-bool macaddr_lt(macaddr *a1, macaddr *a2) {
-  return((hibits(a1) < hibits(a2)) ||
-	 ((hibits(a1) == hibits(a2)) && lobits(a1) < lobits(a2)));
+bool
+macaddr_lt(macaddr * a1, macaddr * a2)
+{
+	return ((hibits(a1) < hibits(a2)) ||
+			((hibits(a1) == hibits(a2)) && lobits(a1) < lobits(a2)));
 };
 
-bool macaddr_le(macaddr *a1, macaddr *a2) {
-  return((hibits(a1) < hibits(a2)) ||
-	 ((hibits(a1) == hibits(a2)) && lobits(a1) <= lobits(a2)));
+bool
+macaddr_le(macaddr * a1, macaddr * a2)
+{
+	return ((hibits(a1) < hibits(a2)) ||
+			((hibits(a1) == hibits(a2)) && lobits(a1) <= lobits(a2)));
 };
 
-bool macaddr_eq(macaddr *a1, macaddr *a2) {
-  return ((hibits(a1) == hibits(a2)) && (lobits(a1) == lobits(a2)));
+bool
+macaddr_eq(macaddr * a1, macaddr * a2)
+{
+	return ((hibits(a1) == hibits(a2)) && (lobits(a1) == lobits(a2)));
 };
 
-bool macaddr_ge(macaddr *a1, macaddr *a2) {
-  return((hibits(a1) > hibits(a2)) ||
-	 ((hibits(a1) == hibits(a2)) && lobits(a1) >= lobits(a2)));
+bool
+macaddr_ge(macaddr * a1, macaddr * a2)
+{
+	return ((hibits(a1) > hibits(a2)) ||
+			((hibits(a1) == hibits(a2)) && lobits(a1) >= lobits(a2)));
 };
 
-bool macaddr_gt(macaddr *a1, macaddr *a2) {
-  return((hibits(a1) > hibits(a2)) ||
-	 ((hibits(a1) == hibits(a2)) && lobits(a1) > lobits(a2)));
+bool
+macaddr_gt(macaddr * a1, macaddr * a2)
+{
+	return ((hibits(a1) > hibits(a2)) ||
+			((hibits(a1) == hibits(a2)) && lobits(a1) > lobits(a2)));
 };
 
-bool macaddr_ne(macaddr *a1, macaddr *a2) {
-  return ((hibits(a1) != hibits(a2)) || (lobits(a1) != lobits(a2)));
+bool
+macaddr_ne(macaddr * a1, macaddr * a2)
+{
+	return ((hibits(a1) != hibits(a2)) || (lobits(a1) != lobits(a2)));
 };
 
 /*
  *	Comparison function for sorting:
  */
 
-int4 macaddr_cmp(macaddr *a1, macaddr *a2) {
-  if (hibits(a1) < hibits(a2))
-    return -1;
-  else if (hibits(a1) > hibits(a2))
-    return 1;
-  else if (lobits(a1) < lobits(a2))
-    return -1;
-  else if (lobits(a1) > lobits(a2))
-    return 1;
-  else
-    return 0;
+int4
+macaddr_cmp(macaddr * a1, macaddr * a2)
+{
+	if (hibits(a1) < hibits(a2))
+		return -1;
+	else if (hibits(a1) > hibits(a2))
+		return 1;
+	else if (lobits(a1) < lobits(a2))
+		return -1;
+	else if (lobits(a1) > lobits(a2))
+		return 1;
+	else
+		return 0;
 }
 
 /*
  *	The special manufacturer fetching function.  See "mac.h".
  */
 
-text *macaddr_manuf(macaddr *addr) {
-  manufacturer *manuf;
-  int length;
-  text *result;
-
-  for (manuf = manufacturers; manuf->name != NULL; manuf++) {
-    if ((manuf->a == addr->a) &&
-	(manuf->b == addr->b) &&
-	(manuf->c == addr->c))
-      break;
-  }
-  if (manuf->name == NULL) {
-    result = palloc(VARHDRSZ + 1);
-    memset(result, 0, VARHDRSZ + 1);
-    VARSIZE(result) = VARHDRSZ + 1;
-  } else {
-    length = strlen(manuf->name) + 1;
-    result = palloc(length + VARHDRSZ);
-    memset(result, 0, length + VARHDRSZ);
-    VARSIZE(result) = length + VARHDRSZ;
-    memcpy(VARDATA(result), manuf->name, length);
-  }
-  return result;
+text *
+macaddr_manuf(macaddr * addr)
+{
+	manufacturer *manuf;
+	int			length;
+	text	   *result;
+
+	for (manuf = manufacturers; manuf->name != NULL; manuf++)
+	{
+		if ((manuf->a == addr->a) &&
+			(manuf->b == addr->b) &&
+			(manuf->c == addr->c))
+			break;
+	}
+	if (manuf->name == NULL)
+	{
+		result = palloc(VARHDRSZ + 1);
+		memset(result, 0, VARHDRSZ + 1);
+		VARSIZE(result) = VARHDRSZ + 1;
+	}
+	else
+	{
+		length = strlen(manuf->name) + 1;
+		result = palloc(length + VARHDRSZ);
+		memset(result, 0, length + VARHDRSZ);
+		VARSIZE(result) = length + VARHDRSZ;
+		memcpy(VARDATA(result), manuf->name, length);
+	}
+	return result;
 }
 
 /*

contrib/ip_and_mac/mac.h

 /*
  *	PostgreSQL type definitions for MAC addresses.
  *
- *	$Id: mac.h,v 1.2 1998/02/14 17:58:07 scrappy Exp $
+ *	$Id: mac.h,v 1.3 1998/02/26 04:27:50 momjian Exp $
  */
 
-typedef struct manufacturer {
-  unsigned char a;
-  unsigned char b;
-  unsigned char c;
-  char *name;
-} manufacturer;
+typedef struct manufacturer
+{
+	unsigned char a;
+	unsigned char b;
+	unsigned char c;
+	char	   *name;
+}			manufacturer;
 
 manufacturer manufacturers[] = {
-  {0x00, 0x00, 0x0C, "Cisco"},
-  {0x00, 0x00, 0x0E, "Fujitsu"},
-  {0x00, 0x00, 0x0F, "NeXT"},
-  {0x00, 0x00, 0x10, "Sytek"},
-  {0x00, 0x00, 0x1D, "Cabletron"},
-  {0x00, 0x00, 0x20, "DIAB"},
-  {0x00, 0x00, 0x22, "Visual Technology"},
-  {0x00, 0x00, 0x2A, "TRW"},
-  {0x00, 0x00, 0x32, "GPT Limited"},
-  {0x00, 0x00, 0x5A, "S & Koch"},
-  {0x00, 0x00, 0x5E, "IANA"},
-  {0x00, 0x00, 0x65, "Network General"},
-  {0x00, 0x00, 0x6B, "MIPS"},
-  {0x00, 0x00, 0x77, "MIPS"},
-  {0x00, 0x00, 0x7A, "Ardent"},
-  {0x00, 0x00, 0x89, "Cayman Systems"},
-  {0x00, 0x00, 0x93, "Proteon"},
-  {0x00, 0x00, 0x9F, "Ameristar Technology"},
-  {0x00, 0x00, 0xA2, "Wellfleet"},
-  {0x00, 0x00, 0xA3, "Network Application Technology"},
-  {0x00, 0x00, 0xA6, "Network General"},
-  {0x00, 0x00, 0xA7, "NCD"},
-  {0x00, 0x00, 0xA9, "Network Systems"},
-  {0x00, 0x00, 0xAA, "Xerox"},
-  {0x00, 0x00, 0xB3, "CIMLinc"},
-  {0x00, 0x00, 0xB7, "Dove Fastnet"},
-  {0x00, 0x00, 0xBC, "Allen-Bradley"},
-  {0x00, 0x00, 0xC0, "Western Digital"},
-  {0x00, 0x00, 0xC5, "Farallon"},
-  {0x00, 0x00, 0xC6, "Hewlett-Packard"},
-  {0x00, 0x00, 0xC8, "Altos"},
-  {0x00, 0x00, 0xC9, "Emulex"},
-  {0x00, 0x00, 0xD7, "Dartmouth College"},
-  {0x00, 0x00, 0xD8, "3Com (?)"},
-  {0x00, 0x00, 0xDD, "Gould"},
-  {0x00, 0x00, 0xDE, "Unigraph"},
-  {0x00, 0x00, 0xE2, "Acer Counterpoint"},
-  {0x00, 0x00, 0xEF, "Alantec"},
-  {0x00, 0x00, 0xFD, "High Level Hardware"},
-  {0x00, 0x01, 0x02, "BBN internal usage"},
-  {0x00, 0x20, 0xAF, "3Com"},
-  {0x00, 0x17, 0x00, "Kabel"},
-  {0x00, 0x80, 0x64, "Wyse Technology"},
-  {0x00, 0x80, 0x2B, "IMAC (?)"},
-  {0x00, 0x80, 0x2D, "Xylogics, Inc."},
-  {0x00, 0x80, 0x8C, "Frontier Software Development"},
-  {0x00, 0x80, 0xC2, "IEEE 802.1 Committee"},
-  {0x00, 0x80, 0xD3, "Shiva"},
-  {0x00, 0xAA, 0x00, "Intel"},
-  {0x00, 0xDD, 0x00, "Ungermann-Bass"},
-  {0x00, 0xDD, 0x01, "Ungermann-Bass"},
-  {0x02, 0x07, 0x01, "Racal InterLan"},
-  {0x02, 0x04, 0x06, "BBN internal usage"},
-  {0x02, 0x60, 0x86, "Satelcom MegaPac"},
-  {0x02, 0x60, 0x8C, "3Com"},
-  {0x02, 0xCF, 0x1F, "CMC"},
-  {0x08, 0x00, 0x02, "3Com"},
-  {0x08, 0x00, 0x03, "ACC"},
-  {0x08, 0x00, 0x05, "Symbolics"},
-  {0x08, 0x00, 0x08, "BBN"},
-  {0x08, 0x00, 0x09, "Hewlett-Packard"},
-  {0x08, 0x00, 0x0A, "Nestar Systems"},
-  {0x08, 0x00, 0x0B, "Unisys"},
-  {0x08, 0x00, 0x11, "Tektronix"},
-  {0x08, 0x00, 0x14, "Excelan"},
-  {0x08, 0x00, 0x17, "NSC"},
-  {0x08, 0x00, 0x1A, "Data General"},
-  {0x08, 0x00, 0x1B, "Data General"},
-  {0x08, 0x00, 0x1E, "Apollo"},
-  {0x08, 0x00, 0x20, "Sun"},
-  {0x08, 0x00, 0x22, "NBI"},
-  {0x08, 0x00, 0x25, "CDC"},
-  {0x08, 0x00, 0x26, "Norsk Data"},
-  {0x08, 0x00, 0x27, "PCS Computer Systems GmbH"},
-  {0x08, 0x00, 0x28, "Texas Instruments"},
-  {0x08, 0x00, 0x2B, "DEC"},
-  {0x08, 0x00, 0x2E, "Metaphor"},
-  {0x08, 0x00, 0x2F, "Prime Computer"},
-  {0x08, 0x00, 0x36, "Intergraph"},
-  {0x08, 0x00, 0x37, "Fujitsu-Xerox"},
-  {0x08, 0x00, 0x38, "Bull"},
-  {0x08, 0x00, 0x39, "Spider Systems"},
-  {0x08, 0x00, 0x41, "DCA Digital Comm. Assoc."},
-  {0x08, 0x00, 0x45, "Xylogics (?)"},
-  {0x08, 0x00, 0x46, "Sony"},
-  {0x08, 0x00, 0x47, "Sequent"},
-  {0x08, 0x00, 0x49, "Univation"},
-  {0x08, 0x00, 0x4C, "Encore"},
-  {0x08, 0x00, 0x4E, "BICC"},
-  {0x08, 0x00, 0x56, "Stanford University"},
-  {0x08, 0x00, 0x58, "DECsystem 20 (?)"},
-  {0x08, 0x00, 0x5A, "IBM"},
-  {0x08, 0x00, 0x67, "Comdesign"},
-  {0x08, 0x00, 0x68, "Ridge"},
-  {0x08, 0x00, 0x69, "Silicon Graphics"},
-  {0x08, 0x00, 0x6E, "Concurrent"},
-  {0x08, 0x00, 0x75, "DDE"},
-  {0x08, 0x00, 0x7C, "Vitalink"},
-  {0x08, 0x00, 0x80, "XIOS"},
-  {0x08, 0x00, 0x86, "Imagen/QMS"},
-  {0x08, 0x00, 0x87, "Xyplex"},
-  {0x08, 0x00, 0x89, "Kinetics"},
-  {0x08, 0x00, 0x8B, "Pyramid"},
-  {0x08, 0x00, 0x8D, "XyVision"},
-  {0x08, 0x00, 0x90, "Retix Inc"},
-  {0x48, 0x44, 0x53, "HDS (?)"},
-  {0x80, 0x00, 0x10, "AT&T"},
-  {0xAA, 0x00, 0x00, "DEC"},
-  {0xAA, 0x00, 0x01, "DEC"},
-  {0xAA, 0x00, 0x02, "DEC"},
-  {0xAA, 0x00, 0x03, "DEC"},
-  {0xAA, 0x00, 0x04, "DEC"},
-  {0x00, 0x00, 0x00, NULL}
+	{0x00, 0x00, 0x0C, "Cisco"},
+	{0x00, 0x00, 0x0E, "Fujitsu"},
+	{0x00, 0x00, 0x0F, "NeXT"},
+	{0x00, 0x00, 0x10, "Sytek"},
+	{0x00, 0x00, 0x1D, "Cabletron"},
+	{0x00, 0x00, 0x20, "DIAB"},
+	{0x00, 0x00, 0x22, "Visual Technology"},
+	{0x00, 0x00, 0x2A, "TRW"},
+	{0x00, 0x00, 0x32, "GPT Limited"},
+	{0x00, 0x00, 0x5A, "S & Koch"},
+	{0x00, 0x00, 0x5E, "IANA"},
+	{0x00, 0x00, 0x65, "Network General"},
+	{0x00, 0x00, 0x6B, "MIPS"},
+	{0x00, 0x00, 0x77, "MIPS"},
+	{0x00, 0x00, 0x7A, "Ardent"},
+	{0x00, 0x00, 0x89, "Cayman Systems"},
+	{0x00, 0x00, 0x93, "Proteon"},
+	{0x00, 0x00, 0x9F, "Ameristar Technology"},
+	{0x00, 0x00, 0xA2, "Wellfleet"},
+	{0x00, 0x00, 0xA3, "Network Application Technology"},
+	{0x00, 0x00, 0xA6, "Network General"},
+	{0x00, 0x00, 0xA7, "NCD"},
+	{0x00, 0x00, 0xA9, "Network Systems"},
+	{0x00, 0x00, 0xAA, "Xerox"},
+	{0x00, 0x00, 0xB3, "CIMLinc"},
+	{0x00, 0x00, 0xB7, "Dove Fastnet"},
+	{0x00, 0x00, 0xBC, "Allen-Bradley"},
+	{0x00, 0x00, 0xC0, "Western Digital"},
+	{0x00, 0x00, 0xC5, "Farallon"},
+	{0x00, 0x00, 0xC6, "Hewlett-Packard"},
+	{0x00, 0x00, 0xC8, "Altos"},
+	{0x00, 0x00, 0xC9, "Emulex"},
+	{0x00, 0x00, 0xD7, "Dartmouth College"},
+	{0x00, 0x00, 0xD8, "3Com (?)"},
+	{0x00, 0x00, 0xDD, "Gould"},
+	{0x00, 0x00, 0xDE, "Unigraph"},
+	{0x00, 0x00, 0xE2, "Acer Counterpoint"},
+	{0x00, 0x00, 0xEF, "Alantec"},
+	{0x00, 0x00, 0xFD, "High Level Hardware"},
+	{0x00, 0x01, 0x02, "BBN internal usage"},
+	{0x00, 0x20, 0xAF, "3Com"},
+	{0x00, 0x17, 0x00, "Kabel"},
+	{0x00, 0x80, 0x64, "Wyse Technology"},
+	{0x00, 0x80, 0x2B, "IMAC (?)"},
+	{0x00, 0x80, 0x2D, "Xylogics, Inc."},
+	{0x00, 0x80, 0x8C, "Frontier Software Development"},
+	{0x00, 0x80, 0xC2, "IEEE 802.1 Committee"},
+	{0x00, 0x80, 0xD3, "Shiva"},
+	{0x00, 0xAA, 0x00, "Intel"},
+	{0x00, 0xDD, 0x00, "Ungermann-Bass"},
+	{0x00, 0xDD, 0x01, "Ungermann-Bass"},
+	{0x02, 0x07, 0x01, "Racal InterLan"},
+	{0x02, 0x04, 0x06, "BBN internal usage"},
+	{0x02, 0x60, 0x86, "Satelcom MegaPac"},
+	{0x02, 0x60, 0x8C, "3Com"},
+	{0x02, 0xCF, 0x1F, "CMC"},
+	{0x08, 0x00, 0x02, "3Com"},
+	{0x08, 0x00, 0x03, "ACC"},
+	{0x08, 0x00, 0x05, "Symbolics"},
+	{0x08, 0x00, 0x08, "BBN"},
+	{0x08, 0x00, 0x09, "Hewlett-Packard"},
+	{0x08, 0x00, 0x0A, "Nestar Systems"},
+	{0x08, 0x00, 0x0B, "Unisys"},
+	{0x08, 0x00, 0x11, "Tektronix"},
+	{0x08, 0x00, 0x14, "Excelan"},
+	{0x08, 0x00, 0x17, "NSC"},
+	{0x08, 0x00, 0x1A, "Data General"},
+	{0x08, 0x00, 0x1B, "Data General"},
+	{0x08, 0x00, 0x1E, "Apollo"},
+	{0x08, 0x00, 0x20, "Sun"},
+	{0x08, 0x00, 0x22, "NBI"},
+	{0x08, 0x00, 0x25, "CDC"},
+	{0x08, 0x00, 0x26, "Norsk Data"},
+	{0x08, 0x00, 0x27, "PCS Computer Systems GmbH"},
+	{0x08, 0x00, 0x28, "Texas Instruments"},
+	{0x08, 0x00, 0x2B, "DEC"},
+	{0x08, 0x00, 0x2E, "Metaphor"},
+	{0x08, 0x00, 0x2F, "Prime Computer"},
+	{0x08, 0x00, 0x36, "Intergraph"},
+	{0x08, 0x00, 0x37, "Fujitsu-Xerox"},
+	{0x08, 0x00, 0x38, "Bull"},
+	{0x08, 0x00, 0x39, "Spider Systems"},
+	{0x08, 0x00, 0x41, "DCA Digital Comm. Assoc."},
+	{0x08, 0x00, 0x45, "Xylogics (?)"},
+	{0x08, 0x00, 0x46, "Sony"},
+	{0x08, 0x00, 0x47, "Sequent"},
+	{0x08, 0x00, 0x49, "Univation"},
+	{0x08, 0x00, 0x4C, "Encore"},
+	{0x08, 0x00, 0x4E, "BICC"},
+	{0x08, 0x00, 0x56, "Stanford University"},
+	{0x08, 0x00, 0x58, "DECsystem 20 (?)"},
+	{0x08, 0x00, 0x5A, "IBM"},
+	{0x08, 0x00, 0x67, "Comdesign"},
+	{0x08, 0x00, 0x68, "Ridge"},
+	{0x08, 0x00, 0x69, "Silicon Graphics"},
+	{0x08, 0x00, 0x6E, "Concurrent"},
+	{0x08, 0x00, 0x75, "DDE"},
+	{0x08, 0x00, 0x7C, "Vitalink"},
+	{0x08, 0x00, 0x80, "XIOS"},
+	{0x08, 0x00, 0x86, "Imagen/QMS"},
+	{0x08, 0x00, 0x87, "Xyplex"},
+	{0x08, 0x00, 0x89, "Kinetics"},
+	{0x08, 0x00, 0x8B, "Pyramid"},
+	{0x08, 0x00, 0x8D, "XyVision"},
+	{0x08, 0x00, 0x90, "Retix Inc"},
+	{0x48, 0x44, 0x53, "HDS (?)"},
+	{0x80, 0x00, 0x10, "AT&T"},
+	{0xAA, 0x00, 0x00, "DEC"},
+	{0xAA, 0x00, 0x01, "DEC"},
+	{0xAA, 0x00, 0x02, "DEC"},
+	{0xAA, 0x00, 0x03, "DEC"},
+	{0xAA, 0x00, 0x04, "DEC"},
+	{0x00, 0x00, 0x00, NULL}
 };
 
 /*

contrib/miscutil/assert_test.c

@@ -9,19 +9,19 @@
 #include "postgres.h"
 #include "assert_test.h"
 
-extern int assertTest(int val);
-extern int assertEnable(int val);
+extern int	assertTest(int val);
+extern int	assertEnable(int val);
 
 int
 assert_enable(int val)
 {
-    return assertEnable(val);
+	return assertEnable(val);
 }
 
 int
 assert_test(int val)
 {
-    return assertTest(val);
+	return assertTest(val);
 }
 
 /*
@@ -29,14 +29,14 @@ assert_test(int val)
 -- Enable/disable Postgres assert checking.
 --
 create function assert_enable(int4) returns int4
-    as '/usr/local/pgsql/lib/assert_test.so'
-    language 'C';
+	as '/usr/local/pgsql/lib/assert_test.so'
+	language 'C';
 
 -- Test Postgres assert checking.
 --
 create function assert_test(int4) returns int4
-    as '/usr/local/pgsql/lib/assert_test.so'
-    language 'C';
+	as '/usr/local/pgsql/lib/assert_test.so'
+	language 'C';
 
 */
 

contrib/miscutil/assert_test.h

 #ifndef ASSERT_TEST_H
 #define ASSERT_TEST_H
 
-int assert_enable(int val);
-int assert_test(int val);
+int			assert_enable(int val);
+int			assert_test(int val);
 
 #endif

contrib/miscutil/misc_utils.c

@@ -13,38 +13,38 @@
 
 #include "misc_utils.h"
 
-extern int ExecutorLimit(int limit);
+extern int	ExecutorLimit(int limit);
 extern void Async_Unlisten(char *relname, int pid);
 
 int
 query_limit(int limit)
 {
-    return ExecutorLimit(limit);
+	return ExecutorLimit(limit);
 }
 
 int
 backend_pid()
 {
-    return getpid();
+	return getpid();
 }
 
 int
 unlisten(char *relname)
 {
-    Async_Unlisten(relname, getpid());
-    return 0;
+	Async_Unlisten(relname, getpid());
+	return 0;
 }
 
 int
 max(int x, int y)
 {
-    return ((x > y) ? x : y);
+	return ((x > y) ? x : y);
 }
 
 int
 min(int x, int y)
 {
-    return ((x < y) ? x : y);
+	return ((x < y) ? x : y);
 }
 
 /* end of file */

contrib/miscutil/misc_utils.h

 #ifndef MISC_UTILS_H
 #define MISC_UTILS_H
 
-int query_limit(int limit);
-int backend_pid(void);
-int unlisten(char *relname);
-int max(int x, int y);
-int min(int x, int y);
+int			query_limit(int limit);
+int			backend_pid(void);
+int			unlisten(char *relname);
+int			max(int x, int y);
+int			min(int x, int y);
 
 #endif

contrib/pginterface/pginterface.c

@@ -30,7 +30,7 @@ static int	tuple;
 **		connectdb - returns PGconn structure
 **
 */
-PGconn	   *
+PGconn *
 connectdb(char *dbName,
 		  char *pghost,
 		  char *pgport,

contrib/sequence/set_sequence.c

@@ -12,30 +12,30 @@
 
 #include "set_sequence.h"
 
-extern int setval(struct varlena *seqin, int4 val);
+extern int	setval(struct varlena * seqin, int4 val);
 
 int
-set_currval(struct varlena *sequence, int4 nextval)
+set_currval(struct varlena * sequence, int4 nextval)
 {
-    return setval(sequence, nextval);
+	return setval(sequence, nextval);
 }
 
 int
-next_id(struct varlena *sequence)
+next_id(struct varlena * sequence)
 {
-    return nextval(sequence);
+	return nextval(sequence);
 }
 
 int
-last_id(struct varlena *sequence)
+last_id(struct varlena * sequence)
 {
-    return currval(sequence);
+	return currval(sequence);
 }
 
 int
-set_last_id(struct varlena *sequence, int4 nextval)
+set_last_id(struct varlena * sequence, int4 nextval)
 {
-    return setval(sequence, nextval);
+	return setval(sequence, nextval);
 }
 
 /* end of file */

contrib/sequence/set_sequence.h

 #ifndef SET_SEQUENCE_H
 #define SET_SEQUENCE_H
 
-int set_currval(struct varlena *sequence, int4 nextval);
-int next_id(struct varlena *sequence);
-int last_id(struct varlena *sequence);
-int set_last_id(struct varlena *sequence, int4 nextval);
+int			set_currval(struct varlena * sequence, int4 nextval);
+int			next_id(struct varlena * sequence);
+int			last_id(struct varlena * sequence);
+int			set_last_id(struct varlena * sequence, int4 nextval);
 
 #endif

contrib/soundex/soundex.c

@@ -13,7 +13,7 @@
 /* prototype for soundex function */
 char	   *soundex(char *instr, char *outstr);
 
-text	   *
+text *
 text_soundex(text *t)
 {
 	/* ABCDEFGHIJKLMNOPQRSTUVWXYZ */
@@ -47,7 +47,7 @@ text_soundex(text *t)
 	return (new_t);
 }
 
-char	   *
+char *
 soundex(char *instr, char *outstr)
 {								/* ABCDEFGHIJKLMNOPQRSTUVWXYZ */
 	char	   *table = "01230120022455012623010202";

contrib/spi/autoinc.c

@@ -2,9 +2,9 @@
 #include "executor/spi.h"		/* this is what you need to work with SPI */
 #include "commands/trigger.h"	/* -"- and triggers */
 
-HeapTuple		autoinc(void);
+HeapTuple	autoinc(void);
 
-extern int4	nextval(struct varlena * seqin);
+extern int4 nextval(struct varlena * seqin);
 
 HeapTuple
 autoinc()
@@ -28,73 +28,73 @@ autoinc()
 		elog(ERROR, "autoinc: can't process STATEMENT events");
 	if (TRIGGER_FIRED_AFTER(CurrentTriggerData->tg_event))
 		elog(ERROR, "autoinc: must be fired before event");
-	
+
 	if (TRIGGER_FIRED_BY_INSERT(CurrentTriggerData->tg_event))
 		rettuple = CurrentTriggerData->tg_trigtuple;
 	else if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event))
 		rettuple = CurrentTriggerData->tg_newtuple;
 	else
 		elog(ERROR, "autoinc: can't process DELETE events");
-	
+
 	rel = CurrentTriggerData->tg_relation;
 	relname = SPI_getrelname(rel);
-	
+
 	trigger = CurrentTriggerData->tg_trigger;
 
 	nargs = trigger->tgnargs;
 	if (nargs <= 0 || nargs % 2 != 0)
 		elog(ERROR, "autoinc (%s): even number gt 0 of arguments was expected", relname);
-	
+
 	args = trigger->tgargs;
 	tupdesc = rel->rd_att;
-	
+
 	CurrentTriggerData = NULL;
-	
-	chattrs = (int *) palloc (nargs/2 * sizeof (int));
-	newvals = (Datum *) palloc (nargs/2 * sizeof (Datum));
-	
-	for (i = 0; i < nargs; )
+
+	chattrs = (int *) palloc(nargs / 2 * sizeof(int));
+	newvals = (Datum *) palloc(nargs / 2 * sizeof(Datum));
+
+	for (i = 0; i < nargs;)
 	{
-		struct varlena	   *seqname;
-		int					attnum = SPI_fnumber (tupdesc, args[i]);
-		int32				val;
-		
-		if ( attnum < 0 )
+		struct varlena *seqname;
+		int			attnum = SPI_fnumber(tupdesc, args[i]);
+		int32		val;
+
+		if (attnum < 0)
 			elog(ERROR, "autoinc (%s): there is no attribute %s", relname, args[i]);
-		if (SPI_gettypeid (tupdesc, attnum) != INT4OID)
-			elog(ERROR, "autoinc (%s): attribute %s must be of INT4 type", 
-					relname, args[i]);
-		
-		val = DatumGetInt32 (SPI_getbinval (rettuple, tupdesc, attnum, &isnull));
-		
+		if (SPI_gettypeid(tupdesc, attnum) != INT4OID)
+			elog(ERROR, "autoinc (%s): attribute %s must be of INT4 type",
+				 relname, args[i]);
+
+		val = DatumGetInt32(SPI_getbinval(rettuple, tupdesc, attnum, &isnull));
+
 		if (!isnull && val != 0)
 		{
 			i += 2;
 			continue;
 		}
-		
+
 		i++;
 		chattrs[chnattrs] = attnum;
-		seqname = textin (args[i]);
-		newvals[chnattrs] = Int32GetDatum (nextval (seqname));
-		if ( DatumGetInt32 (newvals[chnattrs]) == 0 )
-			newvals[chnattrs] = Int32GetDatum (nextval (seqname));
-		pfree (seqname);
+		seqname = textin(args[i]);
+		newvals[chnattrs] = Int32GetDatum(nextval(seqname));
+		if (DatumGetInt32(newvals[chnattrs]) == 0)
+			newvals[chnattrs] = Int32GetDatum(nextval(seqname));
+		pfree(seqname);
 		chnattrs++;
 		i++;
 	}
-	
+
 	if (chnattrs > 0)
 	{
-		rettuple = SPI_modifytuple (rel, rettuple, chnattrs, chattrs, newvals, NULL);
-		if ( rettuple == NULL )
-			elog (ERROR, "autoinc (%s): %d returned by SPI_modifytuple",
-				relname, SPI_result);
+		rettuple = SPI_modifytuple(rel, rettuple, chnattrs, chattrs, newvals, NULL);
+		if (rettuple == NULL)
+			elog(ERROR, "autoinc (%s): %d returned by SPI_modifytuple",
+				 relname, SPI_result);
 	}
-	
-	pfree (relname);
-	pfree (chattrs);
-	pfree (newvals);
+
+	pfree(relname);
+	pfree(chattrs);
+	pfree(newvals);
 
 	return (rettuple);
 }

contrib/spi/insert_username.c

@@ -7,71 +7,71 @@
  */
 
 #include "executor/spi.h"		/* this is what you need to work with SPI */
-#include "commands/trigger.h"		/* -"- and triggers */
+#include "commands/trigger.h"	/* -"- and triggers */
 #include "miscadmin.h"			/* for GetPgUserName() */
 
-HeapTuple	insert_username (void);
+HeapTuple	insert_username(void);
 
 HeapTuple
-insert_username ()
+insert_username()
 {
-	Trigger		*trigger;		/* to get trigger name */
+	Trigger    *trigger;		/* to get trigger name */
 	int			nargs;			/* # of arguments */
 	Datum		newval;			/* new value of column */
-	char		**args;			/* arguments */
-	char		*relname;		/* triggered relation name */
+	char	  **args;			/* arguments */
+	char	   *relname;		/* triggered relation name */
 	Relation	rel;			/* triggered relation */
 	HeapTuple	rettuple = NULL;
 	TupleDesc	tupdesc;		/* tuple description */
 	int			attnum;
 
-				/* sanity checks from autoinc.c */		
+	/* sanity checks from autoinc.c */
 	if (!CurrentTriggerData)
 		elog(ERROR, "insert_username: triggers are not initialized");
 	if (TRIGGER_FIRED_FOR_STATEMENT(CurrentTriggerData->tg_event))
 		elog(ERROR, "insert_username: can't process STATEMENT events");
 	if (TRIGGER_FIRED_AFTER(CurrentTriggerData->tg_event))
 		elog(ERROR, "insert_username: must be fired before event");
-	
+
 	if (TRIGGER_FIRED_BY_INSERT(CurrentTriggerData->tg_event))
 		rettuple = CurrentTriggerData->tg_trigtuple;
 	else if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event))
 		rettuple = CurrentTriggerData->tg_newtuple;
 	else
 		elog(ERROR, "insert_username: can't process DELETE events");
-	
+
 	rel = CurrentTriggerData->tg_relation;
 	relname = SPI_getrelname(rel);
-	
+
 	trigger = CurrentTriggerData->tg_trigger;
 
 	nargs = trigger->tgnargs;
 	if (nargs != 1)
 		elog(ERROR, "insert_username (%s): one argument was expected", relname);
-	
+
 	args = trigger->tgargs;
 	tupdesc = rel->rd_att;
-	
+
 	CurrentTriggerData = NULL;
-	
-	attnum = SPI_fnumber (tupdesc, args[0]);
-		
-	if ( attnum < 0 )
+
+	attnum = SPI_fnumber(tupdesc, args[0]);
+
+	if (attnum < 0)
 		elog(ERROR, "insert_username (%s): there is no attribute %s", relname, args[0]);
-	if (SPI_gettypeid (tupdesc, attnum) != TEXTOID)
-		elog(ERROR, "insert_username (%s): attribute %s must be of TEXT type", 
-				relname, args[0]);
-
-				/* create fields containing name */
-	newval = PointerGetDatum (textin (GetPgUserName ()));
-
-				/* construct new tuple */
-	rettuple = SPI_modifytuple (rel, rettuple, 1, &attnum, &newval, NULL);
-	if ( rettuple == NULL )
-		elog (ERROR, "insert_username (%s): %d returned by SPI_modifytuple",
-			relname, SPI_result);
-	
-	pfree (relname);
+	if (SPI_gettypeid(tupdesc, attnum) != TEXTOID)
+		elog(ERROR, "insert_username (%s): attribute %s must be of TEXT type",
+			 relname, args[0]);
+
+	/* create fields containing name */
+	newval = PointerGetDatum(textin(GetPgUserName()));
+
+	/* construct new tuple */
+	rettuple = SPI_modifytuple(rel, rettuple, 1, &attnum, &newval, NULL);
+	if (rettuple == NULL)
+		elog(ERROR, "insert_username (%s): %d returned by SPI_modifytuple",
+			 relname, SPI_result);
+
+	pfree(relname);
 
 	return (rettuple);
 }

contrib/spi/refint.c

@@ -190,7 +190,7 @@ check_primary_key()
 	 * Ok, execute prepared plan.
 	 */
 	ret = SPI_execp(*(plan->splan), kvals, NULL, 1);
-		/* we have no NULLs - so we pass   ^^^^   here */
+	/* we have no NULLs - so we pass   ^^^^   here */
 
 	if (ret < 0)
 		elog(ERROR, "check_primary_key: SPI_execp returned %d", ret);
@@ -481,7 +481,7 @@ check_foreign_key()
 		relname = args[0];
 
 		ret = SPI_execp(plan->splan[r], kvals, NULL, tcount);
-			/* we have no NULLs - so we pass   ^^^^	 here */
+		/* we have no NULLs - so we pass   ^^^^  here */
 
 		if (ret < 0)
 			elog(ERROR, "check_foreign_key: SPI_execp returned %d", ret);

contrib/string/string_io.c

@@ -20,13 +20,13 @@
 #define ISO8859
 
 #define MIN(x, y)	((x) < (y) ? (x) : (y))
-#define	VALUE(char) 	((char) - '0')
-#define	DIGIT(val)	((val) + '0')
-#define ISOCTAL(c) 	(((c) >= '0') && ((c) <= '7'))
+#define VALUE(char)		((char) - '0')
+#define DIGIT(val)	((val) + '0')
+#define ISOCTAL(c)	(((c) >= '0') && ((c) <= '7'))
 #ifndef ISO8859
-#define NOTPRINTABLE(c)	(!isprint(c))
+#define NOTPRINTABLE(c) (!isprint(c))
 #else
-#define NOTPRINTABLE(c)	(!isprint(c) && ((c) < 0xa0))
+#define NOTPRINTABLE(c) (!isprint(c) && ((c) < 0xa0))
 #endif
 
 /*
@@ -50,103 +50,117 @@
 char *
 string_output(char *data, int size)
 {
-    register unsigned char c, *p, *r, *result;
-    register int l, len;
+	register unsigned char c,
+			   *p,
+			   *r,
+			   *result;
+	register int l,
+				len;
+
+	if (data == NULL)
+	{
+		result = (char *) palloc(2);
+		result[0] = '-';
+		result[1] = '\0';
+		return (result);
+	}
 
-    if (data == NULL) {
-	result = (char *) palloc(2);
-	result[0] = '-';
-	result[1] = '\0';
-	return (result);
-    }
-
-    if (size < 0) {
-	size = strlen(data);
-    }
-
-    /* adjust string length for escapes */
-    len = size;
-    for (p=data,l=size; l>0; p++,l--) {
-	switch (*p) {
-	  case '\\':
-	  case '"' :
-	  case '{':
-	  case '}':
-	  case '\b':
-	  case '\f':
-	  case '\n':
-	  case '\r':
-	  case '\t':
-	  case '\v':
-	    len++;
-	    break;
-	  default:
-	    if (NOTPRINTABLE(*p)) {
-		len += 3;
-	    }
+	if (size < 0)
+	{
+		size = strlen(data);
+	}
+
+	/* adjust string length for escapes */
+	len = size;
+	for (p = data, l = size; l > 0; p++, l--)
+	{
+		switch (*p)
+		{
+			case '\\':
+			case '"':
+			case '{':
+			case '}':
+			case '\b':
+			case '\f':
+			case '\n':
+			case '\r':
+			case '\t':
+			case '\v':
+				len++;
+				break;
+			default:
+				if (NOTPRINTABLE(*p))
+				{
+					len += 3;
+				}
+		}
 	}
-    }
-    len++;
-
-    result = (char *) palloc(len);
-
-    for (p=data,r=result,l=size; (l > 0) && (c = *p); p++,l--) {
-	switch (c) {
-	  case '\\':
-	  case '"' :
-	  case '{':
-	  case '}':
-	    *r++ = '\\';
-	    *r++ = c;
-	    break;
-	  case '\b':
-	    *r++ = '\\';
-	    *r++ = 'b';
-	    break;
-	  case '\f':
-	    *r++ = '\\';
-	    *r++ = 'f';
-	    break;
-	  case '\n':
-	    *r++ = '\\';
-	    *r++ = 'n';
-	    break;
-	  case '\r':
-	    *r++ = '\\';
-	    *r++ = 'r';
-	    break;
-	  case '\t':
-	    *r++ = '\\';
-	    *r++ = 't';
-	    break;
-	  case '\v':
-	    *r++ = '\\';
-	    *r++ = 'v';
-	    break;
-	  default:
-	    if (NOTPRINTABLE(c)) {
-		*r = '\\';
-		r += 3;
-		*r-- = DIGIT(c & 07);
-		c >>= 3;
-		*r-- = DIGIT(c & 07);
-		c >>= 3;
-		*r   = DIGIT(c & 03);
-		r += 3;
-	    } else {
-		*r++ = c;
-	    }
+	len++;
+
+	result = (char *) palloc(len);
+
+	for (p = data, r = result, l = size; (l > 0) && (c = *p); p++, l--)
+	{
+		switch (c)
+		{
+			case '\\':
+			case '"':
+			case '{':
+			case '}':
+				*r++ = '\\';
+				*r++ = c;
+				break;
+			case '\b':
+				*r++ = '\\';
+				*r++ = 'b';
+				break;
+			case '\f':
+				*r++ = '\\';
+				*r++ = 'f';
+				break;
+			case '\n':
+				*r++ = '\\';
+				*r++ = 'n';
+				break;
+			case '\r':
+				*r++ = '\\';
+				*r++ = 'r';
+				break;
+			case '\t':
+				*r++ = '\\';
+				*r++ = 't';
+				break;
+			case '\v':
+				*r++ = '\\';
+				*r++ = 'v';
+				break;
+			default:
+				if (NOTPRINTABLE(c))
+				{
+					*r = '\\';
+					r += 3;
+					*r-- = DIGIT(c & 07);
+					c >>= 3;
+					*r-- = DIGIT(c & 07);
+					c >>= 3;
+					*r = DIGIT(c & 03);
+					r += 3;
+				}
+				else
+				{
+					*r++ = c;
+				}
+		}
 	}
-    }
-    *r = '\0';
+	*r = '\0';
 
-    return((char *) result);
+	return ((char *) result);
 }
 
 /*
  * string_input() --
  *
- * This function accepts a C string in input and copies it into a new 
+ * This function accepts a C string in input and copies it into a new
  * object allocated with palloc() translating all escape sequences.
  * An optional header can be allocatd before the string, for example
  * to hold the length of a varlena object.
@@ -172,136 +186,155 @@ string_output(char *data, int size)
 char *
 string_input(char *str, int size, int hdrsize, int *rtn_size)
 {
-    register unsigned char *p, *r;
-    unsigned char *result;
-    int len;
-
-    if ((str == NULL) || (hdrsize < 0)) {
-	return (char *) NULL;
-    }
-
-    /* Compute result size */
-    len = strlen(str);
-    for (p=str; *p; ) {
-	if (*p++ == '\\') {
-	    if (ISOCTAL(*p)) {
-		if (ISOCTAL(*(p+1))) {
-		    p++;
-		    len--;
-		}
-		if (ISOCTAL(*(p+1))) {
-		    p++;
-		    len--;
+	register unsigned char *p,
+			   *r;
+	unsigned char *result;
+	int			len;
+
+	if ((str == NULL) || (hdrsize < 0))
+	{
+		return (char *) NULL;
+	}
+
+	/* Compute result size */
+	len = strlen(str);
+	for (p = str; *p;)
+	{
+		if (*p++ == '\\')
+		{
+			if (ISOCTAL(*p))
+			{
+				if (ISOCTAL(*(p + 1)))
+				{
+					p++;
+					len--;
+				}
+				if (ISOCTAL(*(p + 1)))
+				{
+					p++;
+					len--;
+				}
+			}
+			if (*p)
+				p++;
+			len--;
 		}
-	    }
-	    if (*p) p++;
-	    len--;
 	}
-    }
-
-    /* result has variable length */
-    if (size == 0) {
-	size = len+1;
-    } else
-
-    /* result has variable length with maximum size */
-    if (size < 0) {
-	size = MIN(len, - size)+1;
-    }
-
-    result = (char *) palloc(hdrsize+size);
-    memset(result, 0, hdrsize+size);
-    if (rtn_size) {
-	*rtn_size = size;
-    }
-
-    r = result + hdrsize;
-    for (p=str; *p; ) {
-	register unsigned char c;
-	if ((c = *p++) == '\\') {
-	    switch (c = *p++) {
-	      case '\0':
-		p--;
-		break;
-	      case '0':
-	      case '1':
-	      case '2':
-	      case '3':
-	      case '4':
-	      case '5':
-	      case '6':
-	      case '7':
-		c = VALUE(c);
-		if (isdigit(*p)) {
-		    c = (c<<3) + VALUE(*p++);
+
+	/* result has variable length */
+	if (size == 0)
+	{
+		size = len + 1;
+	}
+	else
+		/* result has variable length with maximum size */
+	if (size < 0)
+	{
+		size = MIN(len, -size) + 1;
+	}
+
+	result = (char *) palloc(hdrsize + size);
+	memset(result, 0, hdrsize + size);
+	if (rtn_size)
+	{
+		*rtn_size = size;
+	}
+
+	r = result + hdrsize;
+	for (p = str; *p;)
+	{
+		register unsigned char c;
+
+		if ((c = *p++) == '\\')
+		{
+			switch (c = *p++)
+			{
+				case '\0':
+					p--;
+					break;
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7':
+					c = VALUE(c);
+					if (isdigit(*p))
+					{
+						c = (c << 3) + VALUE(*p++);
+					}
+					if (isdigit(*p))
+					{
+						c = (c << 3) + VALUE(*p++);
+					}
+					*r++ = c;
+					break;
+				case 'b':
+					*r++ = '\b';
+					break;
+				case 'f':
+					*r++ = '\f';
+					break;
+				case 'n':
+					*r++ = '\n';
+					break;
+				case 'r':
+					*r++ = '\r';
+					break;
+				case 't':
+					*r++ = '\t';
+					break;
+				case 'v':
+					*r++ = '\v';
+					break;
+				default:
+					*r++ = c;
+			}
 		}
-		if (isdigit(*p)) {
-		    c = (c<<3) + VALUE(*p++);
+		else
+		{
+			*r++ = c;
 		}
-		*r++ = c;
-		break;
-	      case 'b':
-		*r++ = '\b';
-		break;
-	      case 'f':
-		*r++ = '\f';
-		break;
-	      case 'n':
-		*r++ = '\n';
-		break;
-	      case 'r':
-		*r++ = '\r';
-		break;
-	      case 't':
-		*r++ = '\t';
-		break;
-	      case 'v':
-		*r++ = '\v';
-		break;
-	      default:
-		*r++ = c;
-	    }
-	} else {
-	    *r++ = c;
 	}
-    }
 
-    return((char *) result);
+	return ((char *) result);
 }
 
 char *
 c_charout(int32 c)
 {
-    char str[2];
+	char		str[2];
 
-    str[0] = (char) c;
-    str[1] = '\0';
+	str[0] = (char) c;
+	str[1] = '\0';
 
-    return (string_output(str, 1));
+	return (string_output(str, 1));
 }
 
 char *
 c_char2out(uint16 s)
 {
-    return (string_output((char *) &s, 2));
+	return (string_output((char *) &s, 2));
 }
 
 char *
 c_char4out(uint32 s)
 {
-    return (string_output((char *) &s, 4));
+	return (string_output((char *) &s, 4));
 }
 
 char *
 c_char8out(char *s)
 {
-    return (string_output(s, 8));
+	return (string_output(s, 8));
 }
 
 char *
 c_char16out(char *s)
 {
-    return (string_output(s, 16));
+	return (string_output(s, 16));
 }
 
 /*
@@ -309,16 +342,17 @@ c_char16out(char *s)
  */
 
 char *
-c_textout(struct varlena *vlena)
+c_textout(struct varlena * vlena)
 {
-    int len = 0;
-    char *s = NULL;
-
-    if (vlena) {
-	len = VARSIZE(vlena) - VARHDRSZ;
-	s = VARDATA(vlena);
-    }
-    return (string_output(s, len));
+	int			len = 0;
+	char	   *s = NULL;
+
+	if (vlena)
+	{
+		len = VARSIZE(vlena) - VARHDRSZ;
+		s = VARDATA(vlena);
+	}
+	return (string_output(s, len));
 }
 
 /*
@@ -328,37 +362,40 @@ c_textout(struct varlena *vlena)
 char *
 c_varcharout(char *s)
 {
-    int len = 0;
+	int			len = 0;
 
-    if (s) {
-	len = *(int32*)s - 4;
-	s += 4;
-    }
-    return (string_output(s, len));
+	if (s)
+	{
+		len = *(int32 *) s - 4;
+		s += 4;
+	}
+	return (string_output(s, len));
 }
 
 #if 0
 struct varlena *
 c_textin(char *str)
 {
-    struct varlena *result;
-    int len;
+	struct varlena *result;
+	int			len;
 
-    if (str == NULL) {
-	return ((struct varlena *) NULL);
-    }
+	if (str == NULL)
+	{
+		return ((struct varlena *) NULL);
+	}
 
-    result = (struct varlena *) string_input(str, 0, VARHDRSZ, &len);
-    VARSIZE(result) = len;
+	result = (struct varlena *) string_input(str, 0, VARHDRSZ, &len);
+	VARSIZE(result) = len;
 
-    return (result);
+	return (result);
 }
 
 char *
 c_char16in(char *str)
 {
-    return (string_input(str, 16, 0, NULL));
+	return (string_input(str, 16, 0, NULL));
 }
+
 #endif
 
 

contrib/string/string_io.h

 #ifndef STRING_IO_H
 #define STRING_IO_H
 
-char *string_output(char *data, int size);
-char *string_input(char *str, int size, int hdrsize, int *rtn_size);
-char *c_charout(int32 c);
-char *c_char2out(uint16 s);
-char *c_char4out(uint32 s);
-char *c_char8out(char *s);
-char *c_char16out(char *s);
-char *c_textout(struct varlena *vlena);
-char *c_varcharout(char *s);
+char	   *string_output(char *data, int size);
+char	   *string_input(char *str, int size, int hdrsize, int *rtn_size);
+char	   *c_charout(int32 c);
+char	   *c_char2out(uint16 s);
+char	   *c_char4out(uint32 s);
+char	   *c_char8out(char *s);
+char	   *c_char16out(char *s);
+char	   *c_textout(struct varlena * vlena);
+char	   *c_varcharout(char *s);
 
 #if 0
 struct varlena *c_textin(char *str);
-char *c_char16in(char *str);
+char	   *c_char16in(char *str);
+
 #endif
 
 #endif

contrib/userlock/user_locks.c

@@ -22,79 +22,80 @@
 
 #include "user_locks.h"
 
-#define USER_LOCKS_TABLE_ID	0
+#define USER_LOCKS_TABLE_ID 0
 
-extern Oid MyDatabaseId;
+extern Oid	MyDatabaseId;
 
 int
 user_lock(unsigned int id1, unsigned int id2, LOCKT lockt)
 {
-    LOCKTAG tag;
+	LOCKTAG		tag;
 
-    memset(&tag,0,sizeof(LOCKTAG));
-    tag.relId = 0;
-    tag.dbId = MyDatabaseId;
-    tag.tupleId.ip_blkid.bi_hi = id2 >> 16;
-    tag.tupleId.ip_blkid.bi_lo = id2 & 0xffff;
-    tag.tupleId.ip_posid = (unsigned short) (id1 & 0xffff);
+	memset(&tag, 0, sizeof(LOCKTAG));
+	tag.relId = 0;
+	tag.dbId = MyDatabaseId;
+	tag.tupleId.ip_blkid.bi_hi = id2 >> 16;
+	tag.tupleId.ip_blkid.bi_lo = id2 & 0xffff;
+	tag.tupleId.ip_posid = (unsigned short) (id1 & 0xffff);
 
-    return LockAcquire(USER_LOCKS_TABLE_ID, &tag, lockt);
+	return LockAcquire(USER_LOCKS_TABLE_ID, &tag, lockt);
 }
 
 int
 user_unlock(unsigned int id1, unsigned int id2, LOCKT lockt)
 {
-    LOCKTAG tag;
-
-    memset(&tag, 0,sizeof(LOCKTAG));
-    tag.relId = 0;
-    tag.dbId = MyDatabaseId;
-    tag.tupleId.ip_blkid.bi_hi = id2 >> 16;
-    tag.tupleId.ip_blkid.bi_lo = id2 & 0xffff;
-    tag.tupleId.ip_posid = (unsigned short) (id1 & 0xffff);
-    
-    return LockRelease(USER_LOCKS_TABLE_ID, &tag, lockt);
+	LOCKTAG		tag;
+
+	memset(&tag, 0, sizeof(LOCKTAG));
+	tag.relId = 0;
+	tag.dbId = MyDatabaseId;
+	tag.tupleId.ip_blkid.bi_hi = id2 >> 16;
+	tag.tupleId.ip_blkid.bi_lo = id2 & 0xffff;
+	tag.tupleId.ip_posid = (unsigned short) (id1 & 0xffff);
+
+	return LockRelease(USER_LOCKS_TABLE_ID, &tag, lockt);
 }
 
 int
 user_write_lock(unsigned int id1, unsigned int id2)
 {
-    return user_lock(id1, id2, WRITE_LOCK);
+	return user_lock(id1, id2, WRITE_LOCK);
 }
 
 
 int
 user_write_unlock(unsigned int id1, unsigned int id2)
 {
-    return user_unlock(id1, id2, WRITE_LOCK);
+	return user_unlock(id1, id2, WRITE_LOCK);
 }
 
 int
 user_write_lock_oid(Oid oid)
 {
-    return user_lock(0, oid, WRITE_LOCK);
+	return user_lock(0, oid, WRITE_LOCK);
 }
 
 int
 user_write_unlock_oid(Oid oid)
 {
-    return user_unlock(0, oid, WRITE_LOCK);
+	return user_unlock(0, oid, WRITE_LOCK);
 }
 
 int
 user_unlock_all()
 {
-    PROC	*proc;
-    SHMEM_OFFSET location;
-
-    ShmemPIDLookup(getpid(),&location);
-    if (location == INVALID_OFFSET) {
-	elog(NOTICE, "UserUnlockAll: unable to get proc ptr");
-	return -1;
-    }
-
-    proc = (PROC *) MAKE_PTR(location);
-    return LockReleaseAll(USER_LOCKS_TABLE_ID, &proc->lockQueue);
+	PROC	   *proc;
+	SHMEM_OFFSET location;
+
+	ShmemPIDLookup(getpid(), &location);
+	if (location == INVALID_OFFSET)
+	{
+		elog(NOTICE, "UserUnlockAll: unable to get proc ptr");
+		return -1;
+	}
+
+	proc = (PROC *) MAKE_PTR(location);
+	return LockReleaseAll(USER_LOCKS_TABLE_ID, &proc->lockQueue);
 }
 
 /* end of file */

contrib/userlock/user_locks.h

 #ifndef USER_LOCKS_H
 #define USER_LOCKS_H
 
-int user_lock(unsigned int id1, unsigned int id2, LOCKT lockt);
-int user_unlock(unsigned int id1, unsigned int id2, LOCKT lockt);
-int user_write_lock(unsigned int id1, unsigned int id2);
-int user_write_unlock(unsigned int id1, unsigned int id2);
-int user_write_lock_oid(Oid oid);
-int user_write_unlock_oid(Oid oid);
-int user_unlock_all(void);
+int			user_lock(unsigned int id1, unsigned int id2, LOCKT lockt);
+int			user_unlock(unsigned int id1, unsigned int id2, LOCKT lockt);
+int			user_write_lock(unsigned int id1, unsigned int id2);
+int			user_write_unlock(unsigned int id1, unsigned int id2);
+int			user_write_lock_oid(Oid oid);
+int			user_write_unlock_oid(Oid oid);
+int			user_unlock_all(void);
 
 #endif

src/backend/access/common/heaptuple.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.36 1998/02/11 19:09:21 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.37 1998/02/26 04:29:15 momjian Exp $
  *
  * NOTES
  *	  The old interface functions have been converted to macros
@@ -34,14 +34,14 @@
 #endif
 
 /* Used by heap_getattr() macro, for speed */
-long heap_sysoffset[] = {
+long		heap_sysoffset[] = {
 /* Only the first one is pass-by-ref, and is handled specially in the macro */
-		offsetof(HeapTupleData, t_ctid),		
-		offsetof(HeapTupleData, t_oid),
-		offsetof(HeapTupleData, t_xmin),
-		offsetof(HeapTupleData, t_cmin),
-		offsetof(HeapTupleData, t_xmax),
-		offsetof(HeapTupleData, t_cmax)
+	offsetof(HeapTupleData, t_ctid),
+	offsetof(HeapTupleData, t_oid),
+	offsetof(HeapTupleData, t_xmin),
+	offsetof(HeapTupleData, t_cmin),
+	offsetof(HeapTupleData, t_xmax),
+	offsetof(HeapTupleData, t_cmax)
 };
 
 /* ----------------------------------------------------------------
@@ -350,7 +350,7 @@ heap_getsysattr(HeapTuple tup, Buffer b, int attnum)
 {
 	switch (attnum)
 	{
-		case  SelfItemPointerAttributeNumber:
+			case SelfItemPointerAttributeNumber:
 			return ((Datum) &tup->t_ctid);
 		case ObjectIdAttributeNumber:
 			return ((Datum) (long) tup->t_oid);
@@ -389,16 +389,16 @@ heap_getsysattr(HeapTuple tup, Buffer b, int attnum)
  */
 Datum
 nocachegetattr(HeapTuple tup,
-			int attnum,
-			TupleDesc tupleDesc,
-			bool *isnull)
+			   int attnum,
+			   TupleDesc tupleDesc,
+			   bool *isnull)
 {
 	char	   *tp;				/* ptr to att in tuple */
-	bits8	   *bp = tup->t_bits; /* ptr to att in tuple */
+	bits8	   *bp = tup->t_bits;		/* ptr to att in tuple */
 	int			slow;			/* do we have to walk nulls? */
 	AttributeTupleForm *att = tupleDesc->attrs;
 
-	
+
 #if IN_MACRO
 /* This is handled in the macro */
 	Assert(attnum > 0);
@@ -430,6 +430,7 @@ nocachegetattr(HeapTuple tup,
 		}
 		else if (attnum == 0)
 		{
+
 			/*
 			 * first attribute is always at position zero
 			 */
@@ -470,11 +471,11 @@ nocachegetattr(HeapTuple tup,
 		 * ----------------
 		 */
 		{
-			int i = 0; /* current offset in bp */
-			int mask;	/* bit in byte we're looking at */
-			char n;	/* current byte in bp */
-			int byte,
-						 finalbit;
+			int			i = 0;	/* current offset in bp */
+			int			mask;	/* bit in byte we're looking at */
+			char		n;		/* current byte in bp */
+			int			byte,
+						finalbit;
 
 			byte = attnum >> 3;
 			finalbit = attnum & 0x07;
@@ -486,14 +487,14 @@ nocachegetattr(HeapTuple tup,
 				{
 					/* check for nulls in any "earlier" bytes */
 					if ((~n) != 0)
-						slow=1;
+						slow = 1;
 				}
 				else
 				{
 					/* check for nulls "before" final bit of last byte */
 					mask = (1 << finalbit) - 1;
 					if ((~n) & mask)
-						slow=1;
+						slow = 1;
 				}
 			}
 		}
@@ -508,8 +509,8 @@ nocachegetattr(HeapTuple tup,
 	{
 		if (att[attnum]->attcacheoff != -1)
 		{
-			return (Datum)fetchatt(&(att[attnum]),
-						tp + att[attnum]->attcacheoff);
+			return (Datum) fetchatt(&(att[attnum]),
+									tp + att[attnum]->attcacheoff);
 		}
 		else if (attnum == 0)
 		{
@@ -517,11 +518,11 @@ nocachegetattr(HeapTuple tup,
 		}
 		else if (!HeapTupleAllFixed(tup))
 		{
-			int j = 0;
+			int			j = 0;
 
 			/*
-			 *	In for(), we make this <= and not < because we want to
-			 *	test if we can go past it in initializing offsets.
+			 * In for(), we make this <= and not < because we want to test
+			 * if we can go past it in initializing offsets.
 			 */
 			for (j = 0; j <= attnum && !slow; j++)
 				if (att[j]->attlen < 1 && !VARLENA_FIXED_SIZE(att[j]))
@@ -536,8 +537,8 @@ nocachegetattr(HeapTuple tup,
 	 */
 	if (!slow)
 	{
-		int j = 1;
-		long off;
+		int			j = 1;
+		long		off;
 
 		/*
 		 * need to set cache for some atts
@@ -554,13 +555,14 @@ nocachegetattr(HeapTuple tup,
 			off = att[j - 1]->attcacheoff + att[j - 1]->atttypmod;
 
 		for (; j <= attnum ||
-				/* Can we compute more?  We will probably need them */
-				(j < tup->t_natts &&
-				 att[j]->attcacheoff == -1 &&
-				 (HeapTupleNoNulls(tup) || !att_isnull(j, bp)) &&
-				 (HeapTupleAllFixed(tup)||
-					 att[j]->attlen > 0 || VARLENA_FIXED_SIZE(att[j]))); j++)
+		/* Can we compute more?  We will probably need them */
+			 (j < tup->t_natts &&
+			  att[j]->attcacheoff == -1 &&
+			  (HeapTupleNoNulls(tup) || !att_isnull(j, bp)) &&
+			  (HeapTupleAllFixed(tup) ||
+			   att[j]->attlen > 0 || VARLENA_FIXED_SIZE(att[j]))); j++)
 		{
+
 			/*
 			 * Fix me when going to a machine with more than a four-byte
 			 * word!
@@ -605,7 +607,7 @@ nocachegetattr(HeapTuple tup,
 					break;
 				case -1:
 					Assert(!VARLENA_FIXED_SIZE(att[j]) ||
-							att[j]->atttypmod == VARSIZE(tp + off));
+						   att[j]->atttypmod == VARSIZE(tp + off));
 					off += VARSIZE(tp + off);
 					break;
 				default:
@@ -618,9 +620,9 @@ nocachegetattr(HeapTuple tup,
 	}
 	else
 	{
-		bool usecache = true;
-		int off = 0;
-		int i;
+		bool		usecache = true;
+		int			off = 0;
+		int			i;
 
 		/*
 		 * Now we know that we have to walk the tuple CAREFULLY.
@@ -665,7 +667,7 @@ nocachegetattr(HeapTuple tup,
 					default:
 						if (att[i]->attlen < sizeof(int32))
 							elog(ERROR,
-								 "nocachegetattr2: attribute %d has len %d",
+							  "nocachegetattr2: attribute %d has len %d",
 								 i, att[i]->attlen);
 						if (att[i]->attalign == 'd')
 							off = DOUBLEALIGN(off);
@@ -690,7 +692,7 @@ nocachegetattr(HeapTuple tup,
 					break;
 				case -1:
 					Assert(!VARLENA_FIXED_SIZE(att[i]) ||
-							att[i]->atttypmod == VARSIZE(tp + off));
+						   att[i]->atttypmod == VARSIZE(tp + off));
 					off += VARSIZE(tp + off);
 					if (!VARLENA_FIXED_SIZE(att[i]))
 						usecache = false;
@@ -965,9 +967,9 @@ heap_modifytuple(HeapTuple tuple,
 	 * ----------------
 	 */
 	infomask = newTuple->t_infomask;
-	memmove((char *) &newTuple->t_oid, /* XXX */
+	memmove((char *) &newTuple->t_oid,	/* XXX */
 			(char *) &tuple->t_oid,
-			((char *) &tuple->t_hoff - (char *) &tuple->t_oid));	/* XXX */
+			((char *) &tuple->t_hoff - (char *) &tuple->t_oid));		/* XXX */
 	newTuple->t_infomask = infomask;
 	newTuple->t_natts = numberOfAttributes;		/* fix t_natts just in
 												 * case */
@@ -993,7 +995,7 @@ heap_addheader(uint32 natts,	/* max domain index */
 			   int structlen,	/* its length */
 			   char *structure) /* pointer to the struct */
 {
-	char 		*tp;			/* tuple data pointer */
+	char	   *tp;				/* tuple data pointer */
 	HeapTuple	tup;
 	long		len;
 	int			hoff;
@@ -1018,4 +1020,3 @@ heap_addheader(uint32 natts,	/* max domain index */
 
 	return (tup);
 }
-

src/backend/access/common/indextuple.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.27 1998/02/11 19:09:23 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.28 1998/02/26 04:29:18 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -41,7 +41,7 @@ index_formtuple(TupleDesc tupleDescriptor,
 				Datum value[],
 				char null[])
 {
-	char *tp;			/* tuple pointer */
+	char	   *tp;				/* tuple pointer */
 	IndexTuple	tuple;			/* return tuple */
 	Size		size,
 				hoff;
@@ -133,14 +133,14 @@ index_formtuple(TupleDesc tupleDescriptor,
  */
 Datum
 nocache_index_getattr(IndexTuple tup,
-			 int attnum,
-			 TupleDesc tupleDesc,
-			 bool *isnull)
+					  int attnum,
+					  TupleDesc tupleDesc,
+					  bool *isnull)
 {
-	char *tp;			/* ptr to att in tuple */
-	char *bp = NULL;	/* ptr to att in tuple */
+	char	   *tp;				/* ptr to att in tuple */
+	char	   *bp = NULL;		/* ptr to att in tuple */
 	int			slow;			/* do we have to walk nulls? */
-	int data_off;		/* tuple data offset */
+	int			data_off;		/* tuple data offset */
 	AttributeTupleForm *att = tupleDesc->attrs;
 
 	/* ----------------
@@ -174,7 +174,7 @@ nocache_index_getattr(IndexTuple tup,
 
 #ifdef IN_MACRO
 /* This is handled in the macro */
-	
+
 		/* first attribute is always at position zero */
 
 		if (attnum == 1)
@@ -184,8 +184,8 @@ nocache_index_getattr(IndexTuple tup,
 		if (att[attnum]->attcacheoff != -1)
 		{
 			return (Datum) fetchatt(&(att[attnum]),
-							 (char *) tup + data_off +
-							 att[attnum]->attcacheoff);
+									(char *) tup + data_off +
+									att[attnum]->attcacheoff);
 		}
 #endif
 
@@ -206,11 +206,11 @@ nocache_index_getattr(IndexTuple tup,
 												 * here! */
 #ifdef IN_MACRO
 /* This is handled in the macro */
-		
+
 		if (att_isnull(attnum, bp))
 		{
 			*isnull = true;
-			return (Datum)NULL;
+			return (Datum) NULL;
 		}
 #endif
 
@@ -219,11 +219,11 @@ nocache_index_getattr(IndexTuple tup,
 		 * ----------------
 		 */
 		{
-			int i = 0; /* current offset in bp */
-			int mask;	/* bit in byte we're looking at */
-			char n;	/* current byte in bp */
-			int byte,
-						 finalbit;
+			int			i = 0;	/* current offset in bp */
+			int			mask;	/* bit in byte we're looking at */
+			char		n;		/* current byte in bp */
+			int			byte,
+						finalbit;
 
 			byte = attnum >> 3;
 			finalbit = attnum & 0x07;
@@ -235,14 +235,14 @@ nocache_index_getattr(IndexTuple tup,
 				{
 					/* check for nulls in any "earlier" bytes */
 					if ((~n) != 0)
-						slow=1;
+						slow = 1;
 				}
 				else
 				{
 					/* check for nulls "before" final bit of last byte */
 					mask = (1 << finalbit) - 1;
 					if ((~n) & mask)
-						slow=1;
+						slow = 1;
 				}
 			}
 		}
@@ -257,7 +257,7 @@ nocache_index_getattr(IndexTuple tup,
 		if (att[attnum]->attcacheoff != -1)
 		{
 			return (Datum) fetchatt(&(att[attnum]),
-							 tp + att[attnum]->attcacheoff);
+									tp + att[attnum]->attcacheoff);
 		}
 		else if (attnum == 0)
 		{
@@ -265,7 +265,7 @@ nocache_index_getattr(IndexTuple tup,
 		}
 		else if (!IndexTupleAllFixed(tup))
 		{
-			int j = 0;
+			int			j = 0;
 
 			for (j = 0; j < attnum && !slow; j++)
 				if (att[j]->attlen < 1 && !VARLENA_FIXED_SIZE(att[j]))
@@ -281,8 +281,8 @@ nocache_index_getattr(IndexTuple tup,
 
 	if (!slow)
 	{
-		int j = 1;
-		long off;
+		int			j = 1;
+		long		off;
 
 		/*
 		 * need to set cache for some atts
@@ -293,13 +293,14 @@ nocache_index_getattr(IndexTuple tup,
 		while (att[j]->attcacheoff != -1)
 			j++;
 
-		if (!VARLENA_FIXED_SIZE(att[j-1]))
+		if (!VARLENA_FIXED_SIZE(att[j - 1]))
 			off = att[j - 1]->attcacheoff + att[j - 1]->attlen;
 		else
 			off = att[j - 1]->attcacheoff + att[j - 1]->atttypmod;
 
 		for (; j < attnum + 1; j++)
 		{
+
 			/*
 			 * Fix me when going to a machine with more than a four-byte
 			 * word!
@@ -346,9 +347,9 @@ nocache_index_getattr(IndexTuple tup,
 	}
 	else
 	{
-		bool usecache = true;
-		int off = 0;
-		int i;
+		bool		usecache = true;
+		int			off = 0;
+		int			i;
 
 		/*
 		 * Now we know that we have to walk the tuple CAREFULLY.
@@ -387,7 +388,7 @@ nocache_index_getattr(IndexTuple tup,
 					default:
 						if (att[i]->attlen < sizeof(int32))
 							elog(ERROR,
-								 "nocachegetiattr2: attribute %d has len %d",
+							 "nocachegetiattr2: attribute %d has len %d",
 								 i, att[i]->attlen);
 						if (att[i]->attalign == 'd')
 							off = DOUBLEALIGN(off);
@@ -412,7 +413,7 @@ nocache_index_getattr(IndexTuple tup,
 					break;
 				case -1:
 					Assert(!VARLENA_FIXED_SIZE(att[i]) ||
-							att[i]->atttypmod == VARSIZE(tp + off));
+						   att[i]->atttypmod == VARSIZE(tp + off));
 					off += VARSIZE(tp + off);
 					if (!VARLENA_FIXED_SIZE(att[i]))
 						usecache = false;

src/backend/access/common/printtup.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.26 1998/02/11 19:09:25 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.27 1998/02/26 04:29:20 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -124,7 +124,7 @@ printtup(HeapTuple tuple, TupleDesc typeinfo)
 		{
 			outputstr = fmgr(typoutput, attr,
 							 gettypelem(typeinfo->attrs[i]->atttypid),
-										typeinfo->attrs[i]->atttypmod);
+							 typeinfo->attrs[i]->atttypmod);
 			pq_putint(strlen(outputstr) + VARHDRSZ, VARHDRSZ);
 			pq_putnchar(outputstr, strlen(outputstr));
 			pfree(outputstr);
@@ -176,8 +176,8 @@ showatts(char *name, TupleDesc tupleDesc)
 void
 debugtup(HeapTuple tuple, TupleDesc typeinfo)
 {
-	int i;
-	Datum	    attr;
+	int			i;
+	Datum		attr;
 	char	   *value;
 	bool		isnull;
 	Oid			typoutput;
@@ -191,7 +191,7 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo)
 		{
 			value = fmgr(typoutput, attr,
 						 gettypelem(typeinfo->attrs[i]->atttypid),
-									typeinfo->attrs[i]->atttypmod);
+						 typeinfo->attrs[i]->atttypmod);
 			printatt((unsigned) i + 1, typeinfo->attrs[i], value);
 			pfree(value);
 		}
@@ -313,7 +313,7 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo)
 					pq_putnchar(DatumGetPointer(attr), len);
 #ifdef IPORTAL_DEBUG
 					fprintf(stderr, "byref length %d data %x\n", len,
-												DatumGetPointer(attr));
+							DatumGetPointer(attr));
 #endif
 				}
 			}

src/backend/access/common/tupdesc.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.35 1998/02/10 16:02:46 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.36 1998/02/26 04:29:22 momjian Exp $
  *
  * NOTES
  *	  some of the executor utility code such as "ExecTypeFromTL" should be
@@ -306,7 +306,7 @@ TupleDescInitEntry(TupleDesc desc,
 	att->attnum = attributeNumber;
 	att->attnelems = attdim;
 	att->attisset = attisset;
-	
+
 	att->attnotnull = false;
 	att->atthasdef = false;
 
@@ -487,7 +487,7 @@ BuildDescForRelation(List *schema, char *relname)
 		if (arry != NIL)
 		{
 			/* array of XXX is _XXX */
-			sprintf(typename, "_%.*s", NAMEDATALEN-2,entry->typename->name);
+			sprintf(typename, "_%.*s", NAMEDATALEN - 2, entry->typename->name);
 			attdim = length(arry);
 		}
 		else

src/backend/access/hash/hash.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.17 1997/11/20 23:19:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.18 1998/02/26 04:29:28 momjian Exp $
  *
  * NOTES
  *	  This file contains only the public interface routines.
@@ -306,7 +306,7 @@ hashinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relatio
 /*
  *	hashgettuple() -- Get the next tuple in the scan.
  */
-char	   *
+char *
 hashgettuple(IndexScanDesc scan, ScanDirection dir)
 {
 	RetrieveIndexResult res;
@@ -329,7 +329,7 @@ hashgettuple(IndexScanDesc scan, ScanDirection dir)
 /*
  *	hashbeginscan() -- start a scan on a hash index
  */
-char	   *
+char *
 hashbeginscan(Relation rel,
 			  bool fromEnd,
 			  uint16 keysz,

src/backend/access/heap/heapam.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.26 1998/02/11 19:09:30 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.27 1998/02/26 04:29:31 momjian Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -654,6 +654,7 @@ heap_beginscan(Relation relation,
 	sdesc->rs_rd = relation;
 
 	if (nkeys)
+
 		/*
 		 * we do this here instead of in initsdesc() because heap_rescan
 		 * also calls initsdesc() and we don't want to allocate memory
@@ -1303,7 +1304,7 @@ heap_replace(Relation relation, ItemPointer otid, HeapTuple tup)
 	Page		dp;
 	Buffer		buffer;
 	HeapTuple	tuple;
-	
+
 	/* ----------------
 	 *	increment access statistics
 	 * ----------------
@@ -1375,13 +1376,13 @@ heap_replace(Relation relation, ItemPointer otid, HeapTuple tup)
 	 * ----------------
 	 */
 	HeapTupleSatisfies(lp,
-						 relation,
-						 buffer,
-						 (PageHeader) dp,
-						 false,
-						 0,
-						 (ScanKey) NULL,
-						 tuple);
+					   relation,
+					   buffer,
+					   (PageHeader) dp,
+					   false,
+					   0,
+					   (ScanKey) NULL,
+					   tuple);
 	if (!tuple)
 	{
 		ReleaseBuffer(buffer);

src/backend/access/index/istrat.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.16 1998/01/15 19:42:02 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.17 1998/02/26 04:29:36 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -242,17 +242,17 @@ StrategyTermEvaluate(StrategyTerm term,
 		switch (operator->flags ^ entry->sk_flags)
 		{
 			case 0x0:
-				tmpres = (long) FMGR_PTR2(&entry->sk_func, 
+				tmpres = (long) FMGR_PTR2(&entry->sk_func,
 										  left, right);
 				break;
 
 			case SK_NEGATE:
-				tmpres = (long) !FMGR_PTR2(&entry->sk_func, 
+				tmpres = (long) !FMGR_PTR2(&entry->sk_func,
 										   left, right);
 				break;
 
 			case SK_COMMUTE:
-				tmpres = (long) FMGR_PTR2(&entry->sk_func, 
+				tmpres = (long) FMGR_PTR2(&entry->sk_func,
 										  right, left);
 				break;
 

src/backend/access/nbtree/nbtree.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.24 1997/11/20 23:20:21 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.25 1998/02/26 04:29:44 momjian Exp $
  *
  * NOTES
  *	  This file contains only the public interface routines.
@@ -389,7 +389,7 @@ btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
-char	   *
+char *
 btgettuple(IndexScanDesc scan, ScanDirection dir)
 {
 	RetrieveIndexResult res;
@@ -411,7 +411,7 @@ btgettuple(IndexScanDesc scan, ScanDirection dir)
 /*
  *	btbeginscan() -- start a scan on a btree index
  */
-char	   *
+char *
 btbeginscan(Relation rel, bool fromEnd, uint16 keysz, ScanKey scankey)
 {
 	IndexScanDesc scan;

src/backend/access/nbtree/nbtsearch.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.30 1998/01/15 19:42:13 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.31 1998/02/26 04:29:50 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -197,12 +197,11 @@ _bt_moveright(Relation rel,
 			 * if number of attrs > keysize. Example: (2,0) - last items
 			 * on this page, (2,1) - first item on next page (hikey), our
 			 * scankey is x = 2. Scankey == (2,1) because of we compare
-			 * first attrs only, but we shouldn't to move right of here. 
-			 * 			- vadim 04/15/97
-			 * 
+			 * first attrs only, but we shouldn't to move right of here. -
+			 * vadim 04/15/97
+			 *
 			 * Also, if this page is not LEAF one (and # of attrs > keysize)
-			 * then we can't move too.
-			 *			- vadim 10/22/97
+			 * then we can't move too. - vadim 10/22/97
 			 */
 
 			if (_bt_skeycmp(rel, keysz, scankey, page, hikey,

src/backend/access/nbtree/nbtsort.c

@@ -5,7 +5,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Id: nbtsort.c,v 1.28 1998/02/21 19:23:14 scrappy Exp $
+ *	  $Id: nbtsort.c,v 1.29 1998/02/26 04:29:54 momjian Exp $
  *
  * NOTES
  *
@@ -553,7 +553,7 @@ _bt_tapeadd(BTTapeBlock *tape, BTItem item, int itemsz)
  * create and initialize a spool structure, including the underlying
  * files.
  */
-void	   *
+void *
 _bt_spoolinit(Relation index, int ntapes, bool isunique)
 {
 	BTSpool    *btspool = (BTSpool *) palloc(sizeof(BTSpool));

src/backend/access/rtree/rtproc.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.15 1998/01/07 21:02:05 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.16 1998/02/26 04:30:06 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -39,7 +39,7 @@ rt_box_union(BOX *a, BOX *b)
 	return (n);
 }
 
-BOX		   *
+BOX *
 rt_box_inter(BOX *a, BOX *b)
 {
 	BOX		   *n;

src/backend/access/rtree/rtree.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.22 1998/01/15 19:42:19 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.23 1998/02/26 04:30:15 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -956,7 +956,7 @@ freestack(RTSTACK *s)
 	}
 }
 
-char	   *
+char *
 rtdelete(Relation r, ItemPointer tid)
 {
 	BlockNumber blkno;

src/backend/access/transam/transam.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.16 1998/01/07 21:02:17 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.17 1998/02/26 04:30:18 momjian Exp $
  *
  * NOTES
  *	  This file contains the high level access-method interface to the
@@ -47,8 +47,8 @@ Relation	VariableRelation = (Relation) NULL;
  *		global variables holding cached transaction id's and statuses.
  * ----------------
  */
-TransactionId	cachedTestXid;
-XidStatus		cachedTestXidStatus;
+TransactionId cachedTestXid;
+XidStatus	cachedTestXidStatus;
 
 /* ----------------
  *		transaction system constants
@@ -416,14 +416,14 @@ InitializeTransactionLog(void)
 	VariableRelation = heap_openr(VariableRelationName);
 	/* ----------------
 	 *	 XXX TransactionLogUpdate requires that LogRelation
-	 *	 is valid so we temporarily set it so we can initialize 
+	 *	 is valid so we temporarily set it so we can initialize
 	 *	 things properly. This could be done cleaner.
 	 * ----------------
 	 */
 	LogRelation = logRelation;
 
 	/* ----------------
-	 *	 if we have a virgin database, we initialize the log 
+	 *	 if we have a virgin database, we initialize the log
 	 *	 relation by committing the AmiTransactionId (id 512) and we
 	 *	 initialize the variable relation by setting the next available
 	 *	 transaction id to FirstTransactionId (id 514).  OID initialization

src/backend/access/transam/xid.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/xid.c,v 1.11 1997/11/02 15:24:47 vadim Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/xid.c,v 1.12 1998/02/26 04:30:19 momjian Exp $
  *
  * OLD COMMENTS
  * XXX WARNING
@@ -38,7 +38,7 @@ xidin(char *representation)
 }
 
 /* XXX char16 name for catalogs */
-char	   *
+char *
 xidout(TransactionId transactionId)
 {
 /*	  return(TransactionIdFormString(transactionId)); */

src/backend/bootstrap/bootstrap.c

@@ -7,7 +7,7 @@
  * Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.36 1998/02/11 19:09:34 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.37 1998/02/26 04:30:22 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -200,19 +200,21 @@ int			numattr;			/* number of attributes for cur. rel */
 extern int	fsyncOff;			/* do not fsync the database */
 
 /* The test for HAVE_SIGSETJMP fails on Linux 2.0.x because the test
- *  explicitly disallows sigsetjmp being a #define, which is how it
- *  is declared in Linux. So, to avoid compiler warnings about
- *  sigsetjmp() being redefined, let's not redefine unless necessary.
+ *	explicitly disallows sigsetjmp being a #define, which is how it
+ *	is declared in Linux. So, to avoid compiler warnings about
+ *	sigsetjmp() being redefined, let's not redefine unless necessary.
  * - thomas 1997-12-27
  */
 
 #if !defined(HAVE_SIGSETJMP) && !defined(sigsetjmp)
 static jmp_buf Warn_restart;
+
 #define sigsetjmp(x,y)	setjmp(x)
 #define siglongjmp longjmp
 
 #else
 static sigjmp_buf Warn_restart;
+
 #endif
 
 int			DebugMode;
@@ -472,8 +474,8 @@ boot_openrel(char *relname)
 	HeapScanDesc sdesc;
 	HeapTuple	tup;
 
-	if (strlen(relname) >= NAMEDATALEN-1)
-		relname[NAMEDATALEN-1] = '\0';
+	if (strlen(relname) >= NAMEDATALEN - 1)
+		relname[NAMEDATALEN - 1] = '\0';
 
 	if (Typ == (struct typmap **) NULL)
 	{
@@ -907,7 +909,7 @@ AllocateAttribute()
  * be freed by the CALLER.
  * ----------------
  */
-char	   *
+char *
 MapArrayTypeName(char *s)
 {
 	int			i,
@@ -960,7 +962,7 @@ EnterString(char *str)
  *		associated with the idnum
  * ----------------
  */
-char	   *
+char *
 LexIDStr(int ident_num)
 {
 	return (strtable[ident_num]);
@@ -979,7 +981,7 @@ LexIDStr(int ident_num)
 static int
 CompHash(char *str, int len)
 {
-	int result;
+	int			result;
 
 	result = (NUM * str[0] + NUMSQR * str[len - 1] + NUMCUBE * str[(len - 1) / 2]);
 

src/backend/catalog/aclchk.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.7 1998/02/25 13:05:57 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.8 1998/02/26 04:30:26 momjian Exp $
  *
  * NOTES
  *	  See acl.h.
@@ -74,7 +74,7 @@ char	   *aclcheck_error_strings[] = {
 static
 dumpacl(Acl *acl)
 {
-	unsigned i;
+	unsigned	i;
 	AclItem    *aip;
 
 	elog(DEBUG, "acl size = %d, # acls = %d",
@@ -94,7 +94,7 @@ ChangeAcl(char *relname,
 		  AclItem *mod_aip,
 		  unsigned modechg)
 {
-	unsigned i;
+	unsigned	i;
 	Acl		   *old_acl = (Acl *) NULL,
 			   *new_acl;
 	Relation	relation;
@@ -211,7 +211,7 @@ get_grosysid(char *groname)
 	return (id);
 }
 
-char	   *
+char *
 get_groname(AclId grosysid)
 {
 	HeapTuple	htp;
@@ -283,8 +283,8 @@ in_group(AclId uid, AclId gid)
 static int32
 aclcheck(char *relname, Acl *acl, AclId id, AclIdType idtype, AclMode mode)
 {
-	unsigned i;
-	AclItem *aip,
+	unsigned	i;
+	AclItem    *aip,
 			   *aidat;
 	unsigned	num,
 				found_group;
@@ -417,7 +417,7 @@ pg_aclcheck(char *relname, char *usename, AclMode mode)
 
 	/*
 	 * Deny anyone permission to update a system catalog unless
-	 * pg_shadow.usecatupd is set.  (This is to let superusers protect
+	 * pg_shadow.usecatupd is set.	(This is to let superusers protect
 	 * themselves from themselves.)
 	 */
 	if (((mode & ACL_WR) || (mode & ACL_AP)) &&

src/backend/catalog/catalog.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.14 1998/02/11 19:09:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.15 1998/02/26 04:30:31 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -26,7 +26,7 @@
  * relpath				- path to the relation
  *		Perhaps this should be in-line code in relopen().
  */
-char	   *
+char *
 relpath(char relname[])
 {
 	char	   *path;

src/backend/catalog/heap.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.46 1998/02/11 19:09:54 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.47 1998/02/26 04:30:35 momjian Exp $
  *
  * INTERFACE ROUTINES
  *		heap_create()			- Create an uncataloged heap relation
@@ -63,8 +63,9 @@
 #include <string.h>
 #endif
 
-static void AddPgRelationTuple(Relation pg_class_desc,
-	   Relation new_rel_desc, Oid new_rel_oid, unsigned natts);
+static void
+AddPgRelationTuple(Relation pg_class_desc,
+				 Relation new_rel_desc, Oid new_rel_oid, unsigned natts);
 static void AddToTempRelList(Relation r);
 static void DeletePgAttributeTuples(Relation rdesc);
 static void DeletePgRelationTuple(Relation rdesc);
@@ -164,14 +165,14 @@ static TempRelList *tempRels = NULL;
  *
  *
  * if heap_create is called with "" as the name, then heap_create will create
- * a temporary name	"temp_$RELOID" for the relation
+ * a temporary name "temp_$RELOID" for the relation
  * ----------------------------------------------------------------
  */
 Relation
 heap_create(char *name,
 			TupleDesc tupDesc)
 {
-	unsigned i;
+	unsigned	i;
 	Oid			relid;
 	Relation	rdesc;
 	int			len;
@@ -378,7 +379,7 @@ heap_create(char *name,
  *		create new relation
  *		insert new relation into attribute catalog
  *
- *		Should coordinate with heap_create_with_catalogr().	Either
+ *		Should coordinate with heap_create_with_catalogr(). Either
  *		it should not be called or there should be a way to prevent
  *		the relation from being removed at the end of the
  *		transaction if it is successful ('u'/'r' may be enough).
@@ -726,14 +727,14 @@ addNewRelationType(char *typeName, Oid new_rel_oid)
 	 */
 	new_type_oid = TypeCreate(typeName, /* type name */
 							  new_rel_oid,		/* relation oid */
-							  typeLen(typeidType(OIDOID)),	/* internal size */
-							  typeLen(typeidType(OIDOID)),	/* external size */
+							  typeLen(typeidType(OIDOID)),		/* internal size */
+							  typeLen(typeidType(OIDOID)),		/* external size */
 							  'c',		/* type-type (catalog) */
 							  ',',		/* default array delimiter */
 							  "int4in", /* input procedure */
-							  "int4out",/* output procedure */
-							  "int4in",	/* receive procedure */
-							  "int4out",/* send procedure */
+							  "int4out",		/* output procedure */
+							  "int4in", /* receive procedure */
+							  "int4out",		/* send procedure */
 							  NULL,		/* array element type - irrelevent */
 							  "-",		/* default type value */
 							  (bool) 1, /* passed by value */
@@ -748,7 +749,7 @@ addNewRelationType(char *typeName, Oid new_rel_oid)
  */
 Oid
 heap_create_with_catalog(char relname[],
-						TupleDesc tupdesc)
+						 TupleDesc tupdesc)
 {
 	Relation	pg_class_desc;
 	Relation	new_rel_desc;

src/backend/catalog/index.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.38 1998/02/07 21:41:48 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.39 1998/02/26 04:30:38 momjian Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -119,7 +119,7 @@ DefaultBuild(Relation heapRelation, Relation indexRelation,
  */
 static FormData_pg_attribute sysatts[] = {
 	{0l, {"ctid"}, 27l, 0l, 6, -1, 0, -1, -1, '\0', '\0', 'i', '\0', '\0'},
-	{0l, {"oid"},  26l, 0l, 4, -2, 0, -1, -1, '\001', '\0', 'i', '\0', '\0'},
+	{0l, {"oid"}, 26l, 0l, 4, -2, 0, -1, -1, '\001', '\0', 'i', '\0', '\0'},
 	{0l, {"xmin"}, 28l, 0l, 4, -3, 0, -1, -1, '\0', '\0', 'i', '\0', '\0'},
 	{0l, {"cmin"}, 29l, 0l, 4, -4, 0, -1, -1, '\001', '\0', 'i', '\0', '\0'},
 	{0l, {"xmax"}, 28l, 0l, 4, -5, 0, -1, -1, '\0', '\0', 'i', '\0', '\0'},
@@ -460,7 +460,7 @@ ConstructTupleDescriptor(Oid heapoid,
 				((TypeTupleForm) ((char *) tup + tup->t_hoff))->typbyval;
 
 			((AttributeTupleForm) to)->attlen =
-					((TypeTupleForm) ((char *) tup + tup->t_hoff))->typlen;
+				((TypeTupleForm) ((char *) tup + tup->t_hoff))->typlen;
 
 			((AttributeTupleForm) to)->atttypmod = IndexKeyType->typmod;
 		}
@@ -1100,7 +1100,7 @@ index_create(char *heapRelationName,
 	 * write lock heap to guarantee exclusive access
 	 * ----------------
 	RelationSetLockForWrite(heapRelation);
-	 *                ^^^^^
+	 *				  ^^^^^
 	 * Does it have any sense ?		- vadim 10/27/97
 	 */
 
@@ -1611,7 +1611,7 @@ DefaultBuild(Relation heapRelation,
 	 */
 	scan = heap_beginscan(heapRelation, /* relation */
 						  0,	/* start at end */
-						  false, /* seeself */
+						  false,/* seeself */
 						  0,	/* number of keys */
 						  (ScanKey) NULL);		/* scan key */
 

src/backend/catalog/pg_aggregate.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.12 1998/02/11 19:10:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.13 1998/02/26 04:30:40 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -267,7 +267,7 @@ AggregateCreate(char *aggName,
 
 }
 
-char	   *
+char *
 AggNameGetInitVal(char *aggName, Oid basetype, int xfuncno, bool *isNull)
 {
 	HeapTuple	tup;

src/backend/catalog/pg_operator.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.21 1998/02/11 19:10:11 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.22 1998/02/26 04:30:41 momjian Exp $
  *
  * NOTES
  *	  these routines moved here from commands/define.c and somewhat cleaned up.
@@ -224,7 +224,7 @@ OperatorShellMakeWithOpenRelation(Relation pg_operator_desc,
 								  Oid leftObjectId,
 								  Oid rightObjectId)
 {
-	int i;
+	int			i;
 	HeapTuple	tup;
 	Datum		values[Natts_pg_operator];
 	char		nulls[Natts_pg_operator];
@@ -782,7 +782,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
 	};
 
 	fmgr_info(ObjectIdEqualRegProcedure, &opKey[0].sk_func);
-        opKey[0].sk_nargs = opKey[0].sk_func.fn_nargs;
+	opKey[0].sk_nargs = opKey[0].sk_func.fn_nargs;
 
 	for (i = 0; i < Natts_pg_operator; ++i)
 	{

src/backend/catalog/pg_proc.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.14 1998/02/11 19:10:16 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.15 1998/02/26 04:30:43 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -216,7 +216,7 @@ ProcedureCreate(char *procedureName,
 	if (strcmp(languageName, "sql") == 0)
 	{
 		plan_list = pg_parse_and_plan(prosrc, typev, parameterCount,
-							&querytree_list, dest);
+									  &querytree_list, dest);
 
 		/* typecheck return value */
 		pg_checkretval(typeObjectId, querytree_list);

src/backend/catalog/pg_type.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.19 1998/02/11 19:10:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.20 1998/02/26 04:30:45 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -155,7 +155,7 @@ TypeGet(char *typeName,			/* name of type to be fetched */
 static Oid
 TypeShellMakeWithOpenRelation(Relation pg_type_desc, char *typeName)
 {
-	int i;
+	int			i;
 	HeapTuple	tup;
 	Datum		values[Natts_pg_type];
 	char		nulls[Natts_pg_type];
@@ -605,7 +605,7 @@ TypeRename(char *oldTypeName, char *newTypeName)
  * the CALLER is responsible for pfreeing the
  */
 
-char	   *
+char *
 makeArrayTypeName(char *typeName)
 {
 	char	   *arr;

src/backend/commands/async.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.28 1998/01/31 04:38:17 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.29 1998/02/26 04:30:47 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -84,7 +84,7 @@
 #include <libpq/libpq.h>
 
 #ifndef HAVE_STRDUP
-#  include <port-protos.h>		/* for strdup() */
+#include <port-protos.h>		/* for strdup() */
 #endif
 
 #include <storage/lmgr.h>
@@ -97,7 +97,7 @@ static Dllist *pendingNotifies = NULL;
 static int	AsyncExistsPendingNotify(char *);
 static void ClearPendingNotify(void);
 static void Async_NotifyFrontEnd(void);
-void        Async_Unlisten(char *relname, int pid);
+void		Async_Unlisten(char *relname, int pid);
 static void Async_UnlistenOnExit(int code, char *relname);
 
 /*
@@ -617,7 +617,7 @@ Async_NotifyFrontEnd()
 		if (whereToSendOutput == Remote)
 		{
 			pq_putnchar("A", 1);
-			pq_putint((int32)MyProcPid, sizeof(int32));
+			pq_putint((int32) MyProcPid, sizeof(int32));
 			pq_putstr(DatumGetName(d)->data);
 			pq_flush();
 		}

src/backend/commands/cluster.c

@@ -14,7 +14,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.22 1998/01/10 05:19:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.23 1998/02/26 04:30:49 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -212,8 +212,8 @@ copy_heap(Oid OIDOldHeap)
 	OldHeapDesc = RelationGetTupleDescriptor(OldHeap);
 
 	/*
-	 * Need to make a copy of the tuple descriptor, heap_create_with_catalog
-	 * modifies it.
+	 * Need to make a copy of the tuple descriptor,
+	 * heap_create_with_catalog modifies it.
 	 */
 
 	tupdesc = CreateTupleDescCopy(OldHeapDesc);

src/backend/commands/command.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.25 1998/02/07 21:41:52 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.26 1998/02/26 04:30:49 momjian Exp $
  *
  * NOTES
  *	  The PortalExecutorHeapMemory crap needs to be eliminated
@@ -97,10 +97,10 @@ PerformPortalFetch(char *name,
 				   char *tag,
 				   CommandDest dest)
 {
-	Portal			portal;
-	int				feature;
-	QueryDesc	   *queryDesc;
-	MemoryContext	context;
+	Portal		portal;
+	int			feature;
+	QueryDesc  *queryDesc;
+	MemoryContext context;
 
 	/* ----------------
 	 *	sanity checks
@@ -148,16 +148,16 @@ PerformPortalFetch(char *name,
 	 * ----------------
 	 */
 	queryDesc = PortalGetQueryDesc(portal);
-	
-	if ( dest == None )		/* MOVE */
+
+	if (dest == None)			/* MOVE */
 	{
-		QueryDesc	*qdesc = (QueryDesc *) palloc (sizeof (QueryDesc));
-		
-		memcpy (qdesc, queryDesc, sizeof (QueryDesc));
+		QueryDesc  *qdesc = (QueryDesc *) palloc(sizeof(QueryDesc));
+
+		memcpy(qdesc, queryDesc, sizeof(QueryDesc));
 		qdesc->dest = dest;
 		queryDesc = qdesc;
 	}
-	
+
 	BeginCommand(name,
 				 queryDesc->operation,
 				 portal->attinfo,		/* QueryDescGetTypeInfo(queryDesc),
@@ -178,9 +178,9 @@ PerformPortalFetch(char *name,
 
 	ExecutorRun(queryDesc, PortalGetState(portal), feature, count);
 
-	if ( dest == None )		/* MOVE */
-		pfree (queryDesc);
-	
+	if (dest == None)			/* MOVE */
+		pfree(queryDesc);
+
 	/* ----------------
 	 * Note: the "end-of-command" tag is returned by higher-level
 	 *		 utility code

src/backend/commands/copy.c

@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.43 1998/02/25 13:06:08 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.44 1998/02/26 04:30:52 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -48,7 +48,8 @@ static Oid	GetOutputFunction(Oid type);
 static Oid	GetTypeElement(Oid type);
 static Oid	GetInputFunction(Oid type);
 static Oid	IsTypeByVal(Oid type);
-static void GetIndexRelations(Oid main_relation_oid,
+static void
+GetIndexRelations(Oid main_relation_oid,
 				  int *n_indices,
 				  Relation **index_rels);
 
@@ -64,7 +65,7 @@ static void CopyAttributeOut(FILE *fp, char *string, char *delim);
 static int	CountTuples(Relation relation);
 
 extern FILE *Pfout,
-			*Pfin;
+		   *Pfin;
 
 static int	lineno;
 
@@ -275,7 +276,7 @@ CopyTo(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
 				if (!isnull)
 				{
 					string = (char *) (*fmgr_faddr(&out_functions[i]))
-							(value, elements[i], typmod[i]);
+						(value, elements[i], typmod[i]);
 					CopyAttributeOut(fp, string, delim);
 					pfree(string);
 				}
@@ -582,8 +583,8 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
 				{
 					values[i] =
 						(Datum) (*fmgr_faddr(&in_functions[i])) (string,
-												   elements[i],
-												   typmod[i]);
+															 elements[i],
+															  typmod[i]);
 
 					/*
 					 * Sanity check - by reference attributes cannot
@@ -592,7 +593,7 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
 					if (!PointerIsValid(values[i]) &&
 						!(rel->rd_att->attrs[i]->attbyval))
 					{
-						elog(ERROR, "copy from line %d: Bad file format",lineno);
+						elog(ERROR, "copy from line %d: Bad file format", lineno);
 					}
 				}
 			}

src/backend/commands/creatinh.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.25 1998/02/10 04:00:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.26 1998/02/26 04:30:55 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -58,7 +58,7 @@ DefineRelation(CreateStmt *stmt)
 	if (strlen(stmt->relname) >= NAMEDATALEN)
 		elog(ERROR, "the relation name %s is >= %d characters long", stmt->relname,
 			 NAMEDATALEN);
-	StrNCpy(relname, stmt->relname, NAMEDATALEN);	/* make full length for
+	StrNCpy(relname, stmt->relname, NAMEDATALEN);		/* make full length for
 														 * copy */
 
 	/* ----------------
@@ -253,7 +253,7 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
 		if (relation == NULL)
 		{
 			elog(ERROR,
-			"MergeAttr: Can't inherit from non-existent superclass '%s'", name);
+				 "MergeAttr: Can't inherit from non-existent superclass '%s'", name);
 		}
 		if (relation->rd_rel->relkind == 'S')
 		{
@@ -334,7 +334,8 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
 
 			for (i = 0; i < constr->num_check; i++)
 			{
-				Constraint *cdef = (Constraint *) makeNode(Constraint); /* palloc(sizeof(Constraint)); */
+				Constraint *cdef = (Constraint *) makeNode(Constraint); /* palloc(sizeof(Constrai
+																		 * nt)); */
 
 				cdef->contype = CONSTR_CHECK;
 				if (check[i].ccname[0] == '$')

src/backend/commands/define.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.23 1998/02/25 13:06:12 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.24 1998/02/26 04:30:57 momjian Exp $
  *
  * DESCRIPTION
  *	  The "DefineFoo" routines take the parse tree and pick out the
@@ -265,39 +265,42 @@ CreateFunction(ProcedureStmt *stmt, CommandDest dest)
 	}
 	else
 	{
-		HeapTuple		languageTuple;
-		Form_pg_language	languageStruct;
+		HeapTuple	languageTuple;
+		Form_pg_language languageStruct;
 
-	        /* Lookup the language in the system cache */
+		/* Lookup the language in the system cache */
 		languageTuple = SearchSysCacheTuple(LANNAME,
-			PointerGetDatum(languageName),
-			0, 0, 0);
-		
-		if (!HeapTupleIsValid(languageTuple)) {
-
-		    elog(ERROR,
-			 "Unrecognized language specified in a CREATE FUNCTION: "
-			 "'%s'.  Recognized languages are sql, C, internal "
-			 "and the created procedural languages.",
-			 languageName);
+											PointerGetDatum(languageName),
+											0, 0, 0);
+
+		if (!HeapTupleIsValid(languageTuple))
+		{
+
+			elog(ERROR,
+				 "Unrecognized language specified in a CREATE FUNCTION: "
+				 "'%s'.  Recognized languages are sql, C, internal "
+				 "and the created procedural languages.",
+				 languageName);
 		}
 
 		/* Check that this language is a PL */
 		languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
-		if (!(languageStruct->lanispl)) {
-		    elog(ERROR,
-		    	"Language '%s' isn't defined as PL", languageName);
+		if (!(languageStruct->lanispl))
+		{
+			elog(ERROR,
+				 "Language '%s' isn't defined as PL", languageName);
 		}
 
 		/*
-		 * Functions in untrusted procedural languages are
-		 * restricted to be defined by postgres superusers only
+		 * Functions in untrusted procedural languages are restricted to
+		 * be defined by postgres superusers only
 		 */
-		if (languageStruct->lanpltrusted == false && !superuser()) {
-		    elog(ERROR, "Only users with Postgres superuser privilege "
-		    	"are permitted to create a function in the '%s' "
-			"language.",
-			languageName);
+		if (languageStruct->lanpltrusted == false && !superuser())
+		{
+			elog(ERROR, "Only users with Postgres superuser privilege "
+				 "are permitted to create a function in the '%s' "
+				 "language.",
+				 languageName);
 		}
 
 		lanisPL = true;

src/backend/commands/proclang.c

@@ -43,7 +43,7 @@ case_translate_language_name(const char *input, char *output)
  * ---------------------------------------------------------------------
  */
 void
-CreateProceduralLanguage(CreatePLangStmt * stmt)
+CreateProceduralLanguage(CreatePLangStmt *stmt)
 {
 	char		languageName[NAMEDATALEN];
 	HeapTuple	langTup;
@@ -139,7 +139,7 @@ CreateProceduralLanguage(CreatePLangStmt * stmt)
  * ---------------------------------------------------------------------
  */
 void
-DropProceduralLanguage(DropPLangStmt * stmt)
+DropProceduralLanguage(DropPLangStmt *stmt)
 {
 	char		languageName[NAMEDATALEN];
 	HeapTuple	langTup;