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

1 files changed, 81 insertions, 73 deletions

diff --git a/src/backend/optimizer/util/ordering.c b/src/backend/optimizer/util/ordering.c
index 40699e81e0b..504d48bdce5 100644
--- a/src/backend/optimizer/util/ordering.c
+++ b/src/backend/optimizer/util/ordering.c
@@ -1,13 +1,13 @@
 /*-------------------------------------------------------------------------
  *
  * ordering.c--
- *    Routines to manipulate and compare merge and path orderings
+ *	  Routines to manipulate and compare merge and path orderings
  *
  * Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.3 1997/08/19 21:32:06 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.4 1997/09/07 04:44:30 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -18,81 +18,88 @@
 #include "optimizer/internal.h"
 #include "optimizer/ordering.h"
 
-static bool equal_sortops_order(Oid *ordering1, Oid *ordering2);
+static bool		equal_sortops_order(Oid * ordering1, Oid * ordering2);
 
-/*    
+/*
  * equal-path-path-ordering--
- *    Returns t iff two path orderings are equal.
- *    
+ *	  Returns t iff two path orderings are equal.
+ *
  */
 bool
-equal_path_path_ordering(PathOrder *path_ordering1,
-			 PathOrder *path_ordering2)
+equal_path_path_ordering(PathOrder * path_ordering1,
+						 PathOrder * path_ordering2)
 {
-    if (path_ordering1 == path_ordering2)
-	return true;
-
-    if (!path_ordering1 || !path_ordering2)
-	return false;
-
-    if (path_ordering1->ordtype == MERGE_ORDER &&
-	path_ordering2->ordtype == MERGE_ORDER) {
-
-	return equal(path_ordering1->ord.merge, path_ordering2->ord.merge);
-
-    } else if (path_ordering1->ordtype == SORTOP_ORDER &&
-	       path_ordering2->ordtype == SORTOP_ORDER) {
-
-	return
-	    (equal_sortops_order(path_ordering1->ord.sortop,
-				 path_ordering2->ord.sortop));
-    } else if (path_ordering1->ordtype == MERGE_ORDER &&
-	       path_ordering2->ordtype == SORTOP_ORDER) {
-
-	return (path_ordering2->ord.sortop &&
-		(path_ordering1->ord.merge->left_operator ==
-		 path_ordering2->ord.sortop[0]));
-    } else {
-
-	return (path_ordering1->ord.sortop &&
-		(path_ordering1->ord.sortop[0] ==
-		 path_ordering2->ord.merge->left_operator));
-    }
+	if (path_ordering1 == path_ordering2)
+		return true;
+
+	if (!path_ordering1 || !path_ordering2)
+		return false;
+
+	if (path_ordering1->ordtype == MERGE_ORDER &&
+		path_ordering2->ordtype == MERGE_ORDER)
+	{
+
+		return equal(path_ordering1->ord.merge, path_ordering2->ord.merge);
+
+	}
+	else if (path_ordering1->ordtype == SORTOP_ORDER &&
+			 path_ordering2->ordtype == SORTOP_ORDER)
+	{
+
+		return
+			(equal_sortops_order(path_ordering1->ord.sortop,
+								 path_ordering2->ord.sortop));
+	}
+	else if (path_ordering1->ordtype == MERGE_ORDER &&
+			 path_ordering2->ordtype == SORTOP_ORDER)
+	{
+
+		return (path_ordering2->ord.sortop &&
+				(path_ordering1->ord.merge->left_operator ==
+				 path_ordering2->ord.sortop[0]));
+	}
+	else
+	{
+
+		return (path_ordering1->ord.sortop &&
+				(path_ordering1->ord.sortop[0] ==
+				 path_ordering2->ord.merge->left_operator));
+	}
 }
 
-/*    
+/*
  * equal-path-merge-ordering--
- *    Returns t iff a path ordering is usable for ordering a merge join.
+ *	  Returns t iff a path ordering is usable for ordering a merge join.
  *
  * XXX	Presently, this means that the first sortop of the path matches
- *    	either of the merge sortops.  Is there a "right" and "wrong"
- *    	sortop to match?
- *    
+ *		either of the merge sortops.  Is there a "right" and "wrong"
+ *		sortop to match?
+ *
  */
 bool
-equal_path_merge_ordering(Oid *path_ordering,
-			  MergeOrder *merge_ordering)
+equal_path_merge_ordering(Oid * path_ordering,
+						  MergeOrder * merge_ordering)
 {
-    if (path_ordering == NULL || merge_ordering == NULL)
-	return(false);
-
-    if (path_ordering[0] == merge_ordering->left_operator ||
-	path_ordering[0] == merge_ordering->right_operator)
-	return(true);
-    else
-	return(false);
+	if (path_ordering == NULL || merge_ordering == NULL)
+		return (false);
+
+	if (path_ordering[0] == merge_ordering->left_operator ||
+		path_ordering[0] == merge_ordering->right_operator)
+		return (true);
+	else
+		return (false);
 }
 
-/*    
+/*
  * equal-merge-merge-ordering--
- *    Returns t iff two merge orderings are equal.
- *    
+ *	  Returns t iff two merge orderings are equal.
+ *
  */
 bool
-equal_merge_merge_ordering(MergeOrder *merge_ordering1,
-			   MergeOrder *merge_ordering2)
+equal_merge_merge_ordering(MergeOrder * merge_ordering1,
+						   MergeOrder * merge_ordering2)
 {
-    return (equal(merge_ordering1, merge_ordering2));
+	return (equal(merge_ordering1, merge_ordering2));
 }
 
 /*****************************************************************************
@@ -101,21 +108,22 @@ equal_merge_merge_ordering(MergeOrder *merge_ordering1,
 
 /*
  * equal_sort_ops_order -
- *    Returns true iff the sort operators are in the same order.
+ *	  Returns true iff the sort operators are in the same order.
  */
-static bool
-equal_sortops_order(Oid *ordering1, Oid *ordering2)
+static			bool
+equal_sortops_order(Oid * ordering1, Oid * ordering2)
 {
-    int i = 0;
-
-    if (ordering1 == NULL || ordering2 == NULL)
-	return (ordering1==ordering2);
-    
-    while (ordering1[i]!=0 && ordering2[i]!=0) {
-	if (ordering1[i] != ordering2[i])
-	    break;
-	i++;
-    }
-
-    return (ordering1[i]==0 && ordering2[i]==0);
+	int				i = 0;
+
+	if (ordering1 == NULL || ordering2 == NULL)
+		return (ordering1 == ordering2);
+
+	while (ordering1[i] != 0 && ordering2[i] != 0)
+	{
+		if (ordering1[i] != ordering2[i])
+			break;
+		i++;
+	}
+
+	return (ordering1[i] == 0 && ordering2[i] == 0);
 }