IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11686


Ignore:
Timestamp:
Feb 7, 2007, 1:52:54 PM (19 years ago)
Author:
jhoblitt
Message:

update psAbort() API:

add noreturn attribute
remove unneeded 'name' params
turn into a macro so file/line/func are automatiically passed

Location:
trunk/psLib
Files:
46 edited

Legend:

Unmodified
Added
Removed
  • trunk/psLib/src/astro/psCoord.c

    r11668 r11686  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.133 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2007-02-06 21:36:09 $
     12*  @version $Revision: 1.134 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2007-02-07 23:52:53 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    401401
    402402    default:
    403         psAbort ("psCoord", "invalid projection");
     403        psAbort("invalid projection");
    404404        break;
    405405    }
     
    465465            break;
    466466        default:
    467             psAbort ("psCoord", "invalid projection");
     467            psAbort("invalid projection");
    468468            break;
    469469        }
     
    493493        case PS_PROJ_CAR:
    494494        case PS_PROJ_MER:
    495             psAbort ("psCoord", "projection not yet implemented");
     495            psAbort("projection not yet implemented");
    496496            break;
    497497        default:
    498             psAbort ("psCoord", "invalid projection");
     498            psAbort("invalid projection");
    499499            break;
    500500        }
     
    502502
    503503    default:
    504         psAbort ("psCoord", "invalid projection");
     504        psAbort("invalid projection");
    505505        break;
    506506    }
     
    557557
    558558    default:
    559         psAbort ("psCoord", "invalid projection");
     559        psAbort("invalid projection");
    560560        break;
    561561    }
     
    603603            break;
    604604        case PS_PROJ_STG:
    605             psAbort ("coords", "STG not defined");
     605            psAbort("STG not defined");
    606606            break;
    607607        case PS_PROJ_ZEA:
     
    613613            break;
    614614        default:
    615             psAbort ("psCoord", "invalid projection");
     615            psAbort("invalid projection");
    616616            break;
    617617        }
     
    663663            break;
    664664        default:
    665             psAbort ("psCoord", "invalid projection");
     665            psAbort("invalid projection");
    666666            break;
    667667        }
     
    670670        break;
    671671    default:
    672         psAbort ("psCoord", "invalid projection");
     672        psAbort("invalid projection");
    673673        break;
    674674    }
  • trunk/psLib/src/db/psDB.c

    r11668 r11686  
    1212 *  @author Joshua Hoblitt
    1313 *
    14  *  @version $Revision: 1.134 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2007-02-06 21:36:09 $
     14 *  @version $Revision: 1.135 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2007-02-07 23:52:53 $
    1616 *
    1717 *  Copyright (C) 2005-2006  Joshua Hoblitt, University of Hawaii
     
    141141    mysql = mysql_init(NULL);
    142142    if (!mysql) {
    143         psAbort(__func__, "mysql_init(), out of memory.");
     143        psAbort("mysql_init(), out of memory.");
    144144    }
    145145
     
    856856    MYSQL_STMT *stmt = mysql_stmt_init(dbh->mysql);
    857857    if (!stmt) {
    858         psAbort(__func__, "mysql_stmt_init(), out of memory.");
     858        psAbort("mysql_stmt_init(), out of memory.");
    859859    }
    860860    if (mysql_stmt_prepare(stmt, query, (unsigned long)strlen(query))) {
  • trunk/psLib/src/fits/psFitsTable.c

    r10999 r11686  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2007-01-09 22:38:52 $
     9 *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2007-02-07 23:52:53 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    420420        }
    421421    default:
    422         psAbort(__func__, "Shouldn't ever get here.");
     422        psAbort("Shouldn't ever get here.");
    423423    }
    424424    return 0;
     
    697697                }
    698698            default:
    699                 psAbort(__func__, "Should never get here.\n");
     699                psAbort("Should never get here.\n");
    700700            }
    701701        }
  • trunk/psLib/src/imageops/psImageGeomManip.c

    r10999 r11686  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2007-01-09 22:38:52 $
     12 *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2007-02-07 23:52:54 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    10581058    }
    10591059
    1060     psAbort(__func__, "Should never get here.\n");
     1060    psAbort("Should never get here.\n");
    10611061    return NULL;
    10621062}
  • trunk/psLib/src/math/psMinimizeLMM.c

    r11668 r11686  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2007-02-06 21:36:09 $
     12 *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2007-02-07 23:52:54 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    282282        chisq += PS_SQR(delta) * dy->data.F32[i];
    283283        if (isnan(dy->data.F32[i]))
    284             psAbort ("psMinLMM", "nan in weights");
     284            psAbort("nan in weights");
    285285        if (isnan(delta))
    286             psAbort ("psMinLMM", "nan in delta");
     286            psAbort("nan in delta");
    287287        if (isnan(chisq))
    288             psAbort ("psMinLMM", "nan in chisq");
     288            psAbort("nan in chisq");
    289289
    290290        for (psS32 j = 0; j < params->n; j++) {
  • trunk/psLib/src/math/psSparse.c

    r10999 r11686  
    6666    if (i < j) {
    6767        // psError(PS_ERR_UNKNOWN, true, "i=%d, j=%d refers to a sub-diagonal element. not allowed!");
    68         psAbort (__func__, "i=%d, j=%d refers to a sub-diagonal element. not allowed!", i, j);
     68        psAbort("i=%d, j=%d refers to a sub-diagonal element. not allowed!", i, j);
    6969        return false;
    7070    }
  • trunk/psLib/src/math/psStats.c

    r11155 r11686  
    1313 * use ->min and ->max (PS_STAT_USE_RANGE)
    1414 *
    15  *  @version $Revision: 1.199 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2007-01-19 04:32:27 $
     15 *  @version $Revision: 1.200 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2007-02-07 23:52:54 $
    1717 *
    1818 *  Copyright 2006 IfA, University of Hawaii
     
    18701870    if (stats->options & (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2)) {
    18711871        if (stats->options & (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV)) {
    1872             psAbort ("stats", "you may not specify both FITTED_MEAN and FITTED_MEAN_V2");
     1872            psAbort("you may not specify both FITTED_MEAN and FITTED_MEAN_V2");
    18731873        }
    18741874        if (!vectorFittedStats_v2(inF32, errorsF32, maskU8, maskVal, stats)) {
     
    18811881    if (stats->options & (PS_STAT_FITTED_MEAN_V3 | PS_STAT_FITTED_STDEV_V3)) {
    18821882        if (stats->options & (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV)) {
    1883             psAbort ("stats", "you may not specify both FITTED_MEAN and FITTED_MEAN_V3");
     1883            psAbort("you may not specify both FITTED_MEAN and FITTED_MEAN_V3");
    18841884        }
    18851885        if (!vectorFittedStats_v3(inF32, errorsF32, maskU8, maskVal, stats)) {
     
    20242024        return 0;
    20252025    }
    2026     psAbort(__func__, "Should never get here.\n");
     2026    psAbort("Should never get here.\n");
    20272027    return 0;
    20282028}
     
    20702070        return NAN;
    20712071    }
    2072     psAbort(__func__, "Should never get here.\n");
     2072    psAbort("Should never get here.\n");
    20732073    return NAN;
    20742074}
  • trunk/psLib/src/sys/psAbort.c

    r10999 r11686  
    99 *
    1010 *  @author Eric Van Alst, MHPCC
     11 *  @author Joshua Hoblitt, University of Hawaii
    1112 *   
    12  *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2007-01-09 22:38:53 $
     13 *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2007-02-07 23:52:54 $
    1415 *
    1516 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2223#include <stdarg.h>
    2324#include <stdlib.h>
     25
    2426#include "psAbort.h"
    2527#include "psError.h"
    2628#include "psLogMsg.h"
    2729
    28 void psAbort(const char *name, const char *format, ...)
     30void p_psAbort(const char *file,
     31               unsigned int lineno,
     32               const char *func,
     33               const char *format,
     34               ...)
    2935{
    3036    psErrorStackPrint(stderr, "Aborting. Error stack:");
     
    3541
    3642    // Call logging function with PS_LOG_ABORT level
    37     psLogMsgV(name, PS_LOG_ABORT, format, argPtr);
     43    psLogMsgV("psLib.sys", PS_LOG_ABORT, format, argPtr);
    3844
    3945    // Clean up stack after variable arguement has been used
  • trunk/psLib/src/sys/psAbort.h

    r11248 r11686  
    88 *
    99 *  @author Eric Van Alst, MHPCC
     10 *  @author Joshua Hoblitt, University of Hawaii
    1011 *
    11  *  $Revision: 1.13 $ $Name: not supported by cvs2svn $
    12  *  $Date: 2007-01-23 22:47:23 $
     12 *  $Revision: 1.14 $ $Name: not supported by cvs2svn $
     13 *  $Date: 2007-02-07 23:52:54 $
    1314 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1415 */
     
    1920/// @addtogroup SysUtils System Utilities
    2021/// @{
     22
     23#include <stdarg.h>
    2124
    2225/** Reports an abort message to logging facility
     
    3033 *
    3134 */
    32 #ifdef __GNUC__
     35#ifdef DOXYGEN
    3336void psAbort(
    34     const char *name,                  ///< Source of abort such as file or function detected
    35     const char *format,                   ///< A printf style formatting statement defining msg
    36     ...
    37 ) __attribute__((format(printf, 2, 3)));
    38 #else // __GNUC__
    39 void psAbort(
    40     const char *name,                  ///< Source of abort such as file or function detected
    41     const char *format,                   ///< A printf style formatting statement defining msg
     37    const char *format,                 ///< A printf style formatting statement
    4238    ...
    4339);
    44 #endif // __GNUC__
     40#else // ifdef DOXYGEN
     41void p_psAbort(
     42    const char *file,                   ///< File of caller
     43    unsigned int lineno,                ///< Line number of caller
     44    const char *func,                   ///< Function name of caller
     45    const char *format,                 ///< A printf style formatting statement
     46    ...
     47#ifdef __GNUC__
     48) __attribute__((format(printf, 4, 5), noreturn));
     49#else // ifdef __GNUC__
     50);
     51#endif // ifdef __GNUC__
     52#ifndef SWIG
     53#define psAbort(...) \
     54      p_psAbort(__FILE__, __LINE__, __func__, __VA_ARGS__)
     55#endif // iddef SWIG
     56#endif // ifdef DOXYGEN
    4557
    4658/// @}
  • trunk/psLib/src/sys/psError.c

    r11674 r11686  
    1111 *  @author Eric Van Alst, MHPCC
    1212 *
    13  *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2007-02-07 01:15:49 $
     13 *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2007-02-07 23:52:54 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    6565        psArrayAdd(errorStack, 0, err);
    6666    } else {
    67         psAbort(__func__, "attempt to exceed maximum error stack depth of %ld",
     67        psAbort("attempt to exceed maximum error stack depth of %ld",
    6868                (long)MAX_ERROR_STACK_SIZE);
    6969    }
     
    7878        // thread exits
    7979        if (pthread_key_create(&errorStack_key, psFreeWrapper)) {
    80             psAbort(__func__, "pthread_key_create() failed");
     80            psAbort("pthread_key_create failed()");
    8181        }
    8282        errorStackKeyInitialized = true;
     
    9595        // param
    9696        if (pthread_setspecific(errorStack_key, errorStack)) {
    97             psAbort(__func__, "pthread_setspecific() failed");
     97            psAbort("pthread_setspecific() failed");
    9898        }
    9999    }
  • trunk/psLib/src/sys/psString.c

    r11618 r11686  
    1313 *  @author David Robbins, MHPCC
    1414 *
    15  *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2007-02-03 06:01:42 $
     15 *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2007-02-07 23:52:54 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    339339    }
    340340
    341     psAbort(__func__, "Should never get here.\n");
     341    psAbort("Should never get here.\n");
    342342    return 0;
    343343}
  • trunk/psLib/src/types/psArguments.c

    r10999 r11686  
    77 *  @author David Robbins, MHPCC
    88 *
    9  *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2007-01-09 22:38:53 $
     9 *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2007-02-07 23:52:54 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    301301                "Argument type (%x) is not supported.\n", arg->type);
    302302        return 0;
    303         //        psAbort(__func__, "Argument type (%x) is not supported.\n", arg->type);
     303        //        psAbort("Argument type (%x) is not supported.\n", arg->type);
    304304    }
    305305
     
    347347            break;
    348348        default:
    349             //            psAbort(__func__, "Argument type (%x) for %s is not supported.\n",
     349            //            psAbort("Argument type (%x) for %s is not supported.\n",
    350350            //                    item->type, item->name);
    351351            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
  • trunk/psLib/src/types/psMetadataItemCompare.c

    r11668 r11686  
    8383    }
    8484
    85     psAbort(__func__, "Should never get here.\n");
     85    psAbort("Should never get here.\n");
    8686    return false;
    8787}
  • trunk/psLib/src/types/psMetadataItemParse.c

    r11668 r11686  
    3939
    4040bool psMetadataItemParseBool(const psMetadataItem *item
    41                             )
     41                              )
    4242{
    4343    PS_ASSERT_PTR_NON_NULL(item, false);
  • trunk/psLib/test/imageops/tst_psImageStats.c

    r7612 r11686  
    755755        if ( myStats != tmpStats ) {
    756756            fprintf(stderr,"ERROR: input psStats not equal to return psStats\n");
    757             psAbort(__func__,"Failed input psStats equal to returned psStats");
     757            psAbort("Failed input psStats equal to returned psStats");
    758758        }
    759759        fprintf(stderr, "The sample mean was %.2f\n", myStats->sampleMean );
  • trunk/psLib/test/math/tap_psPolyFit1D.c

    r11656 r11686  
    331331    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    332332    if (0 != memLeaks) {
    333         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     333        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    334334    }
    335335
  • trunk/psLib/test/math/tap_psPolyFit2D.c

    r11656 r11686  
    343343    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    344344    if (0 != memLeaks) {
    345         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     345        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    346346    }
    347347    return (testStatus);
  • trunk/psLib/test/math/tap_psPolyFit3D.c

    r11656 r11686  
    392392    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    393393    if (0 != memLeaks) {
    394         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     394        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    395395    }
    396396
  • trunk/psLib/test/math/tap_psPolyFit4D.c

    r11656 r11686  
    450450    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    451451    if (0 != memLeaks) {
    452         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     452        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    453453    }
    454454
  • trunk/psLib/test/math/tap_psStats07.c

    r11685 r11686  
    487487    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    488488    if (0 != memLeaks) {
    489         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     489        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    490490    }
    491491
  • trunk/psLib/test/math/tap_psStats09.c

    r11685 r11686  
    338338    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    339339    if (0 != memLeaks) {
    340         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     340        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    341341    }
    342342
  • trunk/psLib/test/math/tst_psFunc01.c

    r4973 r11686  
    3939    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    4040    if (0 != memLeaks) {
    41         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     41        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    4242    }
    4343
     
    5858
    5959    if ( myGaussData->type.type != PS_TYPE_F32) {
    60         psAbort(__func__,"p_psGaussianDev did not return a vector of type F32");
     60        psAbort("p_psGaussianDev did not return a vector of type F32");
    6161    }
    6262
     
    6666    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    6767    if (0 != memLeaks) {
    68         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     68        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    6969    }
    7070
  • trunk/psLib/test/math/tst_psHist00.c

    r7999 r11686  
    123123    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    124124    if (0 != memLeaks) {
    125         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     125        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    126126    }
    127127    psMemCheckCorruption(1);
  • trunk/psLib/test/math/tst_psHist01.c

    r7999 r11686  
    112112    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    113113    if (0 != memLeaks) {
    114         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     114        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    115115    }
    116116    psMemCheckCorruption(1);
  • trunk/psLib/test/math/tst_psHist02.c

    r4859 r11686  
    179179    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    180180    if ( 0 != memLeaks ) {
    181         psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks );
     181        psAbort("Memory Leaks! (%d leaks)", memLeaks );
    182182    }
    183183    psMemCheckCorruption( 1 );
  • trunk/psLib/test/math/tst_psHist03.c

    r7999 r11686  
    126126    memLeaks = psMemCheckLeaks(currentId,NULL,NULL,false);
    127127    if (0 != memLeaks) {
    128         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     128        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    129129    }
    130130    psMemCheckCorruption(1);
  • trunk/psLib/test/math/tst_psMathUtils.c

    r6306 r11686  
    186186    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    187187    if (0 != memLeaks) {
    188         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     188        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    189189    }
    190190
  • trunk/psLib/test/math/tst_psMinimizeLMM.c

    r7182 r11686  
    144144        fflush(stdout);
    145145        // XXX: This is causing a seg fault
    146         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     146        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    147147    }
    148148
  • trunk/psLib/test/math/tst_psMinimizePowell.c

    r6484 r11686  
    134134    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    135135    if (0 != memLeaks) {
    136         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     136        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    137137    }
    138138    printFooter(stdout,
     
    209209    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    210210    if (0 != memLeaks) {
    211         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     211        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    212212    }
    213213    printFooter(stdout,
     
    275275    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    276276    if (0 != memLeaks) {
    277         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     277        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    278278    }
    279279    printFooter(stdout,
  • trunk/psLib/test/math/tst_psPolyFit1D.c

    r7106 r11686  
    306306    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    307307    if (0 != memLeaks) {
    308         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     308        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    309309    }
    310310
  • trunk/psLib/test/math/tst_psPolyFit2D.c

    r7105 r11686  
    316316    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    317317    if (0 != memLeaks) {
    318         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     318        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    319319    }
    320320
  • trunk/psLib/test/math/tst_psPolyFit3D.c

    r7136 r11686  
    361361    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    362362    if (0 != memLeaks) {
    363         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     363        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    364364    }
    365365
  • trunk/psLib/test/math/tst_psPolyFit4D.c

    r7137 r11686  
    413413    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    414414    if (0 != memLeaks) {
    415         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     415        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    416416    }
    417417
  • trunk/psLib/test/math/tst_psSpline1D.c

    r6484 r11686  
    1313*  @author GLG, MHPCC
    1414*
    15 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    16 *  @date $Date: 2006-02-24 23:43:15 $
     15*  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     16*  @date $Date: 2007-02-07 23:52:54 $
    1717*
    1818*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    128128    psS32 memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    129129    if (0 != memLeaks) {
    130         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     130        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    131131    }
    132132
     
    156156    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    157157    if (0 != memLeaks) {
    158         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     158        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    159159    }
    160160
     
    268268    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    269269    if (0 != memLeaks) {
    270         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     270        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    271271    }
    272272    /****************************************************************************/
     
    347347    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    348348    if (0 != memLeaks) {
    349         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     349        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    350350    }
    351351    return (testStatus);
     
    461461    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    462462    if (0 != memLeaks) {
    463         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     463        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    464464    }
    465465    /****************************************************************************/
     
    540540    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    541541    if (0 != memLeaks) {
    542         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     542        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    543543    }
    544544    return (testStatus);
     
    644644    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    645645    if (0 != memLeaks) {
    646         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     646        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    647647    }
    648648    /****************************************************************************/
     
    723723    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    724724    if (0 != memLeaks) {
    725         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     725        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    726726    }
    727727    return (testStatus);
     
    870870    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    871871    if (0 != memLeaks) {
    872         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     872        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    873873    }
    874874    return (testStatus);
  • trunk/psLib/test/math/tst_psStats03.c

    r7999 r11686  
    125125    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    126126    if (0 != memLeaks) {
    127         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     127        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    128128    }
    129129
  • trunk/psLib/test/math/tst_psStats05.c

    r6302 r11686  
    7474    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    7575    if (0 != memLeaks) {
    76         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     76        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    7777    }
    7878    psMemCheckCorruption(1);
  • trunk/psLib/test/math/tst_psStats06.c

    r7999 r11686  
    136136    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    137137    if (0 != memLeaks) {
    138         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     138        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    139139    }
    140140
  • trunk/psLib/test/math/tst_psStats07.c

    r7999 r11686  
    443443    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    444444    if (0 != memLeaks) {
    445         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     445        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    446446    }
    447447
  • trunk/psLib/test/math/tst_psStats08.c

    r7999 r11686  
    179179    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    180180    if (0 != memLeaks) {
    181         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     181        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    182182    }
    183183
  • trunk/psLib/test/math/tst_psStats09.c

    r7999 r11686  
    319319    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    320320    if (0 != memLeaks) {
    321         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     321        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    322322    }
    323323
  • trunk/psLib/test/types/tst_psBitSet.c

    r8966 r11686  
    1717 *  @author  Ross Harman, MHPCC
    1818 *
    19  *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
    20  *  @date  $Date: 2006-09-26 01:47:22 $
     19 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
     20 *  @date  $Date: 2007-02-07 23:52:54 $
    2121 *
    2222 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    123123            psBitSetTest(bs,23) ) {
    124124
    125         psAbort("testBitSet01b","psBitSetAlloc failed to clear all bits at allocation.");
     125        psAbort("psBitSetAlloc failed to clear all bits at allocation.");
    126126    }
    127127
     
    135135    bs = psBitSetSet(bs, 23);
    136136    if(bs != tempBs) {
    137         psAbort("testBitSet01b",
    138                 "Return pointer not equal to output argument pointer.");
     137        psAbort(                "Return pointer not equal to output argument pointer.");
    139138    }
    140139    if(bs->bits[0] != 0x05) {
    141         psAbort(__func__,
    142                 "Unexpected value for first byte (%d vs 5).",
     140        psAbort(                "Unexpected value for first byte (%d vs 5).",
    143141                bs->bits[0]);
    144142    }
     
    154152            ! psBitSetTest(bs,23) ) {
    155153
    156         psAbort("testBitSet01b","Failed to set a bit.");
     154        psAbort("Failed to set a bit.");
    157155    }
    158156
     
    173171            psBitSetTest(bs,23) ) {
    174172
    175         psAbort("testBitSet01b","Failed to clear a bit.");
     173        psAbort("Failed to clear a bit.");
    176174    }
    177175
     
    195193    if (err->code != PS_ERR_BAD_PARAMETER_VALUE) {
    196194        psErrorStackPrint(stderr,"Error Stack:");
    197         psAbort("testBitSet01c","psBitSetSet(bs, -4) didn't generate expected error.\n");
     195        psAbort("psBitSetSet(bs, -4) didn't generate expected error.\n");
    198196    }
    199197    psFree(err);
     
    206204    if (err->code != PS_ERR_BAD_PARAMETER_VALUE) {
    207205        psErrorStackPrint(stderr,"Error Stack:");
    208         psAbort("testBitSet01c","psBitSetSet(bs, 200) didn't generate expected error.\n");
     206        psAbort("psBitSetSet(bs, 200) didn't generate expected error.\n");
    209207    }
    210208    psFree(err);
     
    217215    if (err->code != PS_ERR_BAD_PARAMETER_NULL) {
    218216        psErrorStackPrint(stderr,"Error Stack:");
    219         psAbort("testBitSet01c","psBitSetSet(NULL,0) didn't generate expected error.\n");
     217        psAbort("psBitSetSet(NULL,0) didn't generate expected error.\n");
    220218    }
    221219    psFree(err);
     
    242240            ! psBitSetTest(bs,23) ) {
    243241
    244         psAbort("testBitSet01c","Set bits returned false.");
     242        psAbort("Set bits returned false.");
    245243    }
    246244
     
    248246    psErrorClear();
    249247    if(psBitSetTest(bs, -4)) {
    250         psAbort("testBitSet01c","psBitSetTest returned true with negative bit position.\n");
     248        psAbort("psBitSetTest returned true with negative bit position.\n");
    251249    }
    252250
     
    254252    if (err->code != PS_ERR_BAD_PARAMETER_VALUE) {
    255253        psErrorStackPrint(stderr,"Error Stack:");
    256         psAbort("testBitSet01c","psBitSetTest(bs, -4) didn't generate proper error.\n");
     254        psAbort("psBitSetTest(bs, -4) didn't generate proper error.\n");
    257255    }
    258256    psFree(err);
     
    261259    psErrorClear();
    262260    if(psBitSetTest(bs, 200)) {
    263         psAbort("testBitSet01c","psBitSetTest returned true with too-large bit position.\n");
     261        psAbort("psBitSetTest returned true with too-large bit position.\n");
    264262    }
    265263
     
    267265    if (err->code != PS_ERR_BAD_PARAMETER_VALUE) {
    268266        psErrorStackPrint(stderr,"Error Stack:");
    269         psAbort("testBitSet01c","psBitSetTest(bs, 200) didn't generate proper error.\n");
     267        psAbort("psBitSetTest(bs, 200) didn't generate proper error.\n");
    270268    }
    271269    psFree(err);
     
    274272    psErrorClear();
    275273    if (psBitSetTest(NULL, 0)) {
    276         psAbort("testBitSet01c","psBitSetTest returned true with NULL psBitSet.\n");
     274        psAbort("psBitSetTest returned true with NULL psBitSet.\n");
    277275    }
    278276
     
    280278    if (err->code != PS_ERR_BAD_PARAMETER_NULL) {
    281279        psErrorStackPrint(stderr,"Error Stack:");
    282         psAbort("testBitSet01c","psBitSetTest(NULL, 0) didn't generate proper error.\n");
     280        psAbort("psBitSetTest(NULL, 0) didn't generate proper error.\n");
    283281    }
    284282    psFree(err);
     
    323321    outbs = psBitSetOp(outbs, bs1, "AND", bs2);
    324322    if (outbs == NULL) {
    325         psAbort(__func__,"psBitSetOp returned a NULL result for AND operation");
     323        psAbort("psBitSetOp returned a NULL result for AND operation");
    326324    }
    327325
     
    333331            binOut2 = psBitSetToString(bs2);
    334332            binOut3 = psBitSetToString(outbs);
    335             psAbort(__func__,"psBitSetOp with AND operator failed.\nInput was %s, %s.  Output was %s",
     333            psAbort("psBitSetOp with AND operator failed.\nInput was %s, %s.  Output was %s",
    336334                    binOut1,binOut2,binOut3);
    337335        }
     
    343341    outbs = psBitSetOp(NULL, bs1, "AND", bs2);
    344342    if (outbs == NULL) {
    345         psAbort(__func__,"psBitSetOp failed to create a new psBitSet for the result");
     343        psAbort("psBitSetOp failed to create a new psBitSet for the result");
    346344    }
    347345    for(psS32 i=0; i<24; i++) {
     
    352350            binOut2 = psBitSetToString(bs2);
    353351            binOut3 = psBitSetToString(outbs);
    354             psAbort(__func__,"psBitSetOp with AND operator failed.\nInput was %s, %s.  Output was %s",
     352            psAbort("psBitSetOp with AND operator failed.\nInput was %s, %s.  Output was %s",
    355353                    binOut1,binOut2,binOut3);
    356354        }
     
    400398    outbs = psBitSetOp(outbs, bs1, "OR", bs2);
    401399    if (outbs == NULL) {
    402         psAbort(__func__,"psBitSetOp returned a NULL result for OR operation");
     400        psAbort("psBitSetOp returned a NULL result for OR operation");
    403401    }
    404402
     
    410408            binOut2 = psBitSetToString(bs2);
    411409            binOut3 = psBitSetToString(outbs);
    412             psAbort(__func__,"psBitSetOp with OR operator failed.\nInput was %s, %s.  Output was %s",
     410            psAbort("psBitSetOp with OR operator failed.\nInput was %s, %s.  Output was %s",
    413411                    binOut1,binOut2,binOut3);
    414412        }
     
    420418    outbs = psBitSetOp(NULL, bs1, "OR", bs2);
    421419    if (outbs == NULL) {
    422         psAbort(__func__,"psBitSetOp failed to create a new psBitSet for the result");
     420        psAbort("psBitSetOp failed to create a new psBitSet for the result");
    423421    }
    424422    for(psS32 i=0; i<24; i++) {
     
    429427            binOut2 = psBitSetToString(bs2);
    430428            binOut3 = psBitSetToString(outbs);
    431             psAbort(__func__,"psBitSetOp with OR operator failed.\nInput was %s, %s.  Output was %s",
     429            psAbort("psBitSetOp with OR operator failed.\nInput was %s, %s.  Output was %s",
    432430                    binOut1,binOut2,binOut3);
    433431        }
     
    478476    outbs = psBitSetOp(outbs, bs1, "XOR", bs2);
    479477    if (outbs == NULL) {
    480         psAbort(__func__,"psBitSetOp returned a NULL result for XOR operation");
     478        psAbort("psBitSetOp returned a NULL result for XOR operation");
    481479    }
    482480
     
    488486            binOut2 = psBitSetToString(bs2);
    489487            binOut3 = psBitSetToString(outbs);
    490             psAbort(__func__,"psBitSetOp with XOR operator failed.\nInput was %s, %s.  Output was %s",
     488            psAbort("psBitSetOp with XOR operator failed.\nInput was %s, %s.  Output was %s",
    491489                    binOut1,binOut2,binOut3);
    492490        }
     
    498496    outbs = psBitSetOp(NULL, bs1, "XOR", bs2);
    499497    if (outbs == NULL) {
    500         psAbort(__func__,"psBitSetOp failed to create a new psBitSet for the result");
     498        psAbort("psBitSetOp failed to create a new psBitSet for the result");
    501499    }
    502500    for(psS32 i=0; i<24; i++) {
     
    507505            binOut2 = psBitSetToString(bs2);
    508506            binOut3 = psBitSetToString(outbs);
    509             psAbort(__func__,"psBitSetOp with XOR operator failed.\nInput was %s, %s.  Output was %s",
     507            psAbort("psBitSetOp with XOR operator failed.\nInput was %s, %s.  Output was %s",
    510508                    binOut1,binOut2,binOut3);
    511509        }
     
    549547    outbs = psBitSetNot(outbs, bs1);
    550548    if (outbs == NULL) {
    551         psAbort(__func__,"psBitSetOp returned a NULL result for NOT operation");
     549        psAbort("psBitSetOp returned a NULL result for NOT operation");
    552550    }
    553551
     
    558556            binOut1 = psBitSetToString(bs1);
    559557            binOut2 = psBitSetToString(outbs);
    560             psAbort(__func__,"psBitSetOp with NOT operator failed.\nInput was %s.  Output was %s",
     558            psAbort("psBitSetOp with NOT operator failed.\nInput was %s.  Output was %s",
    561559                    binOut1,binOut2);
    562560        }
     
    568566    outbs = psBitSetNot(NULL, bs1);
    569567    if (outbs == NULL) {
    570         psAbort(__func__,"psBitSetOp failed to create a new psBitSet for the result");
     568        psAbort("psBitSetOp failed to create a new psBitSet for the result");
    571569    }
    572570    for(psS32 i=0; i<24; i++) {
     
    576574            binOut1 = psBitSetToString(bs1);
    577575            binOut2 = psBitSetToString(outbs);
    578             psAbort(__func__,"psBitSetOp with NOT operator failed.\nInput was %s.  Output was %s",
     576            psAbort("psBitSetOp with NOT operator failed.\nInput was %s.  Output was %s",
    579577                    binOut1,binOut2);
    580578        }
     
    605603    psBitSet* outbs = psBitSetOp(NULL, bs1, "XOR", bs2);
    606604    if (outbs != NULL) {
    607         psAbort(__func__,"psBitSetOp did not return a NULL result when input sizes differ");
     605        psAbort("psBitSetOp did not return a NULL result when input sizes differ");
    608606    }
    609607
     
    611609    if (err->code != PS_ERR_BAD_PARAMETER_SIZE) {
    612610        psErrorStackPrint(stderr,"Error Stack:");
    613         psAbort(__func__,"psBitSetOp didn't generate expected error with operands' sizes differed.");
     611        psAbort("psBitSetOp didn't generate expected error with operands' sizes differed.");
    614612    }
    615613    psFree(err);
     
    623621    psBitSet* outbs2 = psBitSetOp(outbs, bs1, "XOR", bs2);
    624622    if (outbs2 == NULL) {
    625         psAbort(__func__,"psBitSetOp failed when input size and output size differed (a recoverable error).");
     623        psAbort("psBitSetOp failed when input size and output size differed (a recoverable error).");
    626624    }
    627625    if (outbs2 != outbs) {
    628         psAbort(__func__,"psBitSetOp didn't reuse the given output struct.");
     626        psAbort("psBitSetOp didn't reuse the given output struct.");
    629627    }
    630628    if (outbs2->n != bs1->n) {
    631         psAbort(__func__,"psBitSetOp did properly adjust the output psBitSet size.");
     629        psAbort("psBitSetOp did properly adjust the output psBitSet size.");
    632630    }
    633631
     
    636634    outbs = psBitSetOp(outbs, bs1, "FOO", bs2);
    637635    if (outbs != NULL) {
    638         psAbort(__func__,"psBitSetOp returned something in case of a bogus operation.");
     636        psAbort("psBitSetOp returned something in case of a bogus operation.");
    639637    }
    640638    err = psErrorLast();
    641639    if (err->code != PS_ERR_BAD_PARAMETER_VALUE) {
    642640        psErrorStackPrint(stderr,"Error Stack:");
    643         psAbort(__func__,"psBitSetOp didn't generate expected error with bogus operator.");
     641        psAbort("psBitSetOp didn't generate expected error with bogus operator.");
    644642    }
    645643    psFree(err);
     
    655653    if (err->code != PS_ERR_BAD_PARAMETER_VALUE) {
    656654        psErrorStackPrint(stderr,"Error Stack:");
    657         psAbort(__func__,"psBitSetOp didn't generate expected error with bogus operator.");
     655        psAbort("psBitSetOp didn't generate expected error with bogus operator.");
    658656    }
    659657    psFree(err);
  • trunk/psLib/test/types/tst_psHash00.c

    r4547 r11686  
    5757    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    5858    if (0 != memLeaks) {
    59         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     59        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    6060    }
    6161    psMemCheckCorruption(1);
  • trunk/psLib/test/types/tst_psHash01.c

    r4547 r11686  
    148148    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    149149    if (memLeaks != 0) {
    150         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     150        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    151151    }
    152152    psMemCheckCorruption(1);
  • trunk/psLib/test/types/tst_psHash02.c

    r4547 r11686  
    106106    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    107107    if (0 != memLeaks) {
    108         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     108        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    109109    }
    110110    psMemCheckCorruption(1);
  • trunk/psLib/test/types/tst_psHash03.c

    r4547 r11686  
    134134    memLeaks = psMemCheckLeaks(currentId,NULL,stdout,false);
    135135    if (memLeaks != 0) {
    136         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     136        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    137137    }
    138138    psMemCheckCorruption(true);
  • trunk/psLib/test/types/tst_psHash04.c

    r4547 r11686  
    7777    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    7878    if (memLeaks != 0) {
    79         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     79        psAbort("Memory Leaks! (%d leaks)", memLeaks);
    8080    }
    8181    psMemCheckCorruption(1);
Note: See TracChangeset for help on using the changeset viewer.