Index: trunk/psLib/src/collections/psBitSet.c
===================================================================
--- trunk/psLib/src/collections/psBitSet.c	(revision 1440)
+++ trunk/psLib/src/collections/psBitSet.c	(revision 1807)
@@ -1,3 +1,2 @@
-
 /** @file  psBitSet.c
  *
@@ -10,16 +9,12 @@
  *
  *  @author Ross Harman, MHPCC
- *
- *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-09 23:34:57 $
+ *  @author Robert DeSonia, MHPCC
+ *
+ *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-09-14 20:01:52 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
  */
 
-/******************************************************************************/
-
-/*  INCLUDE FILES                                                             */
-
-/******************************************************************************/
 #include <string.h>
 #include <stdio.h>
@@ -32,43 +27,17 @@
 #include "psError.h"
 #include "psAbort.h"
-
-/******************************************************************************/
-
-/*  DEFINE STATEMENTS                                                         */
-
-/******************************************************************************/
-
-// None
-
-/******************************************************************************/
-
-/*  TYPE DEFINITIONS                                                          */
-
-/******************************************************************************/
-
-// None
-
-/*****************************************************************************/
-
-/*  GLOBAL VARIABLES                                                         */
-
-/*****************************************************************************/
-
-// None
-
-/*****************************************************************************/
-
-/*  FILE STATIC VARIABLES                                                    */
-
-/*****************************************************************************/
-
-// None
-
-/*****************************************************************************/
-
-/*  FUNCTION IMPLEMENTATION - LOCAL                                          */
-
-/*****************************************************************************/
-static void psBitSetFree(psBitSet* restrict inBitSet);
+#include "psString.h"
+
+#include "psCollectionsErrors.h"
+
+enum {
+    UNKNOWN_OP,
+    AND_OP,
+    OR_OP,
+    XOR_OP,
+    NOT_OP
+};
+
+static void bitSetFree(psBitSet* restrict inBitSet);
 
 /** Private function to create a mask.
@@ -90,9 +59,12 @@
 }
 
-/*****************************************************************************/
-
-/* FUNCTION IMPLEMENTATION - PUBLIC                                          */
-
-/*****************************************************************************/
+static void bitSetFree(psBitSet* restrict inBitSet)
+{
+    if (inBitSet == NULL) {
+        return;
+    }
+    psFree(inBitSet->bits);
+}
+
 psBitSet* psBitSetAlloc(int n)
 {
@@ -100,15 +72,15 @@
     psBitSet* newObj = NULL;
 
-    if (n <= 0) {
-        psError(__func__, " : Line %d - Allocation size must be > 0: size = %d", __LINE__, n);
-        return 0;
+    if (n < 0) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetAlloc",
+                   PS_ERR_BAD_PARAMETER_VALUE, true,
+                   PS_ERRORTEXT_psBitSet_ALLOC_NEG_SIZE,
+                   n);
+        return NULL;
     }
 
     numBytes = ceil(n / 8.0);
     newObj = psAlloc(sizeof(psBitSet));
-    if (newObj == NULL) {
-        psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__);
-    }
-    p_psMemSetDeallocator(newObj, (psFreeFcn) psBitSetFree);
+    p_psMemSetDeallocator(newObj, (psFreeFcn) bitSetFree);
     newObj->n = numBytes;
 
@@ -116,22 +88,10 @@
     /* @i@ */
     newObj->bits = psAlloc(sizeof(char) * numBytes);
-    if (newObj->bits == NULL) {
-        psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__);
-    }
-
-    memset(newObj->bits, numBytes, 0);
+
+    memset(newObj->bits, 0, numBytes);
 
     return newObj;
 }
 
-static void psBitSetFree(psBitSet* restrict inBitSet)
-{
-    if (inBitSet == NULL) {
-        psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__);
-        return;
-    }
-    psFree(inBitSet->bits);
-}
-
 psBitSet* psBitSetSet(psBitSet* inBitSet, int bit)
 {
@@ -139,11 +99,14 @@
 
     if (inBitSet == NULL) {
-        psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__);
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetSet",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psBitSet_SET_NULL);
         return inBitSet;
-    } else if (bit < 0) {
-        psError(__func__, " : Line %d - Bit position too small: %d", __LINE__, bit);
-        return inBitSet;
-    } else if (bit > inBitSet->n * 8 - 1) {
-        psError(__func__, " : Line %d - Bit position too large: %d", __LINE__, bit);
+    } else if ( (bit < 0) ||
+                (bit > inBitSet->n * 8 - 1) ) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetSet",
+                   PS_ERR_BAD_PARAMETER_VALUE, true,
+                   PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
+                   bit,inBitSet->n * 8 - 1);
         return inBitSet;
     }
@@ -155,4 +118,28 @@
 }
 
+psBitSet* psBitSetClear(psBitSet* inBitSet, int bit)
+{
+    char *byte = NULL;
+
+    if (inBitSet == NULL) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetClear",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psBitSet_SET_NULL);
+        return inBitSet;
+    } else if ( (bit < 0) ||
+                (bit > inBitSet->n * 8 - 1) ) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetClear",
+                   PS_ERR_BAD_PARAMETER_VALUE, true,
+                   PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
+                   bit,inBitSet->n * 8 - 1);
+        return inBitSet;
+    }
+    // Variable byte is the byte in the array that contains the bit to be set
+    byte = inBitSet->bits + bit / 8;
+    *byte &= ! mask(bit);
+
+    return inBitSet;
+}
+
 bool psBitSetTest(const psBitSet* inBitSet, int bit)
 {
@@ -160,20 +147,20 @@
 
     if (inBitSet == NULL) {
-        psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__);
-        return 0;
-    } else if (bit < 0) {
-        psError(__func__, " : Line %d - Bit position too small: %d", __LINE__, bit);
-        return 0;
-    } else if (bit > inBitSet->n * 8 - 1) {
-        psError(__func__, " : Line %d - Bit position too large: %d", __LINE__, bit);
-        return 0;
-    }
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetTest",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psBitSet_SET_NULL);
+        return false;
+    } else if ( (bit < 0) ||
+                (bit > inBitSet->n * 8 - 1) ) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetTest",
+                   PS_ERR_BAD_PARAMETER_VALUE, true,
+                   PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
+                   bit,inBitSet->n * 8 - 1);
+        return false;
+    }
+
     // Variable byte is the byte in the array that contains the bit to be tested
     byte = inBitSet->bits + bit / 8;
-    if ((int)(*byte & mask(bit)) == 0) {
-        return 0;
-    }
-
-    return 1;
+    return ((*byte & mask(bit)) != 0);
 }
 
@@ -183,57 +170,108 @@
     int i = 0;
     int n = 0;
-    char tempChar = '0';
-    char *outBits = NULL;
-    char *inBits1 = NULL;
-    char *inBits2 = NULL;
+    char* outBits = NULL;
+    char* inBits1 = NULL;
+    char* inBits2 = NULL;
+    int op = UNKNOWN_OP;
 
     if (inBitSet1 == NULL) {
-        psError(__func__, " : Line %d - Null psBitSet for inBitSet1 argument", __LINE__);
-        return outBitSet;
-    }
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetOp",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psBitSet_FIRST_OPERAND_NULL);
+        psFree(outBitSet);
+        return NULL;
+    }
+    inBits1 = inBitSet1->bits;
 
     if (operator == NULL) {
-        psError(__func__, " : Line %d - Null input operator\n", __LINE__);
-        return outBitSet;
-    }
-
-    if (inBitSet2 == NULL) {
-        psError(__func__, " : Line %d - Null psBitSet for inBitSet2 argument", __LINE__);
-        return outBitSet;
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetOp",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psBitSet_OPERATOR_NULL);
+        psFree(outBitSet);
+        return NULL;
+    }
+
+    // make operator all caps
+    int tempStrLen = strlen(operator);
+    char* tempStr = psAlloc(tempStrLen+1);
+
+    for (int lcv=0;lcv<tempStrLen;lcv++) {
+        tempStr[lcv] = (char)toupper(operator[lcv]);
+    }
+    tempStr[tempStrLen] = '\0';
+
+    // parse the operator
+    if (strcmp(operator,"AND")==0) {
+        op = AND_OP;
+    } else if (strcmp(operator,"OR")==0) {
+        op = OR_OP;
+    } else if (strcmp(operator,"XOR")==0) {
+        op = XOR_OP;
+    } else if (strcmp(operator,"NOT")==0) {
+        op = NOT_OP;
+    } else {
+        psFree(tempStr);
+        psFree(outBitSet);
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetOp",
+                   PS_ERR_BAD_PARAMETER_VALUE, true,
+                   PS_ERRORTEXT_psBitSet_OPERATOR_INVALID,
+                   operator);
+        return NULL;
+    }
+    psFree(tempStr);
+
+    if (op != NOT_OP) {
+        if (inBitSet2 == NULL) {
+            psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetOp",
+                       PS_ERR_BAD_PARAMETER_NULL, true,
+                       PS_ERRORTEXT_psBitSet_SECOND_OPERAND_NULL);
+            psFree(outBitSet);
+            return NULL;
+        }
+
+        if (inBitSet1->n != inBitSet2->n) {
+            psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetOp",
+                       PS_ERR_BAD_PARAMETER_SIZE, true,
+                       PS_ERRORTEXT_psBitSet_OPERANDS_SIZE_DIFFER);
+            psFree(outBitSet);
+            return NULL;
+        }
+        inBits2 = inBitSet2->bits;
     }
 
     if (outBitSet == NULL) {
-        outBitSet = psBitSetAlloc(inBitSet1->n * 8);
-    }
-
-    if (inBitSet1->n != inBitSet2->n || outBitSet->n != inBitSet1->n) {
-        psError(__func__, " : Line %d - psBitSet sizes not the same", __LINE__);
-        return outBitSet;
+        outBitSet = psBitSetAlloc(inBitSet1->n*8);
+    } else if (outBitSet->n != inBitSet1->n) {
+        outBitSet->n = inBitSet1->n;
+        outBitSet->bits = psRealloc(outBitSet->bits, inBitSet1->n);
     }
 
     n = outBitSet->n;
     outBits = outBitSet->bits;
-    inBits1 = inBitSet1->bits;
-    inBits2 = inBitSet2->bits;
-
-    tempChar = toupper(operator[0]);
-    switch (tempChar) {
-    case 'A':
+
+    switch (op) {
+    case AND_OP:
         for (i = 0; i < n; i++) {
             outBits[i] = inBits1[i] & inBits2[i];
         }
         break;
-    case 'O':
+    case OR_OP:
         for (i = 0; i < n; i++) {
             outBits[i] = inBits1[i] | inBits2[i];
         }
         break;
-    case 'X':
+    case XOR_OP:
         for (i = 0; i < n; i++) {
             outBits[i] = inBits1[i] ^ inBits2[i];
         }
         break;
+    case NOT_OP:
+        for (i = 0; i < n; i++) {
+            outBits[i] = ~inBits1[i];
+        }
+        break;
     default:
-        psError(__func__, " : Line %d - Invalid psBitMask binary operation: %s", __LINE__, operator);
+        psAbort(PS_ERRORNAME_DOMAIN "psBitSetOp",
+                "Unexpected error - operator parsed successfully but not valid?");
     }
 
@@ -243,34 +281,18 @@
 psBitSet* psBitSetNot(psBitSet* outBitSet, const psBitSet* restrict inBitSet)
 {
-    int i = 0;
-    int n = 0;
-    char *outBits = NULL;
-    char *inBits = NULL;
-
-    if (inBitSet == NULL) {
-        psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__);
-        return outBitSet;
-    }
-
-    n = inBitSet->n;
-    if (n == 0) {
-        psError(__func__, " : Line %d - No elements in inBitSet", __LINE__);
-        return outBitSet;
-    }
+    if (inBitSet == NULL) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetNot",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psBitSet_OPERAND_NULL);
+        psFree(outBitSet);
+        return NULL;
+    }
+
+    outBitSet = psBitSetOp(outBitSet,inBitSet,"NOT",NULL);
 
     if (outBitSet == NULL) {
-        outBitSet = psBitSetAlloc(n * 8);
-    }
-
-    if (inBitSet->n != outBitSet->n) {
-        psError(__func__, " : Line %d - psBitSet sizes not the same", __LINE__);
-        return outBitSet;
-    }
-
-    outBits = outBitSet->bits;
-    inBits = inBitSet->bits;
-
-    for (i = 0; i < n; i++) {
-        outBits[i] = ~inBits[i];
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psBitSetNot",
+                   PS_ERR_UNKNOWN, false,
+                   PS_ERRORTEXT_psBitSet_NOT_OP_FAILED);
     }
 
@@ -284,10 +306,6 @@
     char *outString = psAlloc((size_t) numBits + 1);
 
-    if (outString == NULL) {
-        psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__);
-    }
-
     for (i = 0; i < numBits; i++) {
-        outString[numBits - i - 1] = (psBitSetTest(inBitSet, i) == 1) ? '1' : '0';
+        outString[numBits - i - 1] = psBitSetTest(inBitSet, i) ? '1' : '0';
     }