Massive commit to run PGINDENT on all *.c and *.h files.

1 files changed, 324 insertions, 274 deletions

diff --git a/src/backend/tcop/variable.c b/src/backend/tcop/variable.c
index c2a2a754e95..d394881ab3a 100644
--- a/src/backend/tcop/variable.c
+++ b/src/backend/tcop/variable.c
@@ -2,7 +2,7 @@
  * Routines for handling of 'SET var TO', 'SHOW var' and 'RESET var'
  * statements.
  *
- * $Id: variable.c,v 1.13 1997/08/12 20:15:50 momjian Exp $
+ * $Id: variable.c,v 1.14 1997/09/07 04:49:37 momjian Exp $
  *
  */
 
@@ -15,421 +15,471 @@
 #include "utils/builtins.h"
 #include "optimizer/internal.h"
 
-extern Cost _cpu_page_wight_;
-extern Cost _cpu_index_page_wight_;
-extern bool _use_geqo_;
-extern int32 _use_geqo_rels_;
-extern bool _use_right_sided_plans_;
+extern Cost		_cpu_page_wight_;
+extern Cost		_cpu_index_page_wight_;
+extern bool		_use_geqo_;
+extern int32	_use_geqo_rels_;
+extern bool		_use_right_sided_plans_;
 
 /*-----------------------------------------------------------------------*/
 #if USE_EURODATES
-#define DATE_EURO	TRUE
+#define DATE_EURO		TRUE
 #else
 #define DATE_EURO FALSE
 #endif
 
 /*-----------------------------------------------------------------------*/
 struct PGVariables PGVariables =
-	{
-		{ DATE_EURO, Date_Postgres }
-	};
+{
+	{DATE_EURO, Date_Postgres}
+};
 
 /*-----------------------------------------------------------------------*/
-static const char *get_token(char **tok, char **val, const char *str)
+static const char *
+get_token(char **tok, char **val, const char *str)
 {
-    const char *start;
-    int len = 0;
-
-    *tok = NULL;
-    if (val != NULL) *val = NULL;
-
-    if ( !(*str) )
-	return NULL;
-
-    /* skip white spaces */
-    while (isspace(*str)) str++;
-    if ( *str == ',' || *str == '=' )
-	elog(WARN, "Syntax error near (%s): empty setting", str);
-
-    /* end of string? then return NULL */
-    if ( !(*str) )
-	return NULL;
-
-    /* OK, at beginning of non-NULL string... */
-    start = str;
-
-    /* 
-     * count chars in token until we hit white space or comma 
-     * or '=' or end of string
-     */
-    while ( *str && (! isspace(*str))
-     && *str != ','  && *str != '=' )
-    {
-	str++;
-	len++;
-    }
-    
-    *tok = (char*) PALLOC(len + 1);
-    strNcpy (*tok, start, len);
-
-    /* skip white spaces */
-    while ( isspace(*str)) str++;
-
-    /* end of string? */
-    if ( !(*str) ) {
-    	return(str);
-
-    /* delimiter? */
-    } else if ( *str == ',' ) {
-    	return (++str);
-
-    } else if ((val == NULL) || ( *str != '=' )) {
+	const char	   *start;
+	int				len = 0;
+
+	*tok = NULL;
+	if (val != NULL)
+		*val = NULL;
+
+	if (!(*str))
+		return NULL;
+
+	/* skip white spaces */
+	while (isspace(*str))
+		str++;
+	if (*str == ',' || *str == '=')
+		elog(WARN, "Syntax error near (%s): empty setting", str);
+
+	/* end of string? then return NULL */
+	if (!(*str))
+		return NULL;
+
+	/* OK, at beginning of non-NULL string... */
+	start = str;
+
+	/*
+	 * count chars in token until we hit white space or comma or '=' or
+	 * end of string
+	 */
+	while (*str && (!isspace(*str))
+		   && *str != ',' && *str != '=')
+	{
+		str++;
+		len++;
+	}
+
+	*tok = (char *) PALLOC(len + 1);
+	strNcpy(*tok, start, len);
+
+	/* skip white spaces */
+	while (isspace(*str))
+		str++;
+
+	/* end of string? */
+	if (!(*str))
+	{
+		return (str);
+
+		/* delimiter? */
+	}
+	else if (*str == ',')
+	{
+		return (++str);
+
+	}
+	else if ((val == NULL) || (*str != '='))
+	{
+		elog(WARN, "Syntax error near (%s)", str);
+	};
+
+	str++;						/* '=': get value */
+	len = 0;
+
+	/* skip white spaces */
+	while (isspace(*str))
+		str++;
+
+	if (*str == ',' || !(*str))
+		elog(WARN, "Syntax error near (=%s)", str);
+
+	start = str;
+
+	/*
+	 * count chars in token's value until we hit white space or comma or
+	 * end of string
+	 */
+	while (*str && (!isspace(*str)) && *str != ',')
+	{
+		str++;
+		len++;
+	}
+
+	*val = (char *) PALLOC(len + 1);
+	strNcpy(*val, start, len);
+
+	/* skip white spaces */
+	while (isspace(*str))
+		str++;
+
+	if (!(*str))
+		return (NULL);
+	if (*str == ',')
+		return (++str);
+
 	elog(WARN, "Syntax error near (%s)", str);
-    };
-    
-    str++;		/* '=': get value */
-    len = 0;
-
-    /* skip white spaces */
-    while ( isspace(*str)) str++;
-
-    if ( *str == ',' || !(*str) )
-	elog(WARN, "Syntax error near (=%s)", str);
-
-    start = str;
-
-    /* 
-     * count chars in token's value until we hit white space or comma 
-     * or end of string
-     */
-    while ( *str && (! isspace(*str)) && *str != ',' )
-    {
-	str++;
-	len++;
-    }
-    
-    *val = (char*) PALLOC(len + 1);
-    strNcpy (*val, start, len);
-
-    /* skip white spaces */
-    while ( isspace(*str)) str++;
-
-    if ( !(*str) )
-    	return (NULL);
-    if ( *str == ',' )
-    	return (++str);
-
-    elog(WARN, "Syntax error near (%s)", str);
-
-    return str;
+
+	return str;
 }
 
 /*-----------------------------------------------------------------------*/
-static bool parse_null(const char *value)
-	{
+static bool
+parse_null(const char *value)
+{
 	return TRUE;
-	}
+}
 
-static bool show_null(const char *value)
-	{
+static bool
+show_null(const char *value)
+{
 	return TRUE;
-	}
+}
 
-static bool reset_null(const char *value)
-	{
+static bool
+reset_null(const char *value)
+{
 	return TRUE;
-	}
+}
 
-static bool parse_geqo (const char *value)
+static bool
+parse_geqo(const char *value)
 {
-    const char *rest;
-    char *tok, *val;
-
-    rest = get_token (&tok, &val, value);
-    if ( tok == NULL )
-	elog(WARN, "Value undefined");
-
-    if (( rest ) && ( *rest != '\0' ))
-	elog(WARN, "Unable to parse '%s'", value);
-
-    if ( strcasecmp (tok, "on") == 0 )
-    {
-    	int32 geqo_rels = GEQO_RELS;
-    	
-    	if ( val != NULL )
-    	{
-    	    geqo_rels = pg_atoi (val, sizeof(int32), '\0');
-    	    if ( geqo_rels <= 1 )
-		elog(WARN, "Bad value for # of relations (%s)", val);
-    	    PFREE(val);
-    	}
-    	_use_geqo_ = true;
-    	_use_geqo_rels_ = geqo_rels;
-    }
-    else if ( strcasecmp (tok, "off") == 0 )
-    {
-    	if (( val != NULL ) && ( *val != '\0' ))
-	    elog(WARN, "%s does not allow a parameter",tok);
-    	_use_geqo_ = false;
-    }
-    else
-    	elog(WARN, "Bad value for GEQO (%s)", value);
-    
-    PFREE(tok);
-    return TRUE;
+	const char	   *rest;
+	char		   *tok,
+				   *val;
+
+	rest = get_token(&tok, &val, value);
+	if (tok == NULL)
+		elog(WARN, "Value undefined");
+
+	if ((rest) && (*rest != '\0'))
+		elog(WARN, "Unable to parse '%s'", value);
+
+	if (strcasecmp(tok, "on") == 0)
+	{
+		int32			geqo_rels = GEQO_RELS;
+
+		if (val != NULL)
+		{
+			geqo_rels = pg_atoi(val, sizeof(int32), '\0');
+			if (geqo_rels <= 1)
+				elog(WARN, "Bad value for # of relations (%s)", val);
+			PFREE(val);
+		}
+		_use_geqo_ = true;
+		_use_geqo_rels_ = geqo_rels;
+	}
+	else if (strcasecmp(tok, "off") == 0)
+	{
+		if ((val != NULL) && (*val != '\0'))
+			elog(WARN, "%s does not allow a parameter", tok);
+		_use_geqo_ = false;
+	}
+	else
+		elog(WARN, "Bad value for GEQO (%s)", value);
+
+	PFREE(tok);
+	return TRUE;
 }
 
-static bool show_geqo ()
+static bool
+show_geqo()
 {
 
-    if ( _use_geqo_ )
-    	elog (NOTICE, "GEQO is ON beginning with %d relations", _use_geqo_rels_);
-    else
-    	elog (NOTICE, "GEQO is OFF");
-    return TRUE;
+	if (_use_geqo_)
+		elog(NOTICE, "GEQO is ON beginning with %d relations", _use_geqo_rels_);
+	else
+		elog(NOTICE, "GEQO is OFF");
+	return TRUE;
 }
 
-static bool reset_geqo ()
+static bool
+reset_geqo()
 {
 
 #ifdef GEQO
-    _use_geqo_ = true;
+	_use_geqo_ = true;
 #else
-    _use_geqo_ = false;
+	_use_geqo_ = false;
 #endif
-    _use_geqo_rels_ = GEQO_RELS;
-    return TRUE;
+	_use_geqo_rels_ = GEQO_RELS;
+	return TRUE;
 }
 
-static bool parse_r_plans (const char *value)
+static bool
+parse_r_plans(const char *value)
 {
 
-    if ( strcasecmp (value, "on") == 0 )
-    	_use_right_sided_plans_ = true;
-    else if ( strcasecmp (value, "off") == 0 )
-    	_use_right_sided_plans_ = false;
-    else
-	elog(WARN, "Bad value for Right-sided Plans (%s)", value);
-    
-    return TRUE;
+	if (strcasecmp(value, "on") == 0)
+		_use_right_sided_plans_ = true;
+	else if (strcasecmp(value, "off") == 0)
+		_use_right_sided_plans_ = false;
+	else
+		elog(WARN, "Bad value for Right-sided Plans (%s)", value);
+
+	return TRUE;
 }
 
-static bool show_r_plans ()
+static bool
+show_r_plans()
 {
 
-    if ( _use_right_sided_plans_ )
-    	elog (NOTICE, "Right-sided Plans are ON");
-    else
-    	elog (NOTICE, "Right-sided Plans are OFF");
-    return TRUE;
+	if (_use_right_sided_plans_)
+		elog(NOTICE, "Right-sided Plans are ON");
+	else
+		elog(NOTICE, "Right-sided Plans are OFF");
+	return TRUE;
 }
 
-static bool reset_r_plans ()
+static bool
+reset_r_plans()
 {
 
 #ifdef USE_RIGHT_SIDED_PLANS
-    _use_right_sided_plans_ = true;
+	_use_right_sided_plans_ = true;
 #else
-    _use_right_sided_plans_ = false;
+	_use_right_sided_plans_ = false;
 #endif
-    return TRUE;
+	return TRUE;
 }
 
-static bool parse_cost_heap (const char *value)
+static bool
+parse_cost_heap(const char *value)
 {
-    float32 res = float4in ((char*)value);
-    
-    _cpu_page_wight_ = *res;
-    
-    return TRUE;
+	float32			res = float4in((char *) value);
+
+	_cpu_page_wight_ = *res;
+
+	return TRUE;
 }
 
-static bool show_cost_heap ()
+static bool
+show_cost_heap()
 {
 
-    elog (NOTICE, "COST_HEAP is %f", _cpu_page_wight_);
-    return TRUE;
+	elog(NOTICE, "COST_HEAP is %f", _cpu_page_wight_);
+	return TRUE;
 }
 
-static bool reset_cost_heap ()
+static bool
+reset_cost_heap()
 {
-    _cpu_page_wight_ = _CPU_PAGE_WEIGHT_;
-    return TRUE;
+	_cpu_page_wight_ = _CPU_PAGE_WEIGHT_;
+	return TRUE;
 }
 
-static bool parse_cost_index (const char *value)
+static bool
+parse_cost_index(const char *value)
 {
-    float32 res = float4in ((char*)value);
-    
-    _cpu_index_page_wight_ = *res;
-    
-    return TRUE;
+	float32			res = float4in((char *) value);
+
+	_cpu_index_page_wight_ = *res;
+
+	return TRUE;
 }
 
-static bool show_cost_index ()
+static bool
+show_cost_index()
 {
 
-    elog (NOTICE, "COST_INDEX is %f", _cpu_index_page_wight_);
-    return TRUE;
+	elog(NOTICE, "COST_INDEX is %f", _cpu_index_page_wight_);
+	return TRUE;
 }
 
-static bool reset_cost_index ()
+static bool
+reset_cost_index()
 {
-    _cpu_index_page_wight_ = _CPU_INDEX_PAGE_WEIGHT_;
-    return TRUE;
+	_cpu_index_page_wight_ = _CPU_INDEX_PAGE_WEIGHT_;
+	return TRUE;
 }
 
-static bool parse_date(const char *value)
+static bool
+parse_date(const char *value)
 {
-	char *tok;
-	int dcnt = 0, ecnt = 0;
+	char		   *tok;
+	int				dcnt = 0,
+					ecnt = 0;
 
-	while((value = get_token(&tok, NULL, value)) != 0)
+	while ((value = get_token(&tok, NULL, value)) != 0)
 	{
 		/* Ugh. Somebody ought to write a table driven version -- mjl */
 
-		if(!strcasecmp(tok, "iso"))
-			{
+		if (!strcasecmp(tok, "iso"))
+		{
 			DateStyle = USE_ISO_DATES;
 			dcnt++;
-			}
-		else if(!strcasecmp(tok, "sql"))
-			{
+		}
+		else if (!strcasecmp(tok, "sql"))
+		{
 			DateStyle = USE_SQL_DATES;
 			dcnt++;
-			}
-		else if(!strcasecmp(tok, "postgres"))
-			{
+		}
+		else if (!strcasecmp(tok, "postgres"))
+		{
 			DateStyle = USE_POSTGRES_DATES;
 			dcnt++;
-			}
-		else if(!strncasecmp(tok, "euro", 4))
-			{
+		}
+		else if (!strncasecmp(tok, "euro", 4))
+		{
 			EuroDates = TRUE;
 			ecnt++;
-			}
-		else if((!strcasecmp(tok, "us"))
-		     || (!strncasecmp(tok, "noneuro", 7)))
-			{
+		}
+		else if ((!strcasecmp(tok, "us"))
+				 || (!strncasecmp(tok, "noneuro", 7)))
+		{
 			EuroDates = FALSE;
 			ecnt++;
-			}
-		else if(!strcasecmp(tok, "default"))
-			{
+		}
+		else if (!strcasecmp(tok, "default"))
+		{
 			DateStyle = USE_POSTGRES_DATES;
 			EuroDates = FALSE;
 			ecnt++;
-			}
+		}
 		else
-			{
+		{
 			elog(WARN, "Bad value for date style (%s)", tok);
-			}
+		}
 		PFREE(tok);
 	}
 
-	if(dcnt > 1 || ecnt > 1)
+	if (dcnt > 1 || ecnt > 1)
 		elog(NOTICE, "Conflicting settings for date");
 
 	return TRUE;
 }
 
-static bool show_date()
-	{
-	char buf[64];
+static bool
+show_date()
+{
+	char			buf[64];
 
-	strcpy( buf, "DateStyle is ");
-	switch (DateStyle) {
+	strcpy(buf, "DateStyle is ");
+	switch (DateStyle)
+	{
 	case USE_ISO_DATES:
-		strcat( buf, "ISO");
+		strcat(buf, "ISO");
 		break;
 	case USE_SQL_DATES:
-		strcat( buf, "SQL");
+		strcat(buf, "SQL");
 		break;
 	default:
-		strcat( buf, "Postgres");
+		strcat(buf, "Postgres");
 		break;
 	};
-	strcat( buf, " with ");
-	strcat( buf, ((EuroDates)? "European": "US (NonEuropean)"));
-	strcat( buf, " conventions");
+	strcat(buf, " with ");
+	strcat(buf, ((EuroDates) ? "European" : "US (NonEuropean)"));
+	strcat(buf, " conventions");
 
 	elog(NOTICE, buf, NULL);
 
 	return TRUE;
-	}
+}
 
-static bool reset_date()
-	{
+static bool
+reset_date()
+{
 	DateStyle = USE_POSTGRES_DATES;
 	EuroDates = FALSE;
 
 	return TRUE;
-	}
+}
 
 /*-----------------------------------------------------------------------*/
 struct VariableParsers
+{
+	const char	   *name;
+					bool(*parser) (const char *);
+					bool(*show) ();
+					bool(*reset) ();
+}				VariableParsers[] =
+
+{
 	{
-	const char *name;
-	bool (*parser)(const char *);
-	bool (*show)();
-	bool (*reset)();
-	} VariableParsers[] =
+		"datestyle", parse_date, show_date, reset_date
+	},
 	{
-		{ "datestyle",	parse_date,	show_date,	reset_date },
-		{ "timezone", 	parse_null,	show_null,	reset_null },
-		{ "cost_heap", 	parse_cost_heap,
-				show_cost_heap,	reset_cost_heap },
-		{ "cost_index",	parse_cost_index,
-				show_cost_index,	reset_cost_index },
-		{ "geqo",	parse_geqo,	show_geqo,	reset_geqo },
-		{ "r_plans",	parse_r_plans,	show_r_plans,	reset_r_plans },
-		{ NULL, NULL, NULL }
-	};
+		"timezone", parse_null, show_null, reset_null
+	},
+	{
+		"cost_heap", parse_cost_heap,
+		show_cost_heap, reset_cost_heap
+	},
+	{
+		"cost_index", parse_cost_index,
+		show_cost_index, reset_cost_index
+	},
+	{
+		"geqo", parse_geqo, show_geqo, reset_geqo
+	},
+	{
+		"r_plans", parse_r_plans, show_r_plans, reset_r_plans
+	},
+	{
+		NULL, NULL, NULL
+	}
+};
 
 /*-----------------------------------------------------------------------*/
-bool SetPGVariable(const char *name, const char *value)
-	{
+bool
+SetPGVariable(const char *name, const char *value)
+{
 	struct VariableParsers *vp;
 
-	for(vp = VariableParsers; vp->name; vp++)
-		{
-		if(!strcasecmp(vp->name, name))
-			return (vp->parser)(value);
-		}
+	for (vp = VariableParsers; vp->name; vp++)
+	{
+		if (!strcasecmp(vp->name, name))
+			return (vp->parser) (value);
+	}
 
 	elog(NOTICE, "Unrecognized variable %s", name);
 
 	return TRUE;
-	}
+}
 
 /*-----------------------------------------------------------------------*/
-bool GetPGVariable(const char *name)
-	{
+bool
+GetPGVariable(const char *name)
+{
 	struct VariableParsers *vp;
 
-	for(vp = VariableParsers; vp->name; vp++)
-		{
-		if(!strcasecmp(vp->name, name))
-			return (vp->show)();
-		}
+	for (vp = VariableParsers; vp->name; vp++)
+	{
+		if (!strcasecmp(vp->name, name))
+			return (vp->show) ();
+	}
 
 	elog(NOTICE, "Unrecognized variable %s", name);
 
 	return TRUE;
-	}
+}
 
 /*-----------------------------------------------------------------------*/
-bool ResetPGVariable(const char *name)
-	{
+bool
+ResetPGVariable(const char *name)
+{
 	struct VariableParsers *vp;
 
-	for(vp = VariableParsers; vp->name; vp++)
-		{
-		if(!strcasecmp(vp->name, name))
-			return (vp->reset)();
-		}
+	for (vp = VariableParsers; vp->name; vp++)
+	{
+		if (!strcasecmp(vp->name, name))
+			return (vp->reset) ();
+	}
 
 	elog(NOTICE, "Unrecognized variable %s", name);
 
 	return TRUE;
-	}
+}