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

1 files changed, 380 insertions, 327 deletions

diff --git a/src/backend/rewrite/rewriteManip.c b/src/backend/rewrite/rewriteManip.c
index 01fad29f773..b8b39b33281 100644
--- a/src/backend/rewrite/rewriteManip.c
+++ b/src/backend/rewrite/rewriteManip.c
@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.4 1996/11/10 03:02:04 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.5 1997/09/07 04:48:09 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -17,7 +17,7 @@
 #include "nodes/nodes.h"
 #include "nodes/relation.h"
 #include "nodes/primnodes.h"
-#include "parser/parsetree.h"		/* for getrelid() */
+#include "parser/parsetree.h"	/* for getrelid() */
 #include "utils/lsyscache.h"
 #include "utils/builtins.h"
 #include "rewrite/rewriteHandler.h"
@@ -28,410 +28,463 @@
 #include "nodes/plannodes.h"
 #include "optimizer/clauses.h"
 
-static void ResolveNew(RewriteInfo *info, List *targetlist, Node **node);
+static void		ResolveNew(RewriteInfo * info, List * targetlist, Node ** node);
 
 
 
 void
-OffsetVarNodes(Node *node, int offset)
+OffsetVarNodes(Node * node, int offset)
 {
-    if (node==NULL)
-	return;
-    switch (nodeTag(node)) {
-    case T_TargetEntry:
+	if (node == NULL)
+		return;
+	switch (nodeTag(node))
 	{
-	    TargetEntry *tle = (TargetEntry *)node;
-	    OffsetVarNodes(tle->expr, offset);
-	}
-	break;
-    case T_Expr:
-	{
-	    Expr *expr = (Expr*)node;
-	    OffsetVarNodes((Node*)expr->args, offset);
-	}
-	break;
-    case T_Var:
-	{
-	    Var *var = (Var*)node;
-	    var->varno += offset;
-	    var->varnoold += offset;
-	}
-	break;
-    case T_List:
-	{
-	    List *l;
+	case T_TargetEntry:
+		{
+			TargetEntry    *tle = (TargetEntry *) node;
+
+			OffsetVarNodes(tle->expr, offset);
+		}
+		break;
+	case T_Expr:
+		{
+			Expr		   *expr = (Expr *) node;
 
-	    foreach(l, (List*)node) {
-		OffsetVarNodes(lfirst(l), offset);
-	    }
+			OffsetVarNodes((Node *) expr->args, offset);
+		}
+		break;
+	case T_Var:
+		{
+			Var			   *var = (Var *) node;
+
+			var->varno += offset;
+			var->varnoold += offset;
+		}
+		break;
+	case T_List:
+		{
+			List		   *l;
+
+			foreach(l, (List *) node)
+			{
+				OffsetVarNodes(lfirst(l), offset);
+			}
+		}
+		break;
+	default:
+		/* ignore the others */
+		break;
 	}
-	break;
-    default:
-	/* ignore the others */
-	break;
-    }
 }
 
 void
-ChangeVarNodes(Node *node, int old_varno, int new_varno)
+ChangeVarNodes(Node * node, int old_varno, int new_varno)
 {
-    if (node==NULL)
-	return;
-    switch (nodeTag(node)) {
-    case T_TargetEntry:
-	{
-	    TargetEntry *tle = (TargetEntry *)node;
-	    ChangeVarNodes(tle->expr, old_varno, new_varno);
-	}
-	break;
-    case T_Expr:
-	{
-	    Expr *expr = (Expr*)node;
-	    ChangeVarNodes((Node*)expr->args, old_varno, new_varno);
-	}
-	break;
-    case T_Var:
+	if (node == NULL)
+		return;
+	switch (nodeTag(node))
 	{
-	    Var *var = (Var*)node;
-	    if (var->varno == old_varno) {
-		var->varno = new_varno;
-		var->varnoold = new_varno;
-	    }
-	}
-	break;
-    case T_List:
-	{
-	    List *l;
-	    foreach (l, (List*)node) {
-		ChangeVarNodes(lfirst(l), old_varno, new_varno);
-	    }
+	case T_TargetEntry:
+		{
+			TargetEntry    *tle = (TargetEntry *) node;
+
+			ChangeVarNodes(tle->expr, old_varno, new_varno);
+		}
+		break;
+	case T_Expr:
+		{
+			Expr		   *expr = (Expr *) node;
+
+			ChangeVarNodes((Node *) expr->args, old_varno, new_varno);
+		}
+		break;
+	case T_Var:
+		{
+			Var			   *var = (Var *) node;
+
+			if (var->varno == old_varno)
+			{
+				var->varno = new_varno;
+				var->varnoold = new_varno;
+			}
+		}
+		break;
+	case T_List:
+		{
+			List		   *l;
+
+			foreach(l, (List *) node)
+			{
+				ChangeVarNodes(lfirst(l), old_varno, new_varno);
+			}
+		}
+		break;
+	default:
+		/* ignore the others */
+		break;
 	}
-	break;
-    default:
-	/* ignore the others */
-	break;
-    }
 }
 
 void
-AddQual(Query *parsetree, Node *qual)
+AddQual(Query * parsetree, Node * qual)
 {
-    Node *copy, *old;
-    
-    if (qual == NULL)
-	return;
-    
-    copy = copyObject(qual);
-    old = parsetree->qual;
-    if (old == NULL)
-	parsetree->qual = copy;
-    else 
-	parsetree->qual = 
-	    (Node*)make_andclause(makeList(parsetree->qual, copy, -1));
+	Node		   *copy,
+				   *old;
+
+	if (qual == NULL)
+		return;
+
+	copy = copyObject(qual);
+	old = parsetree->qual;
+	if (old == NULL)
+		parsetree->qual = copy;
+	else
+		parsetree->qual =
+			(Node *) make_andclause(makeList(parsetree->qual, copy, -1));
 }
 
 void
-AddNotQual(Query *parsetree, Node *qual)
+AddNotQual(Query * parsetree, Node * qual)
 {
-    Node *copy;
-    
-    if (qual == NULL) return;
-    
-    copy = (Node*)make_notclause(copyObject(qual));
+	Node		   *copy;
 
-    AddQual(parsetree,copy);
+	if (qual == NULL)
+		return;
+
+	copy = (Node *) make_notclause(copyObject(qual));
+
+	AddQual(parsetree, copy);
 }
 
-static Node *
+static Node    *
 make_null(Oid type)
 {
-    Const *c = makeNode(Const);
-    
-    c->consttype = type;
-    c->constlen = get_typlen(type);
-    c->constvalue = PointerGetDatum(NULL);
-    c->constisnull = true;
-    c->constbyval = get_typbyval(type);
-    return (Node*)c;
+	Const		   *c = makeNode(Const);
+
+	c->consttype = type;
+	c->constlen = get_typlen(type);
+	c->constvalue = PointerGetDatum(NULL);
+	c->constisnull = true;
+	c->constbyval = get_typbyval(type);
+	return (Node *) c;
 }
 
 void
-FixResdomTypes (List *tlist)
+FixResdomTypes(List * tlist)
 {
-    List *i;
+	List		   *i;
 
-    foreach (i, tlist) {
-	TargetEntry *tle = lfirst(i);
+	foreach(i, tlist)
+	{
+		TargetEntry    *tle = lfirst(i);
 
-	if (nodeTag(tle->expr) == T_Var) {
-	    Var *var = (Var*)tle->expr;
+		if (nodeTag(tle->expr) == T_Var)
+		{
+			Var			   *var = (Var *) tle->expr;
 
-	    tle->resdom->restype = var->vartype;
-	    tle->resdom->reslen = get_typlen(var->vartype);
+			tle->resdom->restype = var->vartype;
+			tle->resdom->reslen = get_typlen(var->vartype);
+		}
 	}
-    }
 }
 
-static Node *
-FindMatchingNew(List *tlist, int attno)
+static Node    *
+FindMatchingNew(List * tlist, int attno)
 {
-    List *i;
-    
-    foreach (i, tlist ) {
-	TargetEntry *tle = lfirst(i);
+	List		   *i;
 
-	if (tle->resdom->resno == attno ) {
-	    return (tle->expr);
+	foreach(i, tlist)
+	{
+		TargetEntry    *tle = lfirst(i);
+
+		if (tle->resdom->resno == attno)
+		{
+			return (tle->expr);
+		}
 	}
-    }
-    return NULL;
+	return NULL;
 }
 
-static Node *
-FindMatchingTLEntry(List *tlist, char *e_attname)
+static Node    *
+FindMatchingTLEntry(List * tlist, char *e_attname)
 {
-    List *i;
-    
-    foreach (i, tlist) {
-	TargetEntry *tle = lfirst(i);
-	char *resname;
-
-	resname = tle->resdom->resname;
-	if (!strcmp(e_attname, resname))
-	    return (tle->expr);
-    }
-    return NULL;
+	List		   *i;
+
+	foreach(i, tlist)
+	{
+		TargetEntry    *tle = lfirst(i);
+		char		   *resname;
+
+		resname = tle->resdom->resname;
+		if (!strcmp(e_attname, resname))
+			return (tle->expr);
+	}
+	return NULL;
 }
 
 static void
-ResolveNew(RewriteInfo *info, List *targetlist, Node **nodePtr)
+ResolveNew(RewriteInfo * info, List * targetlist, Node ** nodePtr)
 {
-    Node *node = *nodePtr;
-
-    if (node == NULL)
-	return;
-
-    switch(nodeTag(node)) {
-    case T_TargetEntry:
-	ResolveNew(info, targetlist, &((TargetEntry*)node)->expr);
-	break;
-    case T_Expr:
-	ResolveNew(info, targetlist, (Node**)(&(((Expr*)node)->args)));
-	break;
-    case T_Var: {
-	int this_varno = (int)((Var*)node)->varno;
-	Node *n;
-	    
-	if (this_varno == info->new_varno) {
-	    n = FindMatchingNew(targetlist,
-				((Var*)node)->varattno);
-	    if (n == NULL) {
-		if (info->event == CMD_UPDATE) {
-		    ((Var*)node)->varno = info->current_varno;
-		    ((Var*)node)->varnoold = info->current_varno;
-		} else {
-		    *nodePtr = make_null(((Var*)node)->vartype);
+	Node		   *node = *nodePtr;
+
+	if (node == NULL)
+		return;
+
+	switch (nodeTag(node))
+	{
+	case T_TargetEntry:
+		ResolveNew(info, targetlist, &((TargetEntry *) node)->expr);
+		break;
+	case T_Expr:
+		ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)));
+		break;
+	case T_Var:
+		{
+			int				this_varno = (int) ((Var *) node)->varno;
+			Node		   *n;
+
+			if (this_varno == info->new_varno)
+			{
+				n = FindMatchingNew(targetlist,
+									((Var *) node)->varattno);
+				if (n == NULL)
+				{
+					if (info->event == CMD_UPDATE)
+					{
+						((Var *) node)->varno = info->current_varno;
+						((Var *) node)->varnoold = info->current_varno;
+					}
+					else
+					{
+						*nodePtr = make_null(((Var *) node)->vartype);
+					}
+				}
+				else
+				{
+					*nodePtr = n;
+				}
+			}
+			break;
 		}
-	    } else {
-		*nodePtr = n;
-	    }
-	}
-	break;
-    }
-    case T_List: {
-	List *l;
-	foreach(l, (List*)node) {
-	    ResolveNew(info, targetlist, (Node**)&(lfirst(l)));
+	case T_List:
+		{
+			List		   *l;
+
+			foreach(l, (List *) node)
+			{
+				ResolveNew(info, targetlist, (Node **) & (lfirst(l)));
+			}
+			break;
+		}
+	default:
+		/* ignore the others */
+		break;
 	}
-	break;
-    }
-    default:
-	/* ignore the others */
-	break;
-    }
 }
 
 void
-FixNew(RewriteInfo* info, Query *parsetree)
+FixNew(RewriteInfo * info, Query * parsetree)
 {
-    ResolveNew(info, parsetree->targetList,
-	       (Node**)&(info->rule_action->targetList));
-    ResolveNew(info, parsetree->targetList, &info->rule_action->qual);
+	ResolveNew(info, parsetree->targetList,
+			   (Node **) & (info->rule_action->targetList));
+	ResolveNew(info, parsetree->targetList, &info->rule_action->qual);
 }
 
 static void
-nodeHandleRIRAttributeRule(Node **nodePtr,
-			   List *rtable,
-			   List *targetlist,
-			   int rt_index,
-			   int attr_num,
-			   int *modified,
-			   int *badsql)
+nodeHandleRIRAttributeRule(Node ** nodePtr,
+						   List * rtable,
+						   List * targetlist,
+						   int rt_index,
+						   int attr_num,
+						   int *modified,
+						   int *badsql)
 {
-    Node *node = *nodePtr;
+	Node		   *node = *nodePtr;
 
-    if (node == NULL)
-	return;
-    switch (nodeTag(node)) {
-    case T_List:
-	{
-	    List *i;
-	    foreach(i, (List*)node) {
-		nodeHandleRIRAttributeRule((Node**)(&(lfirst(i))), rtable,
-					   targetlist, rt_index, attr_num,
-					   modified, badsql);
-	    }
-	}
-	break;
-    case T_TargetEntry:
-	{
-	    TargetEntry *tle = (TargetEntry *)node;
-	    nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
-				       rt_index, attr_num, modified, badsql);
-	}
-	break;
-    case T_Expr:
-	{
-	    Expr *expr = (Expr *)node;
-	    nodeHandleRIRAttributeRule((Node**)(&(expr->args)), rtable,
-				       targetlist, rt_index, attr_num,
-				       modified, badsql);
-	}
-	break;
-    case T_Var:
+	if (node == NULL)
+		return;
+	switch (nodeTag(node))
 	{
-	    int this_varno = (int) ((Var*)node)->varno;
-	    NameData name_to_look_for;
-	    memset(name_to_look_for.data, 0, NAMEDATALEN);
-
-	    if (this_varno == rt_index &&
-		((Var*) node)->varattno == attr_num) {
-		if (((Var*)node)->vartype == 32) { /* HACK */
-		    *nodePtr = make_null(((Var*)node)->vartype);
-		    *modified = TRUE;
-		    *badsql = TRUE;
-		    break;
-		} else {
-		    namestrcpy(&name_to_look_for,
-			       (char *)get_attname(getrelid(this_varno,
-							    rtable),
-						   attr_num));
+	case T_List:
+		{
+			List		   *i;
+
+			foreach(i, (List *) node)
+			{
+				nodeHandleRIRAttributeRule((Node **) (&(lfirst(i))), rtable,
+										   targetlist, rt_index, attr_num,
+										   modified, badsql);
+			}
 		}
-	    }
-	    if (name_to_look_for.data[0]) {
-		Node *n;
-		
-		n = FindMatchingTLEntry(targetlist, (char *)&name_to_look_for);
-		if (n == NULL) {
-		    *nodePtr = make_null(((Var*) node)->vartype);
-		} else {
-		    *nodePtr = n;
+		break;
+	case T_TargetEntry:
+		{
+			TargetEntry    *tle = (TargetEntry *) node;
+
+			nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
+								   rt_index, attr_num, modified, badsql);
 		}
-		*modified = TRUE;
-	    }
+		break;
+	case T_Expr:
+		{
+			Expr		   *expr = (Expr *) node;
+
+			nodeHandleRIRAttributeRule((Node **) (&(expr->args)), rtable,
+									   targetlist, rt_index, attr_num,
+									   modified, badsql);
+		}
+		break;
+	case T_Var:
+		{
+			int				this_varno = (int) ((Var *) node)->varno;
+			NameData		name_to_look_for;
+
+			memset(name_to_look_for.data, 0, NAMEDATALEN);
+
+			if (this_varno == rt_index &&
+				((Var *) node)->varattno == attr_num)
+			{
+				if (((Var *) node)->vartype == 32)
+				{				/* HACK */
+					*nodePtr = make_null(((Var *) node)->vartype);
+					*modified = TRUE;
+					*badsql = TRUE;
+					break;
+				}
+				else
+				{
+					namestrcpy(&name_to_look_for,
+							   (char *) get_attname(getrelid(this_varno,
+															 rtable),
+													attr_num));
+				}
+			}
+			if (name_to_look_for.data[0])
+			{
+				Node		   *n;
+
+				n = FindMatchingTLEntry(targetlist, (char *) &name_to_look_for);
+				if (n == NULL)
+				{
+					*nodePtr = make_null(((Var *) node)->vartype);
+				}
+				else
+				{
+					*nodePtr = n;
+				}
+				*modified = TRUE;
+			}
+		}
+		break;
+	default:
+		/* ignore the others */
+		break;
 	}
-	break;
-    default:
-	/* ignore the others */
-	break;
-    }
 }
 
-/* 
+/*
  * Handles 'on retrieve to relation.attribute
- *          do instead retrieve (attribute = expression) w/qual'
+ *			do instead retrieve (attribute = expression) w/qual'
  */
 void
-HandleRIRAttributeRule(Query *parsetree,
-		       List *rtable,
-		       List *targetlist,
-		       int rt_index,
-		       int attr_num,
-		       int *modified,
-		       int *badsql)
+HandleRIRAttributeRule(Query * parsetree,
+					   List * rtable,
+					   List * targetlist,
+					   int rt_index,
+					   int attr_num,
+					   int *modified,
+					   int *badsql)
 {
-    nodeHandleRIRAttributeRule((Node**)(&(parsetree->targetList)), rtable,
-			       targetlist, rt_index, attr_num,
-			       modified, badsql);
-    nodeHandleRIRAttributeRule(&parsetree->qual, rtable, targetlist,
-			       rt_index, attr_num, modified, badsql);
+	nodeHandleRIRAttributeRule((Node **) (&(parsetree->targetList)), rtable,
+							   targetlist, rt_index, attr_num,
+							   modified, badsql);
+	nodeHandleRIRAttributeRule(&parsetree->qual, rtable, targetlist,
+							   rt_index, attr_num, modified, badsql);
 }
 
 
 static void
-nodeHandleViewRule(Node **nodePtr,
-		   List *rtable,
-		   List *targetlist,
-		   int rt_index,
-		   int *modified)
+nodeHandleViewRule(Node ** nodePtr,
+				   List * rtable,
+				   List * targetlist,
+				   int rt_index,
+				   int *modified)
 {
-    Node *node = *nodePtr;
-    
-    if (node == NULL)
-	return;
+	Node		   *node = *nodePtr;
 
-    switch (nodeTag(node)) {
-    case T_List:
-	{
-	    List *l;
-	    foreach (l, (List*)node) {
-		nodeHandleViewRule((Node**) (&(lfirst(l))),
-				   rtable, targetlist,
-				   rt_index, modified);
-	    }
-	}
-	break;
-    case T_TargetEntry:
-	{
-	    TargetEntry *tle = (TargetEntry *)node;
-	    nodeHandleViewRule(&(tle->expr), rtable, targetlist,
-			       rt_index, modified);
-	}
-	break;
-    case T_Expr:
-	{
-	    Expr *expr = (Expr*)node;
-	    nodeHandleViewRule((Node**)(&(expr->args)),
-			       rtable, targetlist,
-			       rt_index, modified);
-	}
-	break;
-    case T_Var:
+	if (node == NULL)
+		return;
+
+	switch (nodeTag(node))
 	{
-	    Var *var = (Var*)node;
-	    int this_varno = var->varno;
-	    Node *n;
-
-	    if (this_varno == rt_index) {
-		n = FindMatchingTLEntry(targetlist,
-					get_attname(getrelid(this_varno,
-							     rtable),
-						    var->varattno));
-		if (n == NULL) {
-		    *nodePtr = make_null(((Var*) node)->vartype);
-		} else {
-		    *nodePtr = n;
+	case T_List:
+		{
+			List		   *l;
+
+			foreach(l, (List *) node)
+			{
+				nodeHandleViewRule((Node **) (&(lfirst(l))),
+								   rtable, targetlist,
+								   rt_index, modified);
+			}
+		}
+		break;
+	case T_TargetEntry:
+		{
+			TargetEntry    *tle = (TargetEntry *) node;
+
+			nodeHandleViewRule(&(tle->expr), rtable, targetlist,
+							   rt_index, modified);
+		}
+		break;
+	case T_Expr:
+		{
+			Expr		   *expr = (Expr *) node;
+
+			nodeHandleViewRule((Node **) (&(expr->args)),
+							   rtable, targetlist,
+							   rt_index, modified);
 		}
-		*modified = TRUE;
-	    }
-	    break;
+		break;
+	case T_Var:
+		{
+			Var			   *var = (Var *) node;
+			int				this_varno = var->varno;
+			Node		   *n;
+
+			if (this_varno == rt_index)
+			{
+				n = FindMatchingTLEntry(targetlist,
+										get_attname(getrelid(this_varno,
+															 rtable),
+													var->varattno));
+				if (n == NULL)
+				{
+					*nodePtr = make_null(((Var *) node)->vartype);
+				}
+				else
+				{
+					*nodePtr = n;
+				}
+				*modified = TRUE;
+			}
+			break;
+		}
+	default:
+		/* ignore the others */
+		break;
 	}
-    default:
-	/* ignore the others */
-	break;
-    }
 }
 
 void
-HandleViewRule(Query *parsetree,
-	       List *rtable,
-	       List *targetlist,
-	       int rt_index,
-	       int *modified)
+HandleViewRule(Query * parsetree,
+			   List * rtable,
+			   List * targetlist,
+			   int rt_index,
+			   int *modified)
 {
-    nodeHandleViewRule(&parsetree->qual, rtable, targetlist, rt_index,
-		       modified);
-    nodeHandleViewRule((Node**)(&(parsetree->targetList)), rtable, targetlist,
-		       rt_index, modified);
+	nodeHandleViewRule(&parsetree->qual, rtable, targetlist, rt_index,
+					   modified);
+	nodeHandleViewRule((Node **) (&(parsetree->targetList)), rtable, targetlist,
+					   rt_index, modified);
 }
-