1 files changed, 166 insertions, 142 deletions

diff --git a/src/backend/optimizer/util/var.c b/src/backend/optimizer/util/var.c
index 3eb0787e3ef..40abf5f80cb 100644
--- a/src/backend/optimizer/util/var.c
+++ b/src/backend/optimizer/util/var.c
@@ -1,13 +1,13 @@
 /*-------------------------------------------------------------------------
  *
  * var.c--
- *    Var node manipulation routines
+ *	  Var node manipulation routines
  *
  * Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.3 1996/11/06 09:29:26 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.4 1997/09/07 04:44:35 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -27,169 +27,193 @@
 #include "parser/parsetree.h"
 
 /*
- *	find_varnos
+ *		find_varnos
  *
- *	Descends down part of a parsetree (qual or tlist),
+ *		Descends down part of a parsetree (qual or tlist),
  *
- *	XXX assumes varno's are always integers, which shouldn't be true...
- *	(though it currently is, see primnodes.h)
+ *		XXX assumes varno's are always integers, which shouldn't be true...
+ *		(though it currently is, see primnodes.h)
  */
-List *
-pull_varnos(Node *me)
+List		   *
+pull_varnos(Node * me)
 {
-    List *i, *result = NIL;
-	
-    if (me == NULL)
-	return (NIL);
-
-    switch (nodeTag(me)) {
-    case T_List:
-	foreach (i, (List*)me) {
-	    result = nconc(result, pull_varnos(lfirst(i)));
+	List		   *i,
+				   *result = NIL;
+
+	if (me == NULL)
+		return (NIL);
+
+	switch (nodeTag(me))
+	{
+	case T_List:
+		foreach(i, (List *) me)
+		{
+			result = nconc(result, pull_varnos(lfirst(i)));
+		}
+		break;
+	case T_ArrayRef:
+		foreach(i, ((ArrayRef *) me)->refupperindexpr)
+			result = nconc(result, pull_varnos(lfirst(i)));
+		foreach(i, ((ArrayRef *) me)->reflowerindexpr)
+			result = nconc(result, pull_varnos(lfirst(i)));
+		result = nconc(result, pull_varnos(((ArrayRef *) me)->refassgnexpr));
+		break;
+	case T_Var:
+		result = lconsi(((Var *) me)->varno, NIL);
+		break;
+	default:
+		break;
 	}
-	break;
-    case T_ArrayRef:
-	foreach (i, ((ArrayRef*) me)->refupperindexpr) 
-	    result = nconc(result, pull_varnos(lfirst(i)));
-	foreach (i, ((ArrayRef*) me)->reflowerindexpr)
-	    result = nconc(result, pull_varnos(lfirst(i)));
-	result = nconc(result, pull_varnos(((ArrayRef*) me)->refassgnexpr));
-	break;
-    case T_Var:
-	result = lconsi(((Var*) me)->varno, NIL);
-	break;
-    default:
-	break;
-    }
-    return(result);
+	return (result);
 }
 
-/*    
+/*
  * contain_var_clause--
- *    Recursively find var nodes from a clause by pulling vars from the
- *    left and right operands of the clause.  
- *    
- *    Returns true if any varnode found.
+ *	  Recursively find var nodes from a clause by pulling vars from the
+ *	  left and right operands of the clause.
+ *
+ *	  Returns true if any varnode found.
  */
-bool contain_var_clause(Node *clause)
+bool
+contain_var_clause(Node * clause)
 {
-    if (clause==NULL) 
-	return FALSE;
-    else if (IsA(clause,Var))
-	return TRUE;
-    else if (IsA(clause,Iter))
-	return contain_var_clause(((Iter*)clause)->iterexpr);
-    else if (single_node(clause)) 
-	return FALSE;
-    else if (or_clause(clause)) {
-	List *temp;
-
-	foreach (temp, ((Expr*)clause)->args) {
-	    if (contain_var_clause(lfirst(temp)))
-		return TRUE;
-	}
-	return FALSE;
-    } else if (is_funcclause (clause)) {
-	List *temp;
-
-	foreach(temp, ((Expr *)clause)->args) {
-	    if (contain_var_clause(lfirst(temp)))
+	if (clause == NULL)
+		return FALSE;
+	else if (IsA(clause, Var))
 		return TRUE;
+	else if (IsA(clause, Iter))
+		return contain_var_clause(((Iter *) clause)->iterexpr);
+	else if (single_node(clause))
+		return FALSE;
+	else if (or_clause(clause))
+	{
+		List		   *temp;
+
+		foreach(temp, ((Expr *) clause)->args)
+		{
+			if (contain_var_clause(lfirst(temp)))
+				return TRUE;
+		}
+		return FALSE;
 	}
-	return FALSE;
-    } else if (IsA(clause,ArrayRef)) {
-	List *temp;
-
-	foreach(temp, ((ArrayRef*)clause)->refupperindexpr)  {
-	    if (contain_var_clause(lfirst(temp)))
-		return TRUE;
+	else if (is_funcclause(clause))
+	{
+		List		   *temp;
+
+		foreach(temp, ((Expr *) clause)->args)
+		{
+			if (contain_var_clause(lfirst(temp)))
+				return TRUE;
+		}
+		return FALSE;
 	}
-	foreach(temp, ((ArrayRef*)clause)->reflowerindexpr) {
-	    if (contain_var_clause(lfirst(temp)))
-		return TRUE;
+	else if (IsA(clause, ArrayRef))
+	{
+		List		   *temp;
+
+		foreach(temp, ((ArrayRef *) clause)->refupperindexpr)
+		{
+			if (contain_var_clause(lfirst(temp)))
+				return TRUE;
+		}
+		foreach(temp, ((ArrayRef *) clause)->reflowerindexpr)
+		{
+			if (contain_var_clause(lfirst(temp)))
+				return TRUE;
+		}
+		if (contain_var_clause(((ArrayRef *) clause)->refexpr))
+			return TRUE;
+		if (contain_var_clause(((ArrayRef *) clause)->refassgnexpr))
+			return TRUE;
+		return FALSE;
 	}
-	if (contain_var_clause(((ArrayRef*)clause)->refexpr))
-	    return TRUE;
-	if (contain_var_clause(((ArrayRef*)clause)->refassgnexpr))
-	    return TRUE;
-	return FALSE;
-    } else if (not_clause(clause))
-	return contain_var_clause((Node*)get_notclausearg((Expr*)clause));
-    else if (is_opclause(clause))
-	return (contain_var_clause((Node*)get_leftop((Expr*)clause)) ||
-		contain_var_clause((Node*)get_rightop((Expr*)clause)));
+	else if (not_clause(clause))
+		return contain_var_clause((Node *) get_notclausearg((Expr *) clause));
+	else if (is_opclause(clause))
+		return (contain_var_clause((Node *) get_leftop((Expr *) clause)) ||
+			  contain_var_clause((Node *) get_rightop((Expr *) clause)));
 
-    return FALSE;
+	return FALSE;
 }
 
-/*    
+/*
  * pull_var_clause--
- *    Recursively pulls all var nodes from a clause by pulling vars from the
- *    left and right operands of the clause.  
- *    
- *    Returns list of varnodes found.
+ *	  Recursively pulls all var nodes from a clause by pulling vars from the
+ *	  left and right operands of the clause.
+ *
+ *	  Returns list of varnodes found.
  */
-List *
-pull_var_clause(Node *clause)
+List		   *
+pull_var_clause(Node * clause)
 {
-    List *retval = NIL;
-
-    if (clause==NULL) 
-	return(NIL);
-    else if (IsA(clause,Var))
-	retval = lcons(clause,NIL);
-    else if (IsA(clause,Iter))
-	retval = pull_var_clause(((Iter*)clause)->iterexpr);
-    else if (single_node(clause)) 
-	retval = NIL;
-    else if (or_clause(clause)) {
-	List *temp;
-
-	foreach (temp, ((Expr*)clause)->args)
-	    retval = nconc(retval, pull_var_clause(lfirst(temp)));
-    } else if (is_funcclause (clause)) {
-	List *temp;
-
-	foreach(temp, ((Expr *)clause)->args)
-	    retval = nconc (retval,pull_var_clause(lfirst(temp)));
-    } else if (IsA(clause,Aggreg)) {
-	retval = pull_var_clause(((Aggreg*)clause)->target);
-    } else if (IsA(clause,ArrayRef)) {
-	List *temp;
-
-	foreach(temp, ((ArrayRef*)clause)->refupperindexpr) 
-	    retval = nconc (retval,pull_var_clause(lfirst(temp)));
-	foreach(temp, ((ArrayRef*)clause)->reflowerindexpr)
-	    retval = nconc (retval,pull_var_clause(lfirst(temp)));
-	retval = nconc(retval,
-		       pull_var_clause(((ArrayRef*)clause)->refexpr));
-	retval = nconc(retval,
-		       pull_var_clause(((ArrayRef*)clause)->refassgnexpr));
-    } else if (not_clause(clause))
-	retval = pull_var_clause((Node*)get_notclausearg((Expr*)clause));
-    else if (is_opclause(clause)) 
-	retval = nconc(pull_var_clause((Node*)get_leftop((Expr*)clause)),
-		       pull_var_clause((Node*)get_rightop((Expr*)clause)));
-    else
-	retval = NIL;
-
-    return (retval);
+	List		   *retval = NIL;
+
+	if (clause == NULL)
+		return (NIL);
+	else if (IsA(clause, Var))
+		retval = lcons(clause, NIL);
+	else if (IsA(clause, Iter))
+		retval = pull_var_clause(((Iter *) clause)->iterexpr);
+	else if (single_node(clause))
+		retval = NIL;
+	else if (or_clause(clause))
+	{
+		List		   *temp;
+
+		foreach(temp, ((Expr *) clause)->args)
+			retval = nconc(retval, pull_var_clause(lfirst(temp)));
+	}
+	else if (is_funcclause(clause))
+	{
+		List		   *temp;
+
+		foreach(temp, ((Expr *) clause)->args)
+			retval = nconc(retval, pull_var_clause(lfirst(temp)));
+	}
+	else if (IsA(clause, Aggreg))
+	{
+		retval = pull_var_clause(((Aggreg *) clause)->target);
+	}
+	else if (IsA(clause, ArrayRef))
+	{
+		List		   *temp;
+
+		foreach(temp, ((ArrayRef *) clause)->refupperindexpr)
+			retval = nconc(retval, pull_var_clause(lfirst(temp)));
+		foreach(temp, ((ArrayRef *) clause)->reflowerindexpr)
+			retval = nconc(retval, pull_var_clause(lfirst(temp)));
+		retval = nconc(retval,
+					   pull_var_clause(((ArrayRef *) clause)->refexpr));
+		retval = nconc(retval,
+				   pull_var_clause(((ArrayRef *) clause)->refassgnexpr));
+	}
+	else if (not_clause(clause))
+		retval = pull_var_clause((Node *) get_notclausearg((Expr *) clause));
+	else if (is_opclause(clause))
+		retval = nconc(pull_var_clause((Node *) get_leftop((Expr *) clause)),
+				 pull_var_clause((Node *) get_rightop((Expr *) clause)));
+	else
+		retval = NIL;
+
+	return (retval);
 }
 
-/*    
- *    	var_equal
- *    
- *    	Returns t iff two var nodes correspond to the same attribute.
+/*
+ *		var_equal
+ *
+ *		Returns t iff two var nodes correspond to the same attribute.
  */
 bool
-var_equal(Var *var1, Var *var2)
+var_equal(Var * var1, Var * var2)
 {
-    if (IsA (var1,Var) && IsA (var2,Var) &&
-	(((Var*)var1)->varno ==  ((Var*)var2)->varno) &&
-	(((Var*)var1)->vartype == ((Var*)var2)->vartype) && 
-	(((Var*)var1)->varattno == ((Var*)var2)->varattno)) {
-
-	return(true);
-    } else 
-	return(false);
+	if (IsA(var1, Var) && IsA(var2, Var) &&
+		(((Var *) var1)->varno == ((Var *) var2)->varno) &&
+		(((Var *) var1)->vartype == ((Var *) var2)->vartype) &&
+		(((Var *) var1)->varattno == ((Var *) var2)->varattno))
+	{
+
+		return (true);
+	}
+	else
+		return (false);
 }