IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9538


Ignore:
Timestamp:
Oct 13, 2006, 11:13:48 AM (20 years ago)
Author:
Paul Price
Message:

Synchronising with SDRS, and cleaning up:

  • Replaced is_psType() with PS_ASSERT_PTR() throughout psLib.
  • Changed "char *" to "psString" where appropriate in psDB and a few other places (to indicate pointers on the PS memory system).
  • Removed psLogArguments and psTraceArguments (functionality in psArgumentVerbosity).
  • Renamed psMetadataLookupMD to psMetadataLookupMetadata (it was about time...). Similarly with the psPolynomial?D{From,To}MD functions.
  • Removed psMetadataRemove() since it is ambiguous about what's removed --- use psMetadataRemove{Key,Index}.
  • psArrayRemoveByPos --> psArrayRemoveIndex
  • psArrayRemove --> psArrayRemoveData
Location:
trunk/psLib/src
Files:
39 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astro/psCoord.c

    r8245 r9538  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.123 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-08-09 02:26:44 $
     12*  @version $Revision: 1.124 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-10-13 21:13:47 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    222222bool psMemCheckPlane(psPtr ptr)
    223223{
    224     if (!is_psType(ptr)) {
    225         return false;
    226     }
     224    PS_ASSERT_PTR(ptr, false);
    227225    return ( psMemGetDeallocator(ptr) == (psFreeFunc)planeFree );
    228226}
    … …  
    230228bool psMemCheckSphere(psPtr ptr)
    231229{
    232     if (!is_psType(ptr)) {
    233         return false;
    234     }
     230    PS_ASSERT_PTR(ptr, false);
    235231    return ( psMemGetDeallocator(ptr) == (psFreeFunc)sphereFree );
    236232}
    … …  
    238234bool psMemCheckCube(psPtr ptr)
    239235{
    240     if (!is_psType(ptr)) {
    241         return false;
    242     }
     236    PS_ASSERT_PTR(ptr, false);
    243237    return ( psMemGetDeallocator(ptr) == (psFreeFunc)cubeFree );
    244238}
    … …  
    246240bool psMemCheckPlaneTransform(psPtr ptr)
    247241{
    248     if (!is_psType(ptr)) {
    249         return false;
    250     }
     242    PS_ASSERT_PTR(ptr, false);
    251243    return ( psMemGetDeallocator(ptr) == (psFreeFunc)planeTransformFree );
    252244}
    … …  
    295287bool psMemCheckPlaneDistort(psPtr ptr)
    296288{
    297     if (!is_psType(ptr)) {
    298         return false;
    299     }
     289    PS_ASSERT_PTR(ptr, false);
    300290    return ( psMemGetDeallocator(ptr) == (psFreeFunc)planeDistortFree );
    301291}
    … …  
    353343bool psMemCheckProjection(psPtr ptr)
    354344{
    355     if (!is_psType(ptr)) {
    356         return false;
    357     }
     345    PS_ASSERT_PTR(ptr, false);
    358346    return ( psMemGetDeallocator(ptr) == (psFreeFunc)projectionFree );
    359347}

  • trunk/psLib/src/astro/psSphereOps.c

    r8232 r9538  
    88 *  @author Dave Robbins, MHPCC
    99 *
    10  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-08-08 23:32:22 $
     10 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-10-13 21:13:47 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    8383bool psMemCheckSphereRot(psPtr ptr)
    8484{
    85     if (!is_psType(ptr)) {
    86         return false;
    87     }
     85    PS_ASSERT_PTR(ptr, false);
    8886    //See if the ptr corresponds to a psSphereRot*
    8987    return ( psMemGetDeallocator(ptr) == (psFreeFunc)sphereRotFree );

  • trunk/psLib/src/db/psDB.c

    r9422 r9538  
    1212 *  @author Joshua Hoblitt
    1313 *
    14  *  @version $Revision: 1.100 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-10-09 22:11:34 $
     14 *  @version $Revision: 1.101 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-10-13 21:13:47 $
    1616 *
    1717 *  Copyright (C) 2005-2006  Joshua Hoblitt, University of Hawaii
    … …  
    7676
    7777// SQL generation functions
    78 static char    *psDBGenerateCreateTableSQL(const char *tableName, const psMetadata *where);
    79 static char    *psDBGenerateSelectRowSQL(const char *tableName, const char *col,
     78static psString psDBGenerateCreateTableSQL(const char *tableName, const psMetadata *where);
     79static psString psDBGenerateSelectRowSQL(const char *tableName, const char *col,
    8080        const psMetadata *where, psU64 limit);
    81 static char    *psDBGenerateInsertRowSQL(const char *tableName, const psMetadata *row);
    82 static char    *psDBGenerateUpdateRowSQL(const char *tableName, const psMetadata *where,
     81static psString psDBGenerateInsertRowSQL(const char *tableName, const psMetadata *row);
     82static psString psDBGenerateUpdateRowSQL(const char *tableName, const psMetadata *where,
    8383        const psMetadata *values);
    84 static char    *psDBGenerateDeleteRowSQL(const char *tableName, const psMetadata *where,
     84static psString psDBGenerateDeleteRowSQL(const char *tableName, const psMetadata *where,
    8585        unsigned long long limit);
    86 static char    *psDBGenerateSetSQL(const psMetadata *set
     86static psString psDBGenerateSetSQL(const psMetadata *set
    8787                                  );
    8888static char *psDBGenerateConditionalSQL(const psMetadataItem *item, const char *tableName);
    … …  
    9090// lookup table functions
    9191static psElemType psDBMySQLToPType(enum enum_field_types type, unsigned int flags);
    92 static char    *psDBPTypeToSQL(psElemType pType);
     92static psString psDBPTypeToSQL(psElemType pType);
    9393static mysqlType *psDBPTypeToMySQL(psElemType pType);
    9494
    … …  
    116116static psPtr    psDBGetPTypeNaN(psElemType pType);
    117117static bool     psDBIsPTypeNaN(psElemType pType, psPtr data);
    118 
    119118
    120119// public functions
    … …  
    228227    PS_ASSERT_PTR_NON_NULL(dbname, false);
    229228
    230     char *query = NULL;
     229    psString query = NULL;
    231230    psStringAppend(&query, "CREATE DATABASE %s", dbname);
    232231
    … …  
    294293
    295294    // Generate SQL query string
    296     char *query = psDBGenerateCreateTableSQL(tableName, md);
     295    psString query = psDBGenerateCreateTableSQL(tableName, md);
    297296    if (!query) {
    298297        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    … …  
    320319
    321320    // Create SQL command string to drop table
    322     char *query = NULL;
     321    psString query = NULL;
    323322    psStringAppend(&query, "DROP TABLE %s", tableName);
    324323
    … …  
    354353
    355354    // Generate SQL query string
    356     char *query = psDBGenerateSelectRowSQL(tableName, col, NULL, limit);
     355    psString query = psDBGenerateSelectRowSQL(tableName, col, NULL, limit);
    357356    if (!query) {
    358357        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    … …  
    541540
    542541    // Create select row query
    543     char *query = psDBGenerateSelectRowSQL(tableName, NULL, where, limit);
     542    psString query = psDBGenerateSelectRowSQL(tableName, NULL, where, limit);
    544543    if (!query) {
    545544        psError(PS_ERR_UNEXPECTED_NULL, false, "Query generation failed.");
    … …  
    597596
    598597    // Generate SQL query string
    599     char *query = psDBGenerateInsertRowSQL(tableName, row);
     598    psString query = psDBGenerateInsertRowSQL(tableName, row);
    600599    if (!query) {
    601600        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    … …  
    692691
    693692    // Generate SQL query to update row
    694     char *query = psDBGenerateUpdateRowSQL(tableName, where, values);
     693    psString query = psDBGenerateUpdateRowSQL(tableName, where, values);
    695694    if (!query) {
    696695        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    … …  
    720719
    721720    // Create SQL statement string
    722     char *query = psDBGenerateDeleteRowSQL(tableName, where,limit);
     721    psString query = psDBGenerateDeleteRowSQL(tableName, where,limit);
    723722    if (!query) {
    724723        psError(PS_ERR_UNEXPECTED_NULL, false, "Query generation failed.");
    … …  
    809808    PS_ASSERT_PTR_NON_NULL(format, false);
    810809
    811     char *query = NULL;
     810    psString query = NULL;
    812811
    813812    // Run query
    … …  
    847846    PS_ASSERT_PTR_NON_NULL(format, -1);
    848847
    849     char *query = NULL;
     848    psString query = NULL;
    850849
    851850    // generate query string
    … …  
    12291228/*****************************************************************************/
    12301229
    1231 static char *psDBGenerateCreateTableSQL(const char *tableName,
    1232                                         const psMetadata *table)
     1230static psString psDBGenerateCreateTableSQL(const char *tableName,
     1231        const psMetadata *table)
    12331232{
    12341233    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
    … …  
    13321331}
    13331332
    1334 static char *psDBGenerateSelectRowSQL(const char *tableName,
    1335                                       const char *col,
    1336                                       const psMetadata *where,
    1337                                       psU64 limit)
     1333static psString psDBGenerateSelectRowSQL(const char *tableName,
     1334        const char *col,
     1335        const psMetadata *where,
     1336        psU64 limit)
    13381337{
    13391338    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
    … …  
    13741373}
    13751374
    1376 static char *psDBGenerateInsertRowSQL(const char *tableName,
    1377                                       const psMetadata *row)
     1375static psString psDBGenerateInsertRowSQL(const char *tableName,
     1376        const psMetadata *row)
    13781377{
    13791378    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
    … …  
    14221421}
    14231422
    1424 static char *psDBGenerateUpdateRowSQL(const char *tableName,
    1425                                       const psMetadata *where,
    1426                                       const psMetadata *values)
     1423static psString psDBGenerateUpdateRowSQL(const char *tableName,
     1424        const psMetadata *where,
     1425        const psMetadata *values)
    14271426{
    14281427    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
    … …  
    14551454}
    14561455
    1457 static char *psDBGenerateDeleteRowSQL(const char *tableName,
    1458                                       const psMetadata *where,
    1459                                       unsigned long long limit)
     1456static psString psDBGenerateDeleteRowSQL(const char *tableName,
     1457        const psMetadata *where,
     1458        unsigned long long limit)
    14601459{
    14611460    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
    … …  
    14921491}
    14931492
    1494 char *psDBGenerateWhereSQL(const psMetadata *where, const char *tableName)
     1493psString psDBGenerateWhereSQL(const psMetadata *where, const char *tableName)
    14951494{
    14961495    PS_ASSERT_PTR_NON_NULL(where, NULL);
    … …  
    15041503}
    15051504
    1506 char *psDBGenerateWhereConditionSQL(const psMetadata *where, const char *tableName)
     1505psString psDBGenerateWhereConditionSQL(const psMetadata *where, const char *tableName)
    15071506{
    15081507    PS_ASSERT_PTR_NON_NULL(where, NULL);
    15091508
    1510     char *query = NULL;
     1509    psString query = NULL;
    15111510
    15121511    // we need to know if an item is 'MULTI' so we have to march through the
    … …  
    15401539            psStringAppend(&query, "(");
    15411540            while ((mItem = psListGetAndIncrement(mCursor))) {
    1542                 char *conditional = psDBGenerateConditionalSQL(mItem, tableName);
     1541                psString conditional = psDBGenerateConditionalSQL(mItem, tableName);
    15431542                if (!conditional) {
    15441543                    psError(PS_ERR_UNKNOWN, false,
    … …  
    15641563            psStringAppend(&query, ")");
    15651564        } else {
    1566             char *conditional = psDBGenerateConditionalSQL(item, tableName);
     1565            psString conditional = psDBGenerateConditionalSQL(item, tableName);
    15671566            if (!conditional) {
    15681567                psError(PS_ERR_UNKNOWN, false,
    … …  
    15901589}
    15911590
    1592 static char *psDBGenerateSetSQL(const psMetadata *set
    1593                                )
     1591static psString psDBGenerateSetSQL(const psMetadata *set
     1592                                  )
    15941593{
    15951594    PS_ASSERT_PTR_NON_NULL(set
    15961595                           , NULL);
    15971596
    1598     char *query = psStringCopy("SET ");
     1597    psString query = psStringCopy("SET ");
    15991598
    16001599    psListIterator *cursor = psListIteratorAlloc(set
    … …  
    16181617}
    16191618
    1620 static char *psDBGenerateConditionalSQL(const psMetadataItem *item, const char *tableName)
     1619static psString psDBGenerateConditionalSQL(const psMetadataItem *item, const char *tableName)
    16211620{
    16221621    PS_ASSERT_PTR_NON_NULL(item, NULL);
    16231622
    1624     char *query = NULL;
     1623    psString query = NULL;
    16251624
    16261625    // stringify the psMetadataItem into a SQL search specification
    … …  
    17251724}
    17261725
    1727 static char *psDBPTypeToSQL(psElemType pType)
     1726static psString psDBPTypeToSQL(psElemType pType)
    17281727{
    17291728    psHash          *pTypeToSQLTable;   // type lookup table
    … …  
    19861985    PS_ASSERT_PTR_NON_NULL(lookupTable, );
    19871986
    1988     char *key = psDBIntToString((psU64)type);
    1989     char *value = psStringCopy(string);
     1987    psString key = psDBIntToString((psU64)type);
     1988    psString value = psStringCopy(string);
    19901989
    19911990    psHashAdd(lookupTable, key, value);
    … …  
    20012000    PS_ASSERT_PTR_NON_NULL(lookupTable, );
    20022001
    2003     char *key = psDBIntToString((psU64)type);
     2002    psString key = psDBIntToString((psU64)type);
    20042003
    20052004    psHashAdd(lookupTable, key, value);
    … …  
    21242123    return isNaN;
    21252124}
    2126 
    21272125
    21282126// string utility functions
    … …  
    21352133    size_t length = n ? (size_t)log10((double)n) + 1 + 1
    21362134                    : 2;
    2137     char *string = psAlloc(length);
     2135    psString string = psStringAlloc(length);
    21382136    snprintf(string, length, "%li", (long int)n);
    21392137

  • trunk/psLib/src/db/psDB.h

    r9422 r9538  
    1010 *  @author Joshua Hoblitt
    1111 *
    12  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-10-09 22:11:34 $
     12 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-10-13 21:13:47 $
    1414 *
    1515 *  Copyright 2005 Joshua Hoblitt, University of Hawaii
    … …  
    381381 * @return psString:   A psString or NULL on failure
    382382 */
    383 char    *psDBGenerateWhereSQL(
     383psString psDBGenerateWhereSQL(
    384384    const psMetadata *where,           ///< Row match criteria
    385385    const char *tableName              ///< Table name
    … …  
    394394 * @return psString:   A psString or NULL on failure
    395395 */
    396 char *psDBGenerateWhereConditionSQL(
     396psString psDBGenerateWhereConditionSQL(
    397397    const psMetadata *where,           ///< Row match criteria
    398398    const char *tableName              ///< Table name

  • trunk/psLib/src/fits/psFits.c

    r8232 r9538  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-08-08 23:32:23 $
     9 *  @version $Revision: 1.59 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-10-13 21:13:47 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1818#include "string.h"
    1919#include "psError.h"
    20 
     20#include "psAssert.h"
    2121#include "psImageStructManip.h"
    2222#include "psMemory.h"
    … …  
    174174bool psMemCheckFits(psPtr ptr)
    175175{
    176     if (!is_psType(ptr)) {
    177         return false;
    178     }
     176    PS_ASSERT_PTR(ptr, false);
    179177    return ( psMemGetDeallocator(ptr) == (psFreeFunc)fitsFree );
    180178}

  • trunk/psLib/src/fits/psFitsImage.c

    r8627 r9538  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-08-26 04:34:28 $
     9 *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-10-13 21:13:47 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1717#include <string.h>
    1818
     19#include "psFits.h"
    1920#include "psAssert.h"
    20 #include "psFits.h"
    2121#include "psFitsImage.h"
    2222#include "psError.h"

  • trunk/psLib/src/imageops/psImageConvolve.c

    r8232 r9538  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2006-08-08 23:32:23 $
     7 *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-10-13 21:13:48 $
    99 *
    1010 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2020#include "psLogMsg.h"
    2121#include "psError.h"
     22#include "psAssert.h"
    2223
    2324
    … …  
    9091bool psMemCheckKernel(psPtr ptr)
    9192{
    92     if (!is_psType(ptr)) {
    93         return false;
    94     }
     93    PS_ASSERT_PTR(ptr, false);
    9594    return ( psMemGetDeallocator(ptr) == (psFreeFunc)freeKernel );
    9695}

  • trunk/psLib/src/imageops/psImageStructManip.c

    r8232 r9538  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-08-08 23:32:23 $
     10 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-10-13 21:13:48 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9797        // if a child, need to orphan (disassociate from parent) first
    9898        if (out->parent != NULL) {
    99             psArrayRemove(out->parent->children,psMemIncrRefCounter(out));
     99            psArrayRemoveData(out->parent->children,psMemIncrRefCounter(out));
    100100            // remove from parent's knowledge without triggering a free
    101101            out->parent = NULL; // break link to parent

  • trunk/psLib/src/math/psMatrix.c

    r8627 r9538  
    2121 *  @author Robert DeSonia, MHPCC
    2222 *
    23  *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2006-08-26 04:34:28 $
     23 *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2006-10-13 21:13:48 $
    2525 *
    2626 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    308308// This is a temporary gauss-jordan solver based on gene's
    309309// version based on the Numerical Recipes version
    310 bool psMatrixGJSolve(
    311     psImage *a,
    312     psVector *b)
    313 {
     310bool psMatrixGJSolve(psImage *a,
     311                     psVector *b
     312                    )
     313{
     314    PS_ASSERT_IMAGE_NON_NULL(a, false);
     315    PS_ASSERT_VECTOR_NON_NULL(b, false);
     316    PS_ASSERT_IMAGE_TYPE(a, PS_TYPE_F64, false);
     317    PS_ASSERT_VECTOR_TYPE(b, PS_TYPE_F64, false);
     318    PS_ASSERT_INT_EQUAL(a->numCols, a->numRows, false);
     319    int Nx = a->numCols;
     320    PS_ASSERT_VECTOR_SIZE(b, (long int)Nx, false);
     321
    314322    psF64 *vector = b->data.F64;
    315323    psF64 **matrix = a->data.F64;
    316     int Nx = a->numCols;
    317324    int *indxc = psAlloc(Nx*sizeof(int));
    318325    int *indxr = psAlloc(Nx*sizeof(int));

  • trunk/psLib/src/math/psMatrix.h

    r7102 r9538  
    2121 *  @author Ross Harman, MHPCC
    2222 *
    23  *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2006-05-10 00:49:38 $
     23 *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2006-10-13 21:13:48 $
    2525 *
    2626 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6969 */
    7070bool psMatrixGJSolve(
    71     psImage *a,                        ///< Matrix to be solved
    72     psVector *b                        ///< Vector of values
     71    psImage *a,                   ///< Matrix to be solved
     72    psVector *b                   ///< Vector of values
    7373);
    7474

  • trunk/psLib/src/math/psMinimizeLMM.c

    r8627 r9538  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-08-26 04:34:28 $
     12 *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-10-13 21:13:48 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    539539bool psMemCheckMinimization(psPtr ptr)
    540540{
    541     if (!is_psType(ptr)) {
    542         return false;
    543     }
     541    PS_ASSERT_PTR(ptr, false);
    544542    return( psMemGetDeallocator(ptr) == (psFreeFunc)minimizationFree );
    545543}

  • trunk/psLib/src/math/psPolynomial.c

    r8245 r9538  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.149 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-08-09 02:26:44 $
     9*  @version $Revision: 1.150 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-10-13 21:13:48 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6464bool psMemCheckPolynomial1D(psPtr ptr)
    6565{
    66     if (!is_psType(ptr)) {
    67         return false;
    68     }
     66    PS_ASSERT_PTR(ptr, false);
    6967    return ( psMemGetDeallocator(ptr) == (psFreeFunc)polynomial1DFree );
    7068}
    … …  
    7270bool psMemCheckPolynomial2D(psPtr ptr)
    7371{
    74     if (!is_psType(ptr)) {
    75         return false;
    76     }
     72    PS_ASSERT_PTR(ptr, false);
    7773    return ( psMemGetDeallocator(ptr) == (psFreeFunc)polynomial2DFree );
    7874}
    … …  
    8076bool psMemCheckPolynomial3D(psPtr ptr)
    8177{
    82     if (!is_psType(ptr)) {
    83         return false;
    84     }
     78    PS_ASSERT_PTR(ptr, false);
    8579    return ( psMemGetDeallocator(ptr) == (psFreeFunc)polynomial3DFree );
    8680}
    … …  
    8882bool psMemCheckPolynomial4D(psPtr ptr)
    8983{
    90     if (!is_psType(ptr)) {
    91         return false;
    92     }
     84    PS_ASSERT_PTR(ptr, false);
    9385    return ( psMemGetDeallocator(ptr) == (psFreeFunc)polynomial4DFree );
    9486}

  • trunk/psLib/src/math/psRegion.c

    r8232 r9538  
    33#include "psMemory.h"
    44#include "psError.h"
    5 
     5#include "psAssert.h"
    66#include "psRegion.h"
    77
    … …  
    109109bool psMemCheckRegion(psPtr ptr)
    110110{
    111     if (!is_psType(ptr)) {
    112         return false;
    113     }
     111    PS_ASSERT_PTR(ptr, false);
    114112    return ( psMemGetDeallocator(ptr) == (psFreeFunc)regionFree );
    115113}

  • trunk/psLib/src/math/psSpline.c

    r8627 r9538  
    66*  This file contains the routines that allocate, free, and evaluate splines.
    77*
    8 *  @version $Revision: 1.153 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2006-08-26 04:34:28 $
     8*  @version $Revision: 1.154 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2006-10-13 21:13:48 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    168168bool psMemCheckSpline1D(psPtr ptr)
    169169{
    170     if (!is_psType(ptr)) {
    171         return false;
    172     }
     170    PS_ASSERT_PTR(ptr, false);
    173171    return ( psMemGetDeallocator(ptr) == (psFreeFunc)spline1DFree );
    174172}

  • trunk/psLib/src/math/psStats.c

    r8627 r9538  
    1616 * use ->min and ->max (PS_STAT_USE_RANGE)
    1717 *
    18  *  @version $Revision: 1.185 $ $Name: not supported by cvs2svn $
    19  *  @date $Date: 2006-08-26 04:34:28 $
     18 *  @version $Revision: 1.186 $ $Name: not supported by cvs2svn $
     19 *  @date $Date: 2006-10-13 21:13:48 $
    2020 *
    2121 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    16231623bool psMemCheckStats(psPtr ptr)
    16241624{
    1625     if (!is_psType(ptr)) {
    1626         return false;
    1627     }
     1625    PS_ASSERT_PTR(ptr, false);
    16281626    return ( psMemGetDeallocator(ptr) == (psFreeFunc)statsFree );
    16291627}
    … …  
    17341732bool psMemCheckHistogram(psPtr ptr)
    17351733{
    1736     if (!is_psType(ptr)) {
    1737         return false;
    1738     }
     1734    PS_ASSERT_PTR(ptr, false);
    17391735    return ( psMemGetDeallocator(ptr) == (psFreeFunc)histogramFree );
    17401736}

  • trunk/psLib/src/mathtypes/psImage.c

    r8627 r9538  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.114 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-08-26 04:34:28 $
     11 *  @version $Revision: 1.115 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-10-13 21:13:48 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4343        int ref = ptr->refCounter;
    4444        ptr->refCounter = 2;  // make sure psFree is not retriggered
    45         psArrayRemove(image->parent->children,image);
     45        psArrayRemoveData(image->parent->children,image);
    4646        ptr->refCounter = ref; // restore previous count (not assuming zero, but should be)
    4747
    … …  
    110110bool psMemCheckImage(psPtr ptr)
    111111{
    112     if (!is_psType(ptr)) {
    113         return false;
    114     }
     112    PS_ASSERT_PTR(ptr, false);
    115113    return ( psMemGetDeallocator(ptr) == (psFreeFunc)imageFree );
    116114}

  • trunk/psLib/src/mathtypes/psScalar.c

    r8232 r9538  
    88 *  @author Ross Harman, MHPCC
    99 *
    10  *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-08-08 23:32:23 $
     10 *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-10-13 21:13:48 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1919#include "psLogMsg.h"
    2020#include "psAbort.h"
    21 
     21#include "psAssert.h"
    2222
    2323
    … …  
    8989bool psMemCheckScalar(psPtr ptr)
    9090{
    91     if (!is_psType(ptr)) {
    92         return false;
    93     }
     91    PS_ASSERT_PTR(ptr, NULL);
    9492    return ( psMemGetDeallocator(ptr) == (psFreeFunc)scalarFree );
    9593}

  • trunk/psLib/src/mathtypes/psVector.c

    r8627 r9538  
    99*  @author Robert DeSonia, MHPCC
    1010*
    11 *  @version $Revision: 1.82 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2006-08-26 04:34:28 $
     11*  @version $Revision: 1.83 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2006-10-13 21:13:48 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626#include "psLogMsg.h"
    2727#include "psCompare.h"
    28 
     28#include "psAssert.h"
    2929
    3030
    … …  
    6363bool psMemCheckVector(psPtr ptr)
    6464{
    65     if (!is_psType(ptr)) {
    66         return false;
    67     }
     65    PS_ASSERT_PTR(ptr, false);
    6866    return ( psMemGetDeallocator(ptr) == (psFreeFunc)vectorFree );
    6967}

  • trunk/psLib/src/sys/psAssert.h

    r8921 r9538  
    66#include <math.h>
    77
     8#include "psMemory.h"
    89#include "psError.h"
    910#include "psLogMsg.h"
     11
     12// Ensure this is a psLib pointer, by checking for the memblock bounds.
     13#define PS_ASSERT_PTR(NAME, RVAL) \
     14{ \
     15    psMemBlock *mb = (psMemBlock*)(NAME) - 1; \
     16    if (mb->startblock != P_PS_MEMMAGIC || mb->endblock != P_PS_MEMMAGIC || \
     17            *(psPtr *)((int8_t *) (mb + 1) + mb->userMemorySize) != P_PS_MEMMAGIC) { \
     18        psError(PS_ERR_MEMORY_CORRUPTION, false, \
     19                "Error: Pointer %s is corrupted or not on the PS memory system.", \
     20                #NAME); \
     21        return (RVAL); \
     22    } \
     23}
    1024
    1125#define PS_ASSERT_INT_UNEQUAL(NAME1, NAME2, RVAL) \

  • trunk/psLib/src/sys/psConfigure.c

    r8627 r9538  
    1313 *  @author Robert DeSonia, MHPCC
    1414 *
    15  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2006-08-26 04:34:28 $
     15 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2006-10-13 21:13:48 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3434static FILE *memCheckFile = NULL;       // File to which to write results of mem check
    3535
    36 char* psLibVersion(void)
     36psString psLibVersion(void)
    3737{
    3838    char version[80];

  • trunk/psLib/src/sys/psConfigure.h

    r7646 r9538  
    1313 *  @author Robert DeSonia, MHPCC
    1414 *
    15  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2006-06-23 01:59:15 $
     15 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2006-10-13 21:13:48 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232 *  @return char*: String with version name.
    3333 */
    34 char* psLibVersion(
     34psString psLibVersion(
    3535    void
    3636);

  • trunk/psLib/src/sys/psLine.c

    r7950 r9538  
    33
    44#include "psMemory.h"
     5#include "psAssert.h"
    56#include "psConstants.h"
    67#include "psLine.h"
    … …  
    6465bool psMemCheckLine(psPtr ptr)
    6566{
    66     if (!is_psType(ptr)) {
    67         return false;
    68     }
     67    PS_ASSERT_PTR(ptr, false);
    6968    return ( psMemGetDeallocator(ptr) == (psFreeFunc)lineFree );
    7069}

  • trunk/psLib/src/sys/psMemory.c

    r8812 r9538  
    88*  @author Robert Lupton, Princeton University
    99*
    10 *  @version $Revision: 1.85 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2006-09-14 22:27:29 $
     10*  @version $Revision: 1.86 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2006-10-13 21:13:48 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psMemory.h"
    2525#include "psError.h"
     26#include "psAssert.h"
    2627#include "psAbort.h"
    2728#include "psLogMsg.h"
    … …  
    3536#include "psLine.h"
    3637#include "psRegion.h"
    37 
    38 #define P_PS_MEMMAGIC (psPtr )0xdeadbeef   // Magic number in psMemBlock header
    3938
    4039#define P_PS_LARGE_BLOCK_SIZE 65536        // size where under, we try to recycle
    … …  
    274273psMemId psMemGetId(void)
    275274{
    276     psMemId id;
    277 
    278     if (safeThreads) {
    279         pthread_mutex_lock(&memIdMutex);
    280     }
    281 
    282     id = memid + 1;
    283 
    284     if (safeThreads) {
    285         pthread_mutex_unlock(&memIdMutex);
    286     }
    287 
    288     return id;
     275    return psMemGetLastId() + 1;
    289276}
    290277
    … …  
    889876}
    890877
    891 bool is_psType(psPtr ptr)
    892 {
    893     if (ptr == NULL) {
    894         return false;
    895     }
    896     psMemBlock* m = ((psMemBlock* ) ptr) - 1;
    897     if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) {
    898         return false; //Probably not a psAllocated-Type
    899     } else {
    900         return true;
    901     }
    902 }
    903 
    904878bool psMemCheckType(psDataType type,
    905879                    psPtr ptr)
    906880{
    907     if (!is_psType(ptr)) {
    908         return false;
    909     }
     881    PS_ASSERT_PTR(ptr, false);
    910882
    911883    switch(type) {

  • trunk/psLib/src/sys/psMemory.h

    r8705 r9538  
    1212 *  @ingroup MemoryManagement
    1313 *
    14  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-08-30 04:40:56 $
     14 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-10-13 21:13:48 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929 *  @{
    3030 */
     31
     32#define P_PS_MEMMAGIC (psPtr)0xdeadbeef   // Magic number in psMemBlock header
    3133
    3234/**
    … …  
    172174);
    173175
    174 /** Tells whether or not a pointer has been allocated as a psDataType.
    175  *
    176  * @return bool:        True if ptr is a psDataType, otherwise false.
    177  */
    178 bool is_psType(
    179     psPtr ptr                          ///< The pointer whose type to check
    180 );
    181 
    182176/** Checks the deallocator to see if the pointer matches the desired datatype.
    183177 *

  • trunk/psLib/src/sys/psSlurp.c

    r9002 r9538  
    55 *  @author Joshua Hoblitt, University of Hawaii
    66 *
    7  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2006-09-27 03:50:19 $
     7 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-10-13 21:13:48 $
    99 *
    1010 *  Copyright 2006 University of Hawaii
    … …  
    1515#endif
    1616
     17#include <stdio.h>
    1718#include <unistd.h>
    1819

  • trunk/psLib/src/sys/psSlurp.h

    r8996 r9538  
     1#ifndef PS_SLURP_H
     2#define PS_SLURP_H
     3
    14#include <stdio.h>
    2 #include <pslib.h>
     5#include "psString.h"
    36
    4 psString psSlurpFD(int fd);
    5 psString psSlurpFile(FILE *stream);
     7
     8// Read ("slurp") a file (specified by file descriptor)
     9// and return a string containing the entire file.
     10psString psSlurpFD(int fd               // File descriptor to read
     11                  );
     12
     13// Read ("slurp") a file (specified by file stream)
     14// and return a string containing the entire file.
     15psString psSlurpFile(FILE *stream       // File stream to read
     16                    );
     17
     18
     19#endif

  • trunk/psLib/src/sys/psString.c

    r9509 r9538  
    1313 *  @author David Robbins, MHPCC
    1414 *
    15  *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2006-10-12 21:31:47 $
     15 *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2006-10-13 21:13:48 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4747bool psMemCheckString(psPtr ptr)
    4848{
    49     if (!is_psType(ptr)) {
    50         return false;
    51     }
     49    PS_ASSERT_PTR(ptr, false);
    5250    return ( psMemGetDeallocator(ptr) == (psFreeFunc)stringFree );
    5351}

  • trunk/psLib/src/types/psArguments.c

    r8973 r9538  
    77 *  @author David Robbins, MHPCC
    88 *
    9  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-09-26 02:55:34 $
     9 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-10-13 21:13:48 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    480480}
    481481
    482 // we have log levels 1 (Error), 2 (Warning), 3 (Info), 4 (Details), 5 (Minutiae)
    483 // 2 = default, -v = 3, -vv = 4, -vvv = 5
    484 psS32 psLogArguments (int *argc,
    485                       char **argv)
    486 {
    487     int N, level;
    488 
    489     // default log level is 2
    490     level = 2;
    491 
    492     psLogSetLevel (level);
    493     PS_ASSERT_PTR_NON_NULL(argv, 2);
    494     PS_ASSERT_PTR_NON_NULL(argc, 2);
    495     // set in order, so that -vvv overrides -vv overrides -v
    496     if ((N = psArgumentGet (*argc, argv, "-v"))) {
    497         psArgumentRemove (N, argc, argv);
    498         level = 3;
    499     }
    500     if ((N = psArgumentGet (*argc, argv, "-vv"))) {
    501         psArgumentRemove (N, argc, argv);
    502         level = 4;
    503     }
    504     if ((N = psArgumentGet (*argc, argv, "-vvv"))) {
    505         psArgumentRemove (N, argc, argv);
    506         level = 5;
    507     }
    508 
    509     if ((N = psArgumentGet (*argc, argv, "-logfmt"))) {
    510         if (*argc < N + 2) {
    511             //            psAbort ("psLogArguments", "USAGE: -logfmt (format)");
    512             psError(PS_ERR_IO, true, "-logfmt switch specified without a format.");
    513         } else {
    514             psArgumentRemove (N, argc, argv);
    515             psLogSetFormat (argv[N]); // XXX EAM : this function should return an error if the log format is invalid
    516             psArgumentRemove (N, argc, argv);
    517         }
    518     }
    519 
    520     // set the level, return the level
    521     psLogSetLevel (level);
    522     return (level);
    523 }
    524 
    525 // set trace levels by facility
    526 psS32 psTraceArguments (int *argc,
    527                         char **argv)
    528 {
    529     int N;
    530     PS_ASSERT_PTR_NON_NULL(argv, 0);
    531     PS_ASSERT_PTR_NON_NULL(argc, 0);
    532 
    533     // argument format is: -trace (facil) (level)
    534     while ((N = psArgumentGet (*argc, argv, "-trace"))) {
    535         if (*argc < N + 3) {
    536             //            psAbort ("psTraceArguments", "USAGE: -trace (facility) (level)");
    537             psError(PS_ERR_IO, true, "-trace switch specified without facility and level.");
    538             return 0;
    539         }
    540         psArgumentRemove (N, argc, argv);
    541         psTraceSetLevel (argv[N], atoi(argv[N+1]));
    542         psArgumentRemove (N, argc, argv);
    543         psArgumentRemove (N, argc, argv);
    544     }
    545     if ((N = psArgumentGet (*argc, argv, "-trace-levels"))) {
    546         psTracePrintLevels ();
    547         //        exit (2);
    548         return 0;
    549     }
    550     return (TRUE);
    551 }
    552 

  • trunk/psLib/src/types/psArguments.h

    r6189 r9538  
    77 *  @author David Robbins, MHPCC
    88 *
    9  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-01-25 03:02:47 $
     9 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-10-13 21:13:48 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7474);
    7575
    76 /** Sets the log level.
    77  *
    78  *  @return psS32:     the log level.
    79  */
    80 psS32 psLogArguments(
    81     int *argc,                         ///< number of arguments
    82     char **argv                        ///< the argument list
    83 );
    84 
    85 /** Sets trace levels by facility
    86  *
    87  *  @return psS32:      1 (true) if successful or else 2.
    88  */
    89 psS32 psTraceArguments(
    90     int *argc,                         ///< number of arguments
    91     char **argv                        ///< the argument list
    92 );
    93 
    9476
    9577/// @}

  • trunk/psLib/src/types/psArray.c

    r8973 r9538  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.54 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-09-26 02:55:34 $
     11 *  @version $Revision: 1.55 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-10-13 21:13:48 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4545bool psMemCheckArray(psPtr ptr)
    4646{
    47     if (!is_psType(ptr)) {
    48         return false;
    49     }
     47    PS_ASSERT_PTR(ptr, false);
    5048    return ( psMemGetDeallocator(ptr) == (psFreeFunc)arrayFree );
    5149}
    … …  
    133131}
    134132
    135 bool psArrayRemove(psArray* array,
    136                    const psPtr data)
     133bool psArrayRemoveData(psArray* array,
     134                       const psPtr data)
    137135{
    138136    bool success = false;
    … …  
    159157}
    160158
    161 bool psArrayRemoveByPos(psArray* array,
    162                         long position)
     159bool psArrayRemoveByIndex(psArray* array,
     160                          long index)
    163161{
    164162    PS_ASSERT_PTR_NON_NULL(array, false);
    165163
    166     if (position < 0 || position >= array->n) {
    167         psError(PS_ERR_BAD_PARAMETER_NULL, true,
    168                 _("position > then the number of elements in the array."));
    169         return false;
    170     }
    171 
    172     long i = position;
     164    if (index < 0 || index >= array->n) {
     165        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     166                _("index > then the number of elements in the array."));
     167        return false;
     168    }
     169
     170    long i = index;
    173171    long n = array->n;
    174172    psFree(array->data[i]);

  • trunk/psLib/src/types/psArray.h

    r9312 r9538  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-10-05 22:32:29 $
     13 *  @version $Revision: 1.41 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-10-13 21:13:48 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    105105 *
    106106 */
    107 bool psArrayRemove(
     107bool psArrayRemoveData(
    108108    psArray* array,                    ///< array to operate on
    109109    const psPtr data                   ///< the data pointer to remove from psArray
    … …  
    118118 *
    119119 */
    120 bool psArrayRemoveByPos(
     120bool psArrayRemoveByIndex(
    121121    psArray* array,                    ///< array to operate on
    122     long position                      ///< the element to remove
     122    long index                      ///< the element to remove
    123123);
    124124

  • trunk/psLib/src/types/psBitSet.c

    r9082 r9538  
    1111 *  @author Robert DeSonia, MHPCC
    1212 *
    13  *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-10-01 00:40:35 $
     13 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-10-13 21:13:48 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6666bool psMemCheckBitSet(psPtr ptr)
    6767{
    68     if (!is_psType(ptr)) {
    69         return false;
    70     }
     68    PS_ASSERT_PTR(ptr, false);
    7169    return ( psMemGetDeallocator(ptr) == (psFreeFunc)bitSetFree );
    7270}

  • trunk/psLib/src/types/psHash.c

    r9083 r9538  
    1212*  @author GLG, MHPCC
    1313*
    14 *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2006-10-01 00:45:34 $
     14*  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2006-10-13 21:13:48 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    165165bool psMemCheckHash(psPtr ptr)
    166166{
    167     if (!is_psType(ptr)) {
    168         return false;
    169     }
     167    PS_ASSERT_PTR(ptr, false);
    170168    return ( psMemGetDeallocator(ptr) == (psFreeFunc)hashFree );
    171169}

  • trunk/psLib/src/types/psList.c

    r9143 r9538  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.54 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-03 06:51:47 $
     8 *  @version $Revision: 1.55 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-13 21:13:48 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2020#include "psTrace.h"
    2121#include "psLogMsg.h"
    22 
     22#include "psAssert.h"
    2323
    2424
    … …  
    140140bool psMemCheckList(psPtr ptr)
    141141{
    142     if (!is_psType(ptr)) {
    143         return false;
    144     }
     142    PS_ASSERT_PTR(ptr, false);
    145143    return ( psMemGetDeallocator(ptr) == (psFreeFunc)listFree );
    146144}

  • trunk/psLib/src/types/psLookupTable.c

    r9143 r9538  
    77*  @author Ross Harman, MHPCC
    88*
    9 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-10-03 06:51:47 $
     9*  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-10-13 21:13:48 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    264264bool psMemCheckLookupTable(psPtr ptr)
    265265{
    266     if (!is_psType(ptr)) {
    267         return false;
    268     }
     266    PS_ASSERT_PTR(ptr, false);
    269267    return ( psMemGetDeallocator(ptr) == (psFreeFunc)lookupTableFree );
    270268}

  • trunk/psLib/src/types/psMetadata.c

    r9534 r9538  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.138 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-10-13 19:06:00 $
     14 *  @version $Revision: 1.139 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-10-13 21:13:48 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    157157bool psMemCheckMetadataItem(psPtr ptr)
    158158{
    159     if (!is_psType(ptr)) {
    160         return false;
    161     }
     159    PS_ASSERT_PTR(ptr, false);
    162160    return ( psMemGetDeallocator(ptr) == (psFreeFunc)metadataItemFree );
    163161}
    … …  
    340338bool psMemCheckMetadata(psPtr ptr)
    341339{
    342     if (!is_psType(ptr)) {
    343         return false;
    344     }
     340    PS_ASSERT_PTR(ptr, false);
    345341    return ( psMemGetDeallocator(ptr) == (psFreeFunc)metadataFree );
    346342}
    … …  
    567563
    568564            // remove the existing entry from metadata
    569             psMetadataRemove(md,0,key);
     565            psMetadataRemoveKey(md, key);
    570566
    571567            // treat as if new (added to list below)
    … …  
    662658
    663659#define METADATA_ADD_TYPE(NAME,TYPE,METATYPE) \
    664 psBool psMetadataAdd##NAME(psMetadata* md, long where, const char* name, \
    665                            int format, const char* comment, TYPE value) { \
    666     return psMetadataAdd(md,where,name, format | METATYPE,comment,value); \
     660bool psMetadataAdd##NAME(psMetadata* md, long where, const char* name, \
     661                         int format, const char* comment, TYPE value) { \
     662    return psMetadataAdd(md, where, name, format | METATYPE, comment, value); \
    667663}
    668664
    … …  
    679675METADATA_ADD_TYPE(F64,psF64,PS_DATA_F64)
    680676METADATA_ADD_TYPE(List,psList*,PS_DATA_LIST)
    681 //METADATA_ADD_TYPE(Str,const char*,PS_DATA_STRING)
     677METADATA_ADD_TYPE(Str,const char*,PS_DATA_STRING)
    682678METADATA_ADD_TYPE(Vector,psVector*,PS_DATA_VECTOR)
    683679METADATA_ADD_TYPE(Image,psImage*,PS_DATA_IMAGE)
    684680METADATA_ADD_TYPE(Hash,psHash*,PS_DATA_HASH)
    685681METADATA_ADD_TYPE(LookupTable,psLookupTable*,PS_DATA_LOOKUPTABLE)
    686 METADATA_ADD_TYPE(Unknown,void*,PS_DATA_UNKNOWN)
    687682METADATA_ADD_TYPE(Metadata,psMetadata*,PS_DATA_METADATA)
    688683METADATA_ADD_TYPE(Array,psArray*,PS_DATA_ARRAY)
    689684METADATA_ADD_TYPE(Time,psTime*,PS_DATA_TIME)
    690 
    691 bool psMetadataAddPtr(psMetadata *md,
    692                       long location,
    693                       const char *name,
    694                       psDataType type,
    695                       const char *comment,
    696                       psPtr value)
    697 {
    698     PS_ASSERT_PTR_NON_NULL(md,false);
    699     PS_ASSERT_PTR_NON_NULL(md->list,false);
    700     PS_ASSERT_PTR_NON_NULL(value,false);
    701     return (psMetadataAdd(md, location, name, type, comment, value) );
    702 
    703 }
    704 
    705 bool psMetadataAddStr(psMetadata *md,
    706                       long location,
    707                       const char *name,
    708                       int format,
    709                       const char *comment,
    710                       const char* value)
    711 {
    712     PS_ASSERT_PTR_NON_NULL(md,false);
    713     PS_ASSERT_PTR_NON_NULL(md->list,false);
    714 
    715     return (psMetadataAdd(md, location, name, format | PS_DATA_STRING, comment, value) );
    716 }
    717 
    718 bool psMetadataRemove(psMetadata *md,
    719                       long where,
    720                       const char *key)
    721 {
    722     PS_ASSERT_PTR_NON_NULL(md,NULL);
    723 
    724     PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    725     psList* mdList = md->list;
    726 
    727     PS_ASSERT_PTR_NON_NULL(md->hash,NULL);
    728     psHash* mdTable = md->hash;
    729 
    730     // Select removal by key or index
    731     if (key != NULL) {
    732         // Remove by key name
    733         psMetadataItem* entry = psHashLookup(mdTable,key);
    734         if (entry == NULL) {
    735             psError(PS_ERR_UNKNOWN, false,
    736                     _("Failed to remove metadata item, %s, from metadata table."), key);
    737             return false;
    738         }
    739         if (entry->type == PS_DATA_METADATA_MULTI) {
    740             psMetadataItem* listItem;
    741             psListIterator* iter = psListIteratorAlloc(
    742                                        entry->data.list,
    743                                        PS_LIST_HEAD,true);
    744             while ((listItem=psListGetAndIncrement(iter)) != NULL) {
    745                 psListRemoveData(mdList, listItem);
    746             }
    747             psFree(iter);
    748             psHashRemove(mdTable,key);
    749 
    750         } else {
    751             psListRemoveData(mdList, entry);
    752             psHashRemove(mdTable, key);
    753         }
    754     } else {
    755         // Remove by index
    756         psMetadataItem* entry = psListGet(mdList, where);
    757         if (entry == NULL) {
    758             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    759                     _("Could not find metadata item at index %ld."), where);
    760             return false;
    761         }
    762         key = entry->name;
    763 
    764         if (key == NULL) {
    765             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    766                     _("Failed to remove metadata item, at index %ld, from metadata list."),
    767                     where);
    768             return false;
    769         }
    770 
    771         psMetadataItem* tableItem = psHashLookup(mdTable, key);
    772         if (tableItem == NULL) {
    773             psError(PS_ERR_UNKNOWN, false,
    774                     _("Failed to remove metadata item, %s, from metadata table."), key);
    775             return false;
    776         }
    777 
    778         if (tableItem->type == PS_DATA_METADATA_MULTI) {
    779             // multiple entries with same key, remove just the specified one
    780             psListRemoveData(tableItem->data.list, entry);
    781         } else {
    782             //Tested below.  psHashRemove can't return false here.
    783             psHashRemove(mdTable, key);
    784         }
    785         psListRemove(mdList, where);
    786     }
    787 
    788     return true;
    789 }
    790 
     685METADATA_ADD_TYPE(Unknown,psPtr,PS_DATA_UNKNOWN)
     686
     687bool psMetadataAddPtr(psMetadata* md, long where, const char* name,
     688                      psDataType type, const char* comment, psPtr value)
     689{
     690    return psMetadataAdd(md, where, name, type, comment, value);
     691}
     692
     693
     694
     695// Remove by key name
    791696bool psMetadataRemoveKey(psMetadata *md,
    792697                         const char *key)
    793698{
    794     return ( psMetadataRemove(md, PS_LIST_HEAD, key) );
    795 }
    796 
     699    PS_ASSERT_PTR_NON_NULL(md, false);
     700
     701    PS_ASSERT_PTR_NON_NULL(md->list, false);
     702    psList* mdList = md->list;
     703
     704    PS_ASSERT_PTR_NON_NULL(md->hash,false);
     705    psHash* mdTable = md->hash;
     706
     707    PS_ASSERT_PTR_NON_NULL(key, false);
     708    PS_ASSERT_INT_POSITIVE(strlen(key), false);
     709
     710    psMetadataItem* entry = psHashLookup(mdTable,key);
     711    if (entry == NULL) {
     712        psError(PS_ERR_UNKNOWN, false,
     713                _("Failed to remove metadata item, %s, from metadata table."), key);
     714        return false;
     715    }
     716    if (entry->type == PS_DATA_METADATA_MULTI) {
     717        psMetadataItem* listItem;
     718        psListIterator* iter = psListIteratorAlloc(
     719                                   entry->data.list,
     720                                   PS_LIST_HEAD,true);
     721        while ((listItem=psListGetAndIncrement(iter)) != NULL) {
     722            psListRemoveData(mdList, listItem);
     723        }
     724        psFree(iter);
     725        psHashRemove(mdTable,key);
     726    } else {
     727        psListRemoveData(mdList, entry);
     728        psHashRemove(mdTable, key);
     729    }
     730
     731    return true;
     732}
     733
     734
     735// Remove by index
    797736bool psMetadataRemoveIndex(psMetadata *md,
    798                            int location)
    799 {
    800     return ( psMetadataRemove(md, location, NULL) );
     737                           long location)
     738{
     739    PS_ASSERT_PTR_NON_NULL(md, false);
     740
     741    PS_ASSERT_PTR_NON_NULL(md->list, false);
     742    psList* mdList = md->list;
     743
     744    PS_ASSERT_PTR_NON_NULL(md->hash,false);
     745    psHash* mdTable = md->hash;
     746
     747    psMetadataItem* entry = psListGet(mdList, location);
     748    if (entry == NULL) {
     749        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     750                _("Could not find metadata item at index %ld."), location);
     751        return false;
     752    }
     753    const char *key = entry->name;
     754
     755    if (key == NULL) {
     756        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     757                _("Failed to remove metadata item, at index %ld, from metadata list."),
     758                location);
     759        return false;
     760    }
     761
     762    psMetadataItem* tableItem = psHashLookup(mdTable, key);
     763    if (tableItem == NULL) {
     764        psError(PS_ERR_UNKNOWN, false,
     765                _("Failed to remove metadata item, %s, from metadata table."), key);
     766        return false;
     767    }
     768
     769    if (tableItem->type == PS_DATA_METADATA_MULTI) {
     770        // multiple entries with same key, remove just the specified one
     771        psListRemoveData(tableItem->data.list, entry);
     772    } else {
     773        //Tested below.  psHashRemove can't return false here.
     774        psHashRemove(mdTable, key);
     775    }
     776    psListRemove(mdList, location);
     777
     778    return true;
    801779}
    802780
    … …  
    10951073}
    10961074
    1097 psMetadata *psMetadataLookupMD(bool *status,
    1098                                const psMetadata *md,
    1099                                const char *key)
     1075psMetadata *psMetadataLookupMetadata(bool *status,
     1076                                     const psMetadata *md,
     1077                                     const char *key)
    11001078{
    11011079    PS_ASSERT_PTR_NON_NULL(md,NULL);
    … …  
    14131391}
    14141392
    1415 psPolynomial1D *psPolynomial1DfromMD (psMetadata *folder)
     1393psPolynomial1D *psPolynomial1DfromMetadata(const psMetadata *folder)
    14161394{
    14171395    PS_ASSERT_PTR_NON_NULL(folder, NULL);
    … …  
    14621440
    14631441// XXX : these may need F64, or %g format for output
    1464 bool psPolynomial1DtoMD (psMetadata *md,
    1465                          psPolynomial1D *poly,
    1466                          char *format,
    1467                          ...)
     1442bool psPolynomial1DtoMetadata(psMetadata *md,
     1443                              const psPolynomial1D *poly,
     1444                              const char *format,
     1445                              ...)
    14681446{
    14691447    PS_ASSERT_PTR_NON_NULL(md, false);
    … …  
    15191497}
    15201498
    1521 psPolynomial2D *psPolynomial2DfromMD (psMetadata *folder)
     1499psPolynomial2D *psPolynomial2DfromMetadata(const psMetadata *folder)
    15221500{
    15231501    PS_ASSERT_PTR_NON_NULL(folder, NULL);
    … …  
    15751553
    15761554// XXX : these may need F64, or %g format for output
    1577 bool psPolynomial2DtoMD (psMetadata *md,
    1578                          psPolynomial2D *poly,
    1579                          char *format,
    1580                          ...)
     1555bool psPolynomial2DtoMetadata (psMetadata *md,
     1556                               const psPolynomial2D *poly,
     1557                               const char *format,
     1558                               ...)
    15811559{
    15821560    PS_ASSERT_PTR_NON_NULL(md, false);
    … …  
    16421620}
    16431621
    1644 psPolynomial3D *psPolynomial3DfromMD (psMetadata *folder)
     1622psPolynomial3D *psPolynomial3DfromMetadata (const psMetadata *folder)
    16451623{
    16461624    PS_ASSERT_PTR_NON_NULL(folder, NULL);
    … …  
    17051683}
    17061684
    1707 bool psPolynomial3DtoMD (psMetadata *md,
    1708                          psPolynomial3D *poly,
    1709                          char *format,
    1710                          ...)
     1685bool psPolynomial3DtoMetadata (psMetadata *md,
     1686                               const psPolynomial3D *poly,
     1687                               const char *format,
     1688                               ...)
    17111689{
    17121690    PS_ASSERT_PTR_NON_NULL(md, false);
    … …  
    17701748}
    17711749
    1772 psPolynomial4D *psPolynomial4DfromMD (psMetadata *folder)
     1750psPolynomial4D *psPolynomial4DfromMetadata(const psMetadata *folder)
    17731751{
    17741752    PS_ASSERT_PTR_NON_NULL(folder, NULL);
    … …  
    18391817}
    18401818
    1841 bool psPolynomial4DtoMD (psMetadata *md,
    1842                          psPolynomial4D *poly,
    1843                          char *format,
    1844                          ...)
     1819bool psPolynomial4DtoMetadata (psMetadata *md,
     1820                               const psPolynomial4D *poly,
     1821                               const char *format,
     1822                               ...)
    18451823{
    18461824    PS_ASSERT_PTR_NON_NULL(md, false);

  • trunk/psLib/src/types/psMetadata.h

    r9534 r9538  
    1111*  @author Ross Harman, MHPCC
    1212*
    13 *  @version $Revision: 1.87 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2006-10-13 19:06:00 $
     13*  @version $Revision: 1.88 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2006-10-13 21:13:48 $
    1515*
    1616*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    598598/** Add a psList to metadata collection.
    599599 *
    600  *  @return psBool:  True for success, False for failure.
    601  */
    602 psBool psMetadataAddList(
     600 *  @return bool:  True for success, False for failure.
     601 */
     602bool psMetadataAddList(
    603603    psMetadata* md,                    ///< Metadata collection to insert metadata item
    604604    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    624624/** Add a vector to metadata collection.
    625625 *
    626  *  @return psBool:  True for success, False for failure.
    627  */
    628 psBool psMetadataAddVector(
     626 *  @return bool:  True for success, False for failure.
     627 */
     628bool psMetadataAddVector(
    629629    psMetadata* md,                    ///< Metadata collection to insert metadata item
    630630    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    637637/** Add a array to metadata collection.
    638638 *
    639  *  @return psBool:  True for success, False for failure.
    640  */
    641 psBool psMetadataAddArray(
     639 *  @return bool:  True for success, False for failure.
     640 */
     641bool psMetadataAddArray(
    642642    psMetadata* md,                    ///< Metadata collection to insert metadata item
    643643    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    650650/** Add an Image to metadata collection.
    651651 *
    652  *  @return psBool:  True for success, False for failure.
    653  */
    654 psBool psMetadataAddImage(
     652 *  @return bool:  True for success, False for failure.
     653 */
     654bool psMetadataAddImage(
    655655    psMetadata* md,                    ///< Metadata collection to insert metadata item
    656656    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    663663/** Add a Time to metadata collection.
    664664 *
    665  *  @return psBool:  True for success, False for failure.
    666  */
    667 psBool psMetadataAddTime(
     665 *  @return bool:  True for success, False for failure.
     666 */
     667bool psMetadataAddTime(
    668668    psMetadata* md,                    ///< Metadata collection to insert metadata item
    669669    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    676676/** Add a Hash to metadata collection.
    677677 *
    678  *  @return psBool:  True for success, False for failure.
    679  */
    680 psBool psMetadataAddHash(
     678 *  @return bool:  True for success, False for failure.
     679 */
     680bool psMetadataAddHash(
    681681    psMetadata* md,                    ///< Metadata collection to insert metadata item
    682682    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    689689/** Add a LookupTable to metadata collection.
    690690 *
    691  *  @return psBool:  True for success, False for failure.
    692  */
    693 psBool psMetadataAddLookupTable(
     691 *  @return bool:  True for success, False for failure.
     692 */
     693bool psMetadataAddLookupTable(
    694694    psMetadata* md,                    ///< Metadata collection to insert metadata item
    695695    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    702702/** Add an Unknown (psPtr) to metadata collection.
    703703 *
    704  *  @return psBool:  True for success, False for failure.
    705  */
    706 psBool psMetadataAddUnknown(
     704 *  @return bool:  True for success, False for failure.
     705 */
     706bool psMetadataAddUnknown(
    707707    psMetadata* md,                    ///< Metadata collection to insert metadata item
    708708    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    728728/** Add Metadata to metadata collection.
    729729 *
    730  *  @return psBool:  True for success, False for failure.
    731  */
    732 psBool psMetadataAddMetadata(
     730 *  @return bool:  True for success, False for failure.
     731 */
     732bool psMetadataAddMetadata(
    733733    psMetadata* md,                    ///< Metadata collection to insert metadata item
    734734    long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    … …  
    737737    const char* comment,               ///< Comment for metadata item
    738738    psMetadata* value                  ///< Metadata for metadata item data
    739 );
    740 
    741 /** Remove an item from metadata collection.
    742  *
    743  *  Items may be removed from metadata by specifing a key or location. If the
    744  *  name is null, the where argument is used instead. If name is not null,
    745  *  where is set to PS_LIST_UNKNOWN. If the item is found, it is removed from
    746  *  the metadata and true is returned.  If the key is not unique, then all
    747  *  items corresponding to it are removed.
    748  *
    749  * @return bool: True for success, false for failure.
    750  */
    751 bool psMetadataRemove(
    752     psMetadata*  md,                   ///< Metadata collection to remove metadata item.
    753     long location,                     ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    754     const char * key                   ///< Name of metadata key.
    755739);
    756740
    … …  
    770754bool psMetadataRemoveIndex(
    771755    psMetadata *md,                    ///< Metadata collection to remove metadata item.
    772     int location                       ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
     756    long location                       ///< Index number, PS_LIST_HEAD, or PS_LIST_TAIL
    773757);
    774758
    … …  
    10211005 *  @return psMetadata*:        Value of metadata item.
    10221006 */
    1023 psMetadata *psMetadataLookupMD(
     1007psMetadata *psMetadataLookupMetadata(
    10241008    bool *status,                      ///< Status of lookup.
    10251009    const psMetadata *md,              ///< Metadata collection to lookup metadata item.
    … …  
    11131097 *  @return psPolynomial2D*:        Newly allocated psPolynomial2D from metadata.
    11141098 */
    1115 psPolynomial2D *psPolynomial2DfromMD(
    1116     psMetadata *folder                 ///< folder containing the polynomial info.
     1099psPolynomial2D *psPolynomial2DfromMetadata(
     1100    const psMetadata *folder                 ///< folder containing the polynomial info.
    11171101);
    11181102
    … …  
    11291113 *  @return bool:       True if successful, otherwise false.
    11301114 */
    1131 bool psPolynomial2DtoMD(
     1115bool psPolynomial2DtoMetadata(
    11321116    psMetadata *md,                    ///< Metadata container for polynomial storage.
    1133     psPolynomial2D *poly,              ///< Polynomial information to be stored.
    1134     char *format,                      ///< Name of polynomial folder.
     1117    const psPolynomial2D *poly,              ///< Polynomial information to be stored.
     1118    const char *format,                      ///< Name of polynomial folder.
    11351119    ...                                ///< Arguments for name formatting.
    11361120);
    … …  
    11471131 *  @return psPolynomial3D*:        Newly allocated psPolynomial3D from metadata.
    11481132 */
    1149 psPolynomial3D *psPolynomial3DfromMD(
    1150     psMetadata *folder                 ///< folder containing the polynomial info.
     1133psPolynomial3D *psPolynomial3DfromMetadata(
     1134    const psMetadata *folder                 ///< folder containing the polynomial info.
    11511135);
    11521136
    … …  
    11631147 *  @return bool:       True if successful, otherwise false.
    11641148 */
    1165 bool psPolynomial3DtoMD(
     1149bool psPolynomial3DtoMetadata(
    11661150    psMetadata *md,                    ///< Metadata container for polynomial storage.
    1167     psPolynomial3D *poly,              ///< Polynomial information to be stored.
    1168     char *format,                      ///< Name of polynomial folder.
     1151    const psPolynomial3D *poly,              ///< Polynomial information to be stored.
     1152    const char *format,                      ///< Name of polynomial folder.
    11691153    ...                                ///< Arguments for name formatting.
    11701154);
    … …  
    11811165 *  @return psPolynomial4D*:        Newly allocated psPolynomial4D from metadata.
    11821166 */
    1183 psPolynomial4D *psPolynomial4DfromMD(
    1184     psMetadata *folder                 ///< folder containing the polynomial info.
     1167psPolynomial4D *psPolynomial4DfromMetadata(
     1168    const psMetadata *folder                 ///< folder containing the polynomial info.
    11851169);
    11861170
    … …  
    11971181 *  @return bool:       True if successful, otherwise false.
    11981182 */
    1199 bool psPolynomial4DtoMD(
     1183bool psPolynomial4DtoMetadata(
    12001184    psMetadata *md,                    ///< Metadata container for polynomial storage.
    1201     psPolynomial4D *poly,              ///< Polynomial information to be stored.
    1202     char *format,                      ///< Name of polynomial folder.
     1185    const psPolynomial4D *poly,              ///< Polynomial information to be stored.
     1186    const char *format,                      ///< Name of polynomial folder.
    12031187    ...                                ///< Arguments for name formatting.
    12041188);

  • trunk/psLib/src/types/psMetadataConfig.c

    r8973 r9538  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.92 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-09-26 02:55:34 $
     12*  @version $Revision: 1.93 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-10-13 21:13:48 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    11181118                } else {
    11191119                    // Remove lower info level
    1120                     if(!psArrayRemoveByPos(levelArray, *level)) {
     1120                    if(!psArrayRemoveByIndex(levelArray, *level)) {
    11211121                        psFree(keyName);
    11221122                        return false;

  • trunk/psLib/src/types/psPixels.c

    r8973 r9538  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-09-26 02:55:34 $
     9 *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-10-13 21:13:48 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1818#include "psPixels.h"
    1919#include "psMemory.h"
    20 
     20#include "psAssert.h"
    2121#include "psError.h"
    2222
    … …  
    7474bool psMemCheckPixels(psPtr ptr)
    7575{
    76     if (!is_psType(ptr)) {
    77         return false;
    78     }
     76    PS_ASSERT_PTR(ptr, false);
    7977    return ( psMemGetDeallocator(ptr) == (psFreeFunc)pixelsFree );
    8078}
Note: See TracChangeset for help on using the changeset viewer.