IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 23487


Ignore:
Timestamp:
Mar 23, 2009, 9:42:42 AM (17 years ago)
Author:
Paul Price
Message:

Functions declared as 'type function()' cause errors with the Intel compiler ('error #310: old-style parameter list (anachronism)'), which wants 'type function()'. These instances haven't caused problems yet, and I'm trying to avoid that.

Location:
trunk
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/pxerrors.c

    r17611 r23487  
    2424#include "pxtools.h"
    2525
    26 psExit pxerrorGetExitStatus () {
     26psExit pxerrorGetExitStatus(void) {
    2727
    2828    psErrorCode err = psErrorCodeLast ();
    … …  
    3838      default:
    3939    return PS_EXIT_UNKNOWN_ERROR;
    40     }   
     40    }
    4141    return PS_EXIT_UNKNOWN_ERROR;
    4242}

  • trunk/ippTools/src/pxtools.h

    r18561 r23487  
    5353bool pxSetFaultCode(psDB *dbh, const char *tableName, psMetadata *where, psS16 code);
    5454
    55 psExit pxerrorGetExitStatus ();
     55psExit pxerrorGetExitStatus(void);
    5656
    5757void pxUsage(FILE *stream, int argc, char **argv, const char *modeName, psMetadata *argSet);
    … …  
    303303#define PXOPT_ADD_WHERE_BOOL(name) \
    304304{ \
    305     bool value = false;  \
     305    bool value = false;  \
    306306    bool status = false; \
    307307    if ((value = psMetadataLookupBool(&status, config->args, "-" #name))) { \
    … …  
    370370}
    371371
    372 #define PXOPT_ADD_WHERE_BOOL_ALIAS(flag,name)   \
     372#define PXOPT_ADD_WHERE_BOOL_ALIAS(flag,name)   \
    373373{ \
    374374    bool value = 0; \
    375375    bool status = false; \
    376     if ((value = psMetadataLookupBool(&status, config->args, flag))) {  \
     376    if ((value = psMetadataLookupBool(&status, config->args, flag))) {  \
    377377        if (!psMetadataAddBOOL(config->where, PS_LIST_TAIL, name, 0, "==", value)) { \
    378378            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
    … …  
    383383}
    384384
    385 #define PXOPT_ADD_WHERE_S16_ALIAS(flag,name)    \
     385#define PXOPT_ADD_WHERE_S16_ALIAS(flag,name)    \
    386386{ \
    387387    psS16 s16 = 0; \
    388388    bool status = false; \
    389     if ((s16= psMetadataLookupS16(&status, config->args, flag))) {      \
     389    if ((s16= psMetadataLookupS16(&status, config->args, flag))) {      \
    390390        if (!psMetadataAddS16(config->where, PS_LIST_TAIL, name, 0, "==", s16)) { \
    391391            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
    … …  
    396396}
    397397
    398 #define PXOPT_ADD_WHERE_S32_ALIAS(flag,name)    \
     398#define PXOPT_ADD_WHERE_S32_ALIAS(flag,name)    \
    399399{ \
    400400    psS32 s32 = 0; \
    401401    bool status = false; \
    402     if ((s32= psMetadataLookupS32(&status, config->args, flag))) {      \
     402    if ((s32= psMetadataLookupS32(&status, config->args, flag))) {      \
    403403        if (!psMetadataAddS32(config->where, PS_LIST_TAIL, name, 0, "==", s32)) { \
    404404            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
    … …  
    409409}
    410410
    411 #define PXOPT_ADD_WHERE_S64_ALIAS(flag,name)    \
     411#define PXOPT_ADD_WHERE_S64_ALIAS(flag,name)    \
    412412{ \
    413413    psS64 s64 = 0; \
    414414    bool status = false; \
    415     if ((s64= psMetadataLookupS64(&status, config->args, flag))) {      \
     415    if ((s64= psMetadataLookupS64(&status, config->args, flag))) {      \
    416416        if (!psMetadataAddS64(config->where, PS_LIST_TAIL, name, 0, "==", s64)) { \
    417417            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
    … …  
    422422}
    423423
    424 #define PXOPT_ADD_WHERE_F32_ALIAS(flag,name)    \
     424#define PXOPT_ADD_WHERE_F32_ALIAS(flag,name)    \
    425425{ \
    426426    psF32 var = 0; \
    427427    bool status = false; \
    428     if ((var = psMetadataLookupF32(&status, config->args, flag))) {     \
     428    if ((var = psMetadataLookupF32(&status, config->args, flag))) {     \
    429429        if (!isnan(var))  { \
    430430            if (!psMetadataAddF32(config->where, PS_LIST_TAIL, name, 0, "==", var)) { \
    … …  
    437437}
    438438
    439 #define PXOPT_ADD_WHERE_F64_ALIAS(flag,name)    \
     439#define PXOPT_ADD_WHERE_F64_ALIAS(flag,name)    \
    440440{ \
    441441    psF64 var = 0; \
    442442    bool status = false; \
    443     if ((var = psMetadataLookupF64(&status, config->args, flag))) {     \
     443    if ((var = psMetadataLookupF64(&status, config->args, flag))) {     \
    444444        if (!isnan(var))  { \
    445445            if (!psMetadataAddF64(config->where, PS_LIST_TAIL, name, 0, "==", var)) { \

  • trunk/magic/remove/src/streaksio.c

    r21481 r23487  
    7575        }
    7676    }
    77      
     77
    7878    psElemType tileType;                // Type corresponding to "long"
    7979    if (sizeof(long) == sizeof(psS64)) {
    … …  
    214214
    215215        // XXX: I should probably be using a different file rule for diffs, but I don't
    216         // have an input rule that takes a diff image. 
     216        // have an input rule that takes a diff image.
    217217        // Since they're skycells, this should be compatible
    218218        sfile->pmfile = pmFPAfileDefineFromArgs(&status, config, "PPSUB.INPUT", "INPUT");
    … …  
    229229        psFree(view);
    230230        sfile->resolved_name = psStringCopy(sfile->pmfile->filename);
    231        
     231
    232232        // copy header from fpu
    233233        sfile->header = (psMetadata*) psMemIncrRefCounter(sfile->pmfile->fpa->hdu->header);
    … …  
    248248    }
    249249
    250     // if outputFilename is not null name it contains the "directory" 
     250    // if outputFilename is not null name it contains the "directory"
    251251    // and outputFilename is the basename name of the file (or nebulous key)
    252252    // and the file is to be opened for writing
    … …  
    293293    bool status = psFitsMoveExtNum(sfile->fits, extnum, false);
    294294    if (!status) {
    295         psError(PS_ERR_IO, false, 
     295        psError(PS_ERR_IO, false,
    296296            "failed to move to extension %d for %s", extnum, sfile->resolved_name);
    297297        streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    427427        return true;
    428428    } else if (in->nHDU == 1) {
    429         // no extensions in the file, can just return true? For now require 
     429        // no extensions in the file, can just return true? For now require
    430430        // at least one dimension
    431431        int naxis =  psMetadataLookupS32(&status, in->header, "NAXIS");
    … …  
    524524    in->header = psFitsReadHeader(NULL, in->fits);
    525525    if (!in->header) {
    526         psError(PS_ERR_IO, false, "failed to read header from %s extnum: %d", 
     526        psError(PS_ERR_IO, false, "failed to read header from %s extnum: %d",
    527527            in->resolved_name, extnum);
    528528        streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    541541        in->image = psFitsReadImage(in->fits, region, 0);
    542542        if (!in->image) {
    543             psError(PS_ERR_IO, false, "failed to read image from %s extnum: %d", 
     543            psError(PS_ERR_IO, false, "failed to read image from %s extnum: %d",
    544544                in->resolved_name, extnum);
    545545            streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    559559        in->imagecube = psFitsReadImageCube(in->fits, region);
    560560        if (!in->imagecube) {
    561             psError(PS_ERR_IO, false, "failed to read image cube from %s extnum: %d", 
     561            psError(PS_ERR_IO, false, "failed to read image cube from %s extnum: %d",
    562562                in->resolved_name, extnum);
    563563            streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    631631        // XXX abort?
    632632        return;
    633     } 
     633    }
    634634    if (!extname) {
    635635        psWarning("extnum %d has no image and extname not defined in %s",
    … …  
    689689    }
    690690    if (!psFitsWriteImage(sfile->fits, sfile->header, sfile->image, 0, extname)) {
    691         psError(PS_ERR_IO, false, "failed to write image to %s extnum: %d", 
     691        psError(PS_ERR_IO, false, "failed to write image to %s extnum: %d",
    692692            sfile->resolved_name, extnum);
    693693        streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    706706    }
    707707    if (!psFitsWriteImageCube(sfile->fits, sfile->header, imagecube, extname)) {
    708         psError(PS_ERR_IO, false, "failed to write image to %s extnum: %d", 
     708        psError(PS_ERR_IO, false, "failed to write image to %s extnum: %d",
    709709            sfile->resolved_name, extnum);
    710710        streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    732732    }
    733733    if (sfile->fits && !psFitsClose(sfile->fits)) {
    734         psError(PS_ERR_IO, false, "failed to close image to %s", 
     734        psError(PS_ERR_IO, false, "failed to close image to %s",
    735735            sfile->resolved_name);
    736736        streaksExit("", PS_EXIT_DATA_ERROR);
    … …  
    10301030
    10311031void
    1032 streaksNebulousCleanup()
     1032streaksNebulousCleanup(void)
    10331033{
    10341034    nebServerFree(ourNebServer);

  • trunk/magic/remove/src/streaksio.h

    r21481 r23487  
    3030bool swapOutputsToInputs(streakFiles *sf);
    3131bool deleteTemps(streakFiles *sf);
    32 void streaksNebulousCleanup();
     32void streaksNebulousCleanup(void);
    3333
    3434#endif // STREAKS_IO_H

  • trunk/ppSim/src/ppSim.h

    r23465 r23487  
    6767} ppSimGalaxy;
    6868
    69 ppSimStar *ppSimStarAlloc ();
    70 ppSimGalaxy *ppSimGalaxyAlloc ();
     69ppSimStar *ppSimStarAlloc(void);
     70ppSimGalaxy *ppSimGalaxyAlloc(void);
    7171
    7272/// Parse command-line arguments
    … …  
    136136
    137137// add a bad CTE region
    138 bool ppSimBadCTE(psImage *image,        // Signal image, modified and returned
    139                 const pmConfig *config // configuration
     138bool ppSimBadCTE(psImage *image,        // Signal image, modified and returned
     139                const pmConfig *config // configuration
    140140  );
    141141
    … …  
    189189double ppSimRandomGaussian (const psRandom *rnd, double mean, double sigma);
    190190double ppSimRandomGaussianNorm (const psRandom *rnd);
    191 void ppSimRandomGaussianFree();
     191void ppSimRandomGaussianFree(void);
    192192
    193193bool ppSimPhotomFiles (pmConfig *config, pmFPAfile *fakeFile, pmFPAfile *forceFile);

  • trunk/ppSim/src/ppSimRandomGaussian.c

    r18011 r23487  
    2929
    3030/* integrate a gaussian from -5 sigma to +5 sigma */
    31 void p_ppSimRandomGaussianInit () {
    32  
     31void p_ppSimRandomGaussianInit (void) {
     32
    3333  int i;
    3434  long A, B;
    3535  double val, x, dx, dx1, dx2, dx3, df;
    3636  double mean, sigma;
    37  
     37
    3838  /* no need to generate this if it already exists */
    3939  if (gaussint) return;
    … …  
    4242  for (B = 0; A == time(NULL); B++);
    4343  srand48(B);
    44  
     44
    4545  Ngaussint = 0x1000;
    4646  ppSimRandomGaussianAlloc (Ngaussint + 1);
    … …  
    5353  mean = 0.0;
    5454  sigma = 1.0;
    55  
     55
    5656  for (i = 0, x = -7.0; (i < Ngaussint) && (x < 7.0); x += dx)  {
    57     df = (3.0*p_ppSimGaussian(x    , mean, sigma) + 
     57    df = (3.0*p_ppSimGaussian(x    , mean, sigma) +
    5858          9.0*p_ppSimGaussian(x+dx1, mean, sigma) +
    59           9.0*p_ppSimGaussian(x+dx2, mean, sigma) + 
     59          9.0*p_ppSimGaussian(x+dx2, mean, sigma) +
    6060          3.0*p_ppSimGaussian(x+dx3, mean, sigma)) * (dx1/8.0);
    6161    val += df;
    … …  
    6767}
    6868
    69 // XXX we are using drand48() rather than the random var supplied by rnd 
     69// XXX we are using drand48() rather than the random var supplied by rnd
    7070double ppSimRandomGaussian (const psRandom *rnd, double mean, double sigma) {
    71  
     71
    7272  int i;
    7373  double y;
    74  
     74
    7575  if (gaussint == NULL) {
    7676      p_ppSimRandomGaussianInit ();
    … …  
    8080  i = Ngaussint*y;
    8181  y = gaussint[i]*sigma + mean;
    82  
     82
    8383  return (y);
    84  
     84
    8585}
    86  
    87 // XXX we are using drand48() rather than the random var supplied by rnd 
     86
     87// XXX we are using drand48() rather than the random var supplied by rnd
    8888double ppSimRandomGaussianNorm (const psRandom *rnd) {
    89  
     89
    9090  int i;
    9191  double y;
    92  
     92
    9393  if (gaussint == NULL) {
    9494      p_ppSimRandomGaussianInit ();
    … …  
    9898  i = Ngaussint*y;
    9999  y = gaussint[i];
    100  
     100
    101101  return (y);
    102102}

  • trunk/ppSim/src/ppSimStars.c

    r17557 r23487  
    66}
    77
    8 ppSimStar *ppSimStarAlloc () {
     8ppSimStar *ppSimStarAlloc(void) {
    99
    1010    ppSimStar *star = (ppSimStar *) psAlloc(sizeof(ppSimStar));
    … …  
    1919}
    2020
    21 ppSimGalaxy *ppSimGalaxyAlloc () {
     21ppSimGalaxy *ppSimGalaxyAlloc(void) {
    2222
    2323    ppSimGalaxy *galaxy = (ppSimGalaxy *) psAlloc(sizeof(ppSimGalaxy));

  • trunk/psModules/src/astrom/pmAstrometryDistortion.c

    r21183 r23487  
    4040}
    4141
    42 pmAstromGradient *pmAstromGradientAlloc ()
     42pmAstromGradient *pmAstromGradientAlloc (void)
    4343{
    4444
    … …  
    126126            grad = pmAstromGradientAlloc ();
    127127
    128             // XXX psTraceSetLevel("psLib.math.psVectorClipFitPolynomial2D", 7);
     128            // XXX psTraceSetLevel("psLib.math.psVectorClipFitPolynomial2D", 7);
    129129
    130130            // fit the collection of positions and offsets with a local 1st order gradient
    … …  
    138138            grad->dTPdM.x = local->coeff[0][1];
    139139
    140             // XXX psTraceSetLevel("psLib.math.psVectorClipFitPolynomial2D", 0);
     140            // XXX psTraceSetLevel("psLib.math.psVectorClipFitPolynomial2D", 0);
    141141
    142142            // fit the collection of positions and offsets with a local 1st order gradient

  • trunk/psModules/src/astrom/pmAstrometryDistortion.h

    r12486 r23487  
    2727pmAstromGradient;
    2828
    29 pmAstromGradient *pmAstromGradientAlloc ();
     29pmAstromGradient *pmAstromGradientAlloc (void);
    3030
    3131/* The following function determines the position residual, in the tangent

  • trunk/psModules/src/astrom/pmAstrometryVisual.c

    r23242 r23487  
    4747/* Initialization Routines  */
    4848
    49 bool pmAstromVisualClose()
     49bool pmAstromVisualClose(void)
    5050{
    5151    if(kapa != -1)

  • trunk/psModules/src/astrom/pmAstrometryVisual.h

    r23242 r23487  
    2626/** Close plotting windows at the end of a run
    2727 * @return true for success */
    28 bool pmAstromVisualClose();
     28bool pmAstromVisualClose(void);
    2929
    3030

  • trunk/psModules/src/camera/pmFPAfile.c

    r23358 r23487  
    5858}
    5959
    60 pmFPAfile *pmFPAfileAlloc()
     60pmFPAfile *pmFPAfileAlloc(void)
    6161{
    6262    pmFPAfile *file = psAlloc(sizeof(pmFPAfile));

  • trunk/psModules/src/camera/pmFPAfile.h

    r23358 r23487  
    115115
    116116// allocate an empty pmFPAfile structure
    117 pmFPAfile *pmFPAfileAlloc ();
     117pmFPAfile *pmFPAfileAlloc(void);
    118118
    119119// select the readout from the named pmFPAfile; if the named file does not exist,

  • trunk/psModules/src/detrend/pmDetrendDB.h

    r23268 r23487  
    6363
    6464pmDetrendSelectOptions *pmDetrendSelectOptionsAlloc(const char *camera, psTime time, pmDetrendType type);
    65 pmDetrendSelectResults *pmDetrendSelectResultsAlloc();
     65pmDetrendSelectResults *pmDetrendSelectResultsAlloc(void);
    6666pmDetrendSelectResults *pmDetrendSelect (const pmDetrendSelectOptions *options, const pmConfig *config);
    6767char *pmDetrendFile (const char *detID, const char *classID, const pmConfig *config);

  • trunk/psModules/src/detrend/pmDetrendThreads.h

    r18893 r23487  
    1818
    1919/// get the requested number of scan rows per thread
    20 int pmDetrendGetScanRows ();
     20int pmDetrendGetScanRows(void);
    2121
    2222/// @}

  • trunk/psModules/src/detrend/pmShutterCorrection.c

    r23259 r23487  
    7171}
    7272
    73 pmShutterCorrection *pmShutterCorrectionAlloc()
     73pmShutterCorrection *pmShutterCorrectionAlloc(void)
    7474{
    7575    pmShutterCorrection *corr = (pmShutterCorrection*)psAlloc(sizeof(pmShutterCorrection));

  • trunk/psModules/src/detrend/pmShutterCorrection.h

    r21509 r23487  
    6969
    7070/// Allocator for shutter correction parameters
    71 pmShutterCorrection *pmShutterCorrectionAlloc();
     71pmShutterCorrection *pmShutterCorrectionAlloc(void);
    7272
    7373/// Guess a shutter correction, based on plot of counts vs exposure time

  • trunk/psModules/src/extras/pmKapaPlots.c

    r13896 r23487  
    4747}
    4848
    49 bool pmKapaClose ()
     49bool pmKapaClose (void)
    5050{
    5151

  • trunk/psModules/src/extras/pmKapaPlots.h

    r12696 r23487  
    11/* @file  pmKapaPlots.h
    2  * @brief functions to make plots with the external program 'kapa' 
     2 * @brief functions to make plots with the external program 'kapa'
    33 *
    44 * @author EAM, IfA
    … …  
    1717// move to psLib or psModules
    1818int pmKapaOpen (bool showWindow);
    19 bool pmKapaClose ();
     19bool pmKapaClose(void);
    2020bool pmKapaPlotVectorPair (psVector *xVec, psVector *yVec);
    2121

  • trunk/psModules/src/extras/psPipe.c

    r12888 r23487  
    3535}
    3636
    37 psPipe *psPipeAlloc ()
     37psPipe *psPipeAlloc (void)
    3838{
    3939    psPipe *pipe = (psPipe *)psAlloc(sizeof(psPipe));

  • trunk/psModules/src/extras/psPipe.h

    r11253 r23487  
    11/* @file  psPipe.h
    2  * @brief 3-stream pipe 
     2 * @brief 3-stream pipe
    33 *
    44 * @author EAM, IfA
    … …  
    2626
    2727// psPipe functions
    28 psPipe *psPipeAlloc ();
     28psPipe *psPipeAlloc (void);
    2929psPipe *psPipeOpen (char *command);
    3030int     psPipeClose (psPipe *pipe);

  • trunk/psModules/src/imcombine/pmSubtractionVisual.c

    r23242 r23487  
    4444
    4545/** destroy windows at the end of a run*/
    46 bool pmSubtractionVisualClose()
     46bool pmSubtractionVisualClose(void)
    4747{
    4848    if(kapa != -1)
    … …  
    256256
    257257#else
    258 bool pmSubtractionVisualClose() {return true;}
     258bool pmSubtractionVisualClose(void) {return true;}
    259259bool pmSubtractionVisualPlotConvKernels(psImage *convKernels) {return true;}
    260260bool pmSubtractionVisualPlotStamps(pmSubtractionStampList *stamps, pmReadout *ro) {return true;}

  • trunk/psModules/src/imcombine/pmSubtractionVisual.h

    r23242 r23487  
    22#define PM_SUBTRACTION_VISUAL_H
    33
    4 bool pmSubtractionVisualClose();
     4bool pmSubtractionVisualClose(void);
    55bool pmSubtractionVisualPlotConvKernels(psImage *convKernels);
    66bool pmSubtractionVisualPlotStamps(pmSubtractionStampList *stamps, pmReadout *ro);

  • trunk/psModules/src/objects/pmDetections.c

    r18828 r23487  
    3030
    3131// generate a pmDetections container with empty (allocated) footprints and peaks containers
    32 pmDetections *pmDetectionsAlloc() {
     32pmDetections *pmDetectionsAlloc(void) {
    3333
    3434    pmDetections *detections = (pmDetections *)psAlloc(sizeof(pmDetections));

  • trunk/psModules/src/objects/pmDetections.h

    r18828 r23487  
    2020 */
    2121typedef struct {
    22   psArray *footprints;        // collection of footprints in the image
    23   psArray *peaks;             // collection of all peaks contained by the footprints
    24   psArray *oldPeaks;          // collection of all peaks previously found
     22  psArray *footprints;        // collection of footprints in the image
     23  psArray *peaks;             // collection of all peaks contained by the footprints
     24  psArray *oldPeaks;          // collection of all peaks previously found
    2525  int last;
    2626} pmDetections;
    2727
    28 pmDetections *pmDetectionsAlloc ();
     28pmDetections *pmDetectionsAlloc (void);
    2929
    3030/// @}

  • trunk/psModules/src/objects/pmMoments.c

    r23187 r23487  
    2525to zero.
    2626*****************************************************************************/
    27 pmMoments *pmMomentsAlloc()
     27pmMoments *pmMomentsAlloc(void)
    2828{
    2929    psTrace("psModules.objects", 10, "---- %s() begin ----\n", __func__);

  • trunk/psModules/src/objects/pmMoments.h

    r19879 r23487  
    5353 *
    5454 */
    55 pmMoments *pmMomentsAlloc();
     55pmMoments *pmMomentsAlloc(void);
    5656
    5757/// @}

  • trunk/psModules/src/objects/pmPSF.c

    r20937 r23487  
    5454}
    5555
    56 pmPSFOptions *pmPSFOptionsAlloc () {
     56pmPSFOptions *pmPSFOptionsAlloc (void) {
    5757
    5858    pmPSFOptions *options = (pmPSFOptions *) psAlloc(sizeof(pmPSFOptions));

  • trunk/psModules/src/objects/pmPSF.h

    r21183 r23487  
    9696pmPSF *pmPSFAlloc (const pmPSFOptions *options);
    9797bool psMemCheckPSF(psPtr ptr);
    98 pmPSFOptions *pmPSFOptionsAlloc();
     98pmPSFOptions *pmPSFOptionsAlloc(void);
    9999bool psMemCheckPSFOptions(psPtr ptr);
    100100

  • trunk/psModules/src/objects/pmSource.h

    r23184 r23487  
    105105 *
    106106 */
    107 pmSource  *pmSourceAlloc();
     107pmSource  *pmSourceAlloc(void);
    108108
    109109/** pmSourceCopy()

  • trunk/psModules/src/objects/pmSourceExtendedPars.c

    r21363 r23487  
    4646}
    4747
    48 pmSourceExtendedPars *pmSourceExtendedParsAlloc () {
     48pmSourceExtendedPars *pmSourceExtendedParsAlloc (void) {
    4949    pmSourceExtendedPars *pars = (pmSourceExtendedPars *) psAlloc(sizeof(pmSourceExtendedPars));
    5050    psMemSetDeallocator(pars, (psFreeFunc) pmSourceExtendedParsFree);
    … …  
    7575}
    7676
    77 pmSourceRadialProfile *pmSourceRadialProfileAlloc () {
     77pmSourceRadialProfile *pmSourceRadialProfileAlloc (void) {
    7878
    7979    pmSourceRadialProfile *profile = (pmSourceRadialProfile *) psAlloc(sizeof(pmSourceRadialProfile));
    … …  
    9999}
    100100
    101 pmSourceIsophotalValues *pmSourceIsophotalValuesAlloc () {
     101pmSourceIsophotalValues *pmSourceIsophotalValuesAlloc (void) {
    102102
    103103    pmSourceIsophotalValues *isophot = (pmSourceIsophotalValues *) psAlloc(sizeof(pmSourceIsophotalValues));
    … …  
    125125}
    126126
    127 pmSourcePetrosianValues *pmSourcePetrosianValuesAlloc () {
     127pmSourcePetrosianValues *pmSourcePetrosianValuesAlloc (void) {
    128128
    129129    pmSourcePetrosianValues *petrosian = (pmSourcePetrosianValues *) psAlloc(sizeof(pmSourcePetrosianValues));
    … …  
    150150}
    151151
    152 pmSourceKronValues *pmSourceKronValuesAlloc () {
     152pmSourceKronValues *pmSourceKronValuesAlloc (void) {
    153153
    154154    pmSourceKronValues *kron = (pmSourceKronValues *) psAlloc(sizeof(pmSourceKronValues));
    … …  
    181181}
    182182
    183 pmSourceAnnuli *pmSourceAnnuliAlloc () {
     183pmSourceAnnuli *pmSourceAnnuliAlloc (void) {
    184184
    185185    pmSourceAnnuli *annuli = (pmSourceAnnuli *) psAlloc(sizeof(pmSourceAnnuli));

  • trunk/psModules/src/objects/pmSourceExtendedPars.h

    r21363 r23487  
    5555} pmSourceExtendedPars;
    5656
    57 pmSourceExtendedPars *pmSourceExtendedParsAlloc ();
     57pmSourceExtendedPars *pmSourceExtendedParsAlloc(void);
    5858bool psMemCheckSourceExtendedPars(psPtr ptr);
    59 pmSourceRadialProfile *pmSourceRadialProfileAlloc ();
     59pmSourceRadialProfile *pmSourceRadialProfileAlloc(void);
    6060bool psMemCheckSourceRadialProfile(psPtr ptr);
    61 pmSourceIsophotalValues *pmSourceIsophotalValuesAlloc ();
     61pmSourceIsophotalValues *pmSourceIsophotalValuesAlloc(void);
    6262bool psMemCheckSourceIsophotalValues(psPtr ptr);
    63 pmSourcePetrosianValues *pmSourcePetrosianValuesAlloc ();
     63pmSourcePetrosianValues *pmSourcePetrosianValuesAlloc(void);
    6464bool psMemCheckSourcePetrosianValues(psPtr ptr);
    65 pmSourceKronValues *pmSourceKronValuesAlloc ();
     65pmSourceKronValues *pmSourceKronValuesAlloc(void);
    6666bool psMemCheckSourceKronValues(psPtr ptr);
    67 pmSourceAnnuli *pmSourceAnnuliAlloc ();
     67pmSourceAnnuli *pmSourceAnnuliAlloc(void);
    6868bool psMemCheckSourceAnnuli(psPtr ptr);
    6969

  • trunk/psModules/src/objects/pmSourceFitSet.c

    r23187 r23487  
    6767}
    6868
    69 void pmSourceFitSetDone () {
     69void pmSourceFitSetDone (void) {
    7070    psFree (fitSets);
    7171}
    … …  
    150150}
    151151
    152 pmSourceFitSetData *pmSourceFitSetDataGet () {
     152pmSourceFitSetData *pmSourceFitSetDataGet (void) {
    153153
    154154    psAssert (fitSets, "pmSourceFitSetInit not called");
    … …  
    172172}
    173173
    174 void pmSourceFitSetDataClear () {
     174void pmSourceFitSetDataClear (void) {
    175175
    176176    int i;

  • trunk/psModules/src/objects/pmSourceFitSet.h

    r21183 r23487  
    2424// use this function to init the fit sets based on the number of threads
    2525bool pmSourceFitSetInit (int nThreads);
    26 void pmSourceFitSetDone ();
     26void pmSourceFitSetDone (void);
    2727
    2828// initialize data for a group of object models
    … …  
    3232// functions for selecting the FitSet corresponding to the current thread
    3333pmSourceFitSetData *pmSourceFitSetDataSet (psArray *modelSet);
    34 pmSourceFitSetData *pmSourceFitSetDataGet ();
    35 void pmSourceFitSetDataClear ();
     34pmSourceFitSetData *pmSourceFitSetDataGet (void);
     35void pmSourceFitSetDataClear (void);
    3636
    3737// function used to set limits for a group of models
    … …  
    5454 */
    5555bool pmSourceFitSet(
    56     pmSource *source,                   ///< The input pmSource
    57     psArray *modelSet,                  ///< model to be fitted
    58     pmSourceFitMode mode,               ///< define parameters to be fitted
    59     psImageMaskType maskVal             ///< Vale to mask
     56    pmSource *source,                   ///< The input pmSource
     57    psArray *modelSet,                  ///< model to be fitted
     58    pmSourceFitMode mode,               ///< define parameters to be fitted
     59    psImageMaskType maskVal             ///< Vale to mask
    6060
    6161);

  • trunk/psModules/src/objects/pmSourcePlots.c

    r19849 r23487  
    139139}
    140140
    141 pmSourcePlotLayout *pmSourcePlotLayoutAlloc()
     141pmSourcePlotLayout *pmSourcePlotLayoutAlloc(void)
    142142{
    143143    pmSourcePlotLayout *layout = (pmSourcePlotLayout *)psAlloc(sizeof(pmSourcePlotLayout));

  • trunk/psModules/src/objects/pmSourcePlots.h

    r15562 r23487  
    2929// typedef bool (*pmSourcePlotFunction)(pmConfig *config, pmFPAview *view, pmSourcePlotLayout *layout);
    3030
    31 pmSourcePlotLayout *pmSourcePlotLayoutAlloc();
     31pmSourcePlotLayout *pmSourcePlotLayoutAlloc(void);
    3232bool psMemCheckSourcePlotLayout(psPtr ptr);
    3333

  • trunk/psphot/src/psphotCleanup.c

    r21341 r23487  
    1818}
    1919
    20 psExit psphotGetExitStatus () {
     20psExit psphotGetExitStatus (void) {
    2121
    2222    psErrorCode err = psErrorCodeLast ();
    2323    switch (err) {
    2424      case PS_ERR_NONE:
    25         return PS_EXIT_SUCCESS;
     25        return PS_EXIT_SUCCESS;
    2626      case PSPHOT_ERR_SYS:
    2727        return PS_EXIT_SYS_ERROR;

  • trunk/psphot/src/psphotDetect.h

    r21392 r23487  
    1919bool        psphotMosaicChip(pmConfig *config, const pmFPAview *view, char *outFile, char *inFile);
    2020void        psphotCleanup (pmConfig *config);
    21 psExit      psphotGetExitStatus ();
     21psExit      psphotGetExitStatus (void);
    2222
    2323#endif

  • trunk/psphot/src/psphotStandAlone.h

    r12805 r23487  
    1717bool            psphotMosaicChip(pmConfig *config, const pmFPAview *view, char *outFile, char *inFile);
    1818void            psphotCleanup (pmConfig *config);
    19 psExit          psphotGetExitStatus ();
     19psExit          psphotGetExitStatus (void);
    2020
    2121#endif

  • trunk/pswarp/src/pswarp.h

    r23195 r23487  
    7272} pswarpTransformTileArgs;
    7373
    74 pswarpTransformTileArgs *pswarpTransformTileArgsAlloc();
     74pswarpTransformTileArgs *pswarpTransformTileArgsAlloc(void);
    7575bool pswarpTransformTile (pswarpTransformTileArgs *args);
    7676
    … …  
    8787bool pswarpMatchRange (int *minX, int *minY, int *maxX, int *maxY, pmReadout *dest, pmReadout *src);
    8888
    89 pswarpMap *pswarpMapAlloc ();
     89pswarpMap *pswarpMapAlloc (void);
    9090pswarpMapGrid *pswarpMapGridAlloc (int Nx, int Ny);
    9191
    … …  
    111111 * define threads for this program
    112112 */
    113 bool pswarpSetThreads ();
     113bool pswarpSetThreads (void);
    114114
    115115/// Return software version

  • trunk/pswarp/src/pswarpMapGrid.c

    r21323 r23487  
    4343    // measure the map for the center of each superpixel
    4444    for (ni = 0, i = xMin; ni < nXpts; i += nXpix, ni++) {
    45         for (nj = 0, j = yMin; nj < nYpts; j += nYpix, nj++) {
    46             pswarpMapSetLocalModel (grid->maps[ni][nj], dest, src, i, j);
    47         }
     45        for (nj = 0, j = yMin; nj < nYpts; j += nYpix, nj++) {
     46            pswarpMapSetLocalModel (grid->maps[ni][nj], dest, src, i, j);
     47        }
    4848    }
    49            
     49
    5050    grid->nXpix = nXpix;
    5151    grid->nYpix = nYpix;
    … …  
    112112
    113113    for (int i = 0; i < grid->nXpts - 1; i++) {
    114         for (int j = 0; j < grid->nYpts - 1; j++) {
    115 
    116             // measure the output coordinates for the next grid position using the current grid map
    117             // compare with the coordinates measured using the next grid map
    118             pswarpMapApply (&xRaw, &yRaw, grid->maps[i][j], grid->maps[i][j]->xo + grid->nXpix, grid->maps[i][j]->yo);
    119             pswarpMapApply (&xRef, &yRef, grid->maps[i+1][j], grid->maps[i][j]->xo + grid->nXpix, grid->maps[i][j]->yo);
    120 
    121             double posError = hypot (xRaw-xRef, yRaw-yRef);
    122             maxError = PS_MAX (maxError, posError);
    123         }
    124     }   
     114        for (int j = 0; j < grid->nYpts - 1; j++) {
     115
     116            // measure the output coordinates for the next grid position using the current grid map
     117            // compare with the coordinates measured using the next grid map
     118            pswarpMapApply (&xRaw, &yRaw, grid->maps[i][j], grid->maps[i][j]->xo + grid->nXpix, grid->maps[i][j]->yo);
     119            pswarpMapApply (&xRef, &yRef, grid->maps[i+1][j], grid->maps[i][j]->xo + grid->nXpix, grid->maps[i][j]->yo);
     120
     121            double posError = hypot (xRaw-xRef, yRaw-yRef);
     122            maxError = PS_MAX (maxError, posError);
     123        }
     124    }
    125125    return maxError;
    126126}
    … …  
    176176    psPlaneTransformApply (FP, fpaDest->fromTPA, TP);
    177177    psPlaneTransformApply (V00, chipDest->fromFPA, FP);
    178    
     178
    179179    /** V(1,0) position */
    180180    offset->x = ix + 1;
    … …  
    186186    psPlaneTransformApply (FP, fpaDest->fromTPA, TP);
    187187    psPlaneTransformApply (V10, chipDest->fromFPA, FP);
    188    
     188
    189189    /** V(0,1) position */
    190190    offset->x = ix;
    … …  
    204204    map->Yy = V01->y - V00->y;
    205205    map->Yo = V00->y - map->Yx*ix - map->Yy*iy;
    206  
     206
    207207    map->xo = ix;
    208208    map->yo = iy;
    … …  
    224224}
    225225
    226 pswarpMap *pswarpMapAlloc () {
     226pswarpMap *pswarpMapAlloc(void) {
    227227
    228228  pswarpMap *map = (pswarpMap *) psAlloc (sizeof(pswarpMap));
    … …  
    238238
    239239    for (int i = 0; i < grid->nXpts; i++) {
    240         for (int j = 0; j < grid->nYpts; j++) {
    241             psFree (grid->maps[i][j]);
    242         }
    243         psFree (grid->maps[i]);
     240        for (int j = 0; j < grid->nYpts; j++) {
     241            psFree (grid->maps[i][j]);
     242        }
     243        psFree (grid->maps[i]);
    244244    }
    245245    psFree (grid->maps);
    … …  
    256256      grid->maps[i] = psAlloc (nYpts*sizeof(void *));
    257257      for (int j = 0; j < nYpts; j++) {
    258           grid->maps[i][j] = pswarpMapAlloc();
     258          grid->maps[i][j] = pswarpMapAlloc();
    259259      }
    260260  }
    … …  
    264264  grid->nXpix = 0;
    265265  grid->nYpix = 0;
    266  
     266
    267267  return grid;
    268268}

  • trunk/pswarp/src/pswarpSetThreads.c

    r21323 r23487  
    2323}
    2424
    25 bool pswarpSetThreads () {
     25bool pswarpSetThreads(void) {
    2626
    2727    psThreadTask *task = NULL;

  • trunk/pswarp/src/pswarpTransformTile.c

    r21368 r23487  
    2424}
    2525
    26 pswarpTransformTileArgs *pswarpTransformTileArgsAlloc()
     26pswarpTransformTileArgs *pswarpTransformTileArgsAlloc(void)
    2727{
    2828    pswarpTransformTileArgs *args = psAlloc(sizeof(pswarpTransformTileArgs));
Note: See TracChangeset for help on using the changeset viewer.