IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 16, 2010, 6:44:32 AM (16 years ago)
Author:
eugene
Message:

updates for large files (fseeok, sizes to off_t, etc)

Location:
branches/eam_branches/largefiles.20100314/Ohana
Files:
1 deleted
177 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/largefiles.20100314/Ohana/configure.tcsh

    r21508 r27295  
    1313set use_tcmalloc = 0
    1414set use_gnu99 = 0
     15set use_largefiles = 0
    1516
    1617set prefix  = ""
    … …  
    7475   set use_gnu99 = 1
    7576   breaksw;
     77  case --use-largefiles
     78   set use_largefiles = 1
     79   breaksw;
    7680  case --pedantic
    7781   set pedantic = 1
    … …  
    180184# use_gnu99
    181185if ($use_gnu99) set CFLAGS = "$CFLAGS -std=gnu99"
     186
     187# use_largefiles
     188# replace with `getconf LFS_CFLAGS`
     189if ($use_largefiles) set CFLAGS = "$CFLAGS -D_FILE_OFFSET_BITS=64"
    182190
    183191if (! $?CPPFLAGS) then
    … …  
    650658  -h, --help              display this help and exit
    651659  --enable-optimize       enable compiler optimization (-O2)
     660  --enable-profile        enable
    652661  --enable-memcheck       enable ohana memory tests
    653662  --pedantic              include -Wall -Werror on compilation
     663  --use-tcmalloc          use the alternate tcmalloc from Google
     664  --use-gnu99             use gnu99 flags to ensure C99 compatibility
     665  --use-largefiles        ensure large file compatibility
    654666
    655667Installation directories:

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/include/addstar.h

    r26384 r27295  
    4444
    4545typedef struct {
    46   int Nstars;
     46  unsigned int Nstars;
    4747  Stars *stars;
    4848  int Nimages;
    … …  
    151151AddstarClientOptions args         PROTO((int argc, char **argv, AddstarClientOptions options));
    152152
    153 void       AddToCalibration       PROTO((Average *average, SecFilt *secfilt, Measure *measure, Measure *new, int *next, int Nstar));
     153void       AddToCalibration       PROTO((Average *average, SecFilt *secfilt, Measure *measure, Measure *new, off_t *next, off_t Nstar));
    154154void       FindCalibration        PROTO((Image *image));
    155155FILE      *GetDB                  PROTO((int *state));
    156156void       InitCalibration        PROTO((int mode));
    157 void       SaveCalibration        PROTO((float Mo, float dMo, float Mr, float dMr, float Mi, int N));
     157void       SaveCalibration        PROTO((float Mo, float dMo, float Mr, float dMr, float Mi, off_t N));
    158158void       SetProtect             PROTO((int mode));
    159159int        SetSignals             PROTO((void));
    … …  
    165165SkyTable  *SkyTableFromTychoIndex PROTO((char *filename, int VERBOSE));
    166166void       check_permissions      PROTO((char *basefile));
    167 int        dump_rawstars          PROTO((Stars *stars, int Nstars));
     167int        dump_rawstars          PROTO((Stars *stars, unsigned int Nstars));
    168168int        edge_check             PROTO((double *x1, double *y1, double *x2, double *y2));
    169169Image     *fakeimage              PROTO((char *rootname, int *Nimage, int photcode));
    170170
    171 int        find_matches           PROTO((SkyRegion *region, Stars *stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    172 int        find_matches_closest   PROTO((SkyRegion *region, Stars *stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    173 int        find_matches_refstars  PROTO((SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    174 int        find_matches_closest_refstars  PROTO((SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    175 
    176 Stars    **find_subset            PROTO((SkyRegion *region, Stars *stars, int Nstars, int *NSTARS));
     171int        find_matches                  PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     172int        find_matches_closest          PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     173int        find_matches_refstars         PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     174int        find_matches_closest_refstars PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     175
     176Stars    **find_subset            PROTO((SkyRegion *region, Stars *stars, unsigned int Nstars, unsigned int *NSTARS));
    177177int        gcatalog               PROTO((Catalog *catalog));
    178 Stars     *get2mass               PROTO((SkyRegion *patch, int photcode, int mode, int *NSTARS));
     178Stars     *get2mass               PROTO((SkyRegion *patch, int photcode, int mode, unsigned int *NSTARS));
    179179double     get_subpix             PROTO((double x, double y));
    180180
    181 Stars     *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode, int *nstars));
    182 Stars     *getgsc                 PROTO((SkyRegion *patch, int *NSTARS));
    183 Stars     *gettycho               PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    184 Stars     *getusno                PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    185 Stars     *getusnob               PROTO((SkyRegion *catstats, int photcode, int *Nstars));
     181Stars     *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode, unsigned int *nstars));
     182Stars     *getgsc                 PROTO((SkyRegion *patch, unsigned int *NSTARS));
     183Stars     *gettycho               PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
     184Stars     *getusno                PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
     185Stars     *getusnob               PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
    186186
    187187// load text-based stars (REF only in the sense of REF photcodes)
    188 Stars     *grefstars              PROTO((char *file, int photcode, int *Nstars));
    189 
    190 Stars     *LoadStars              PROTO((char *file, int *Nstars, Image **images, int *Nimages, AddstarClientOptions *options));
     188Stars     *grefstars              PROTO((char *file, int photcode, unsigned int *Nstars));
     189
     190Stars     *LoadStars              PROTO((char *file, unsigned int *Nstars, Image **images, int *Nimages, AddstarClientOptions *options));
    191191Header   **LoadHeaders            PROTO((FILE *f, int *mode, int *Nheader));
    192 HeaderSet *MatchHeaders           PROTO((int **extsize, int *nimage, int mode, Header **headers, int Nheaders));
    193 int        LoadData               PROTO((FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int NheaderSets, AddstarClientOptions *options));
     192HeaderSet *MatchHeaders           PROTO((off_t **extsize, int *nimage, int mode, Header **headers, int Nheaders));
     193int        LoadData               PROTO((FILE *f, char *file, Image **images, int *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int NheaderSets, AddstarClientOptions *options));
    194194int        GetZeroPointExposure   PROTO((Header **headers, HeaderSet *headerSets, int Nimages));
    195195
    … …  
    199199void       lock_image_db          PROTO((FITS_DB *db, char *filename));
    200200int        main                   PROTO((int argc, char **argv));
    201 void       make_backup            PROTO((char *filename));
    202 int        match_refstars         PROTO((Stars *stars, int Nstars));
    203 void       mkcatalog              PROTO((SkyRegion *region, Catalog *catalog));
    204201double     opening_angle          PROTO((double x1, double y1, double x2, double y2, double x3, double y3));
    205202int        parse_time             PROTO((Header *header));
    206 Stars     *rd_gsc                 PROTO((char *filename, int *nstars));
     203Stars     *rd_gsc                 PROTO((char *filename, unsigned int *nstars));
    207204int        replace_match          PROTO((Average *average, Measure *measure, Stars *star));
    208205void       resort_catalog         PROTO((Catalog *catalog));
    209 Stars     *rfits                  PROTO((FILE *f, unsigned int *nstars));
    210 Stars     *rtext                  PROTO((FILE *f, unsigned int *nstars));
    211206Stars     *ReadStarsFITS          PROTO((FILE *f, Header *header, Header *in_theader, unsigned int *nstars));
    212207Stars     *ReadStarsTEXT          PROTO((FILE *f, unsigned int *nstars));
    … …  
    214209int        ReadImageHeader        PROTO((Header *header, Image *image, int photcode));
    215210Stars     *FilterStars            PROTO((Stars *instars, Image *image, unsigned int imageID));
    216 Stars     *MergeStars             PROTO((Stars *stars, int *Nstars, Stars *instars, int Ninstars));
    217 void       save_pt_catalog        PROTO((Catalog *catalog));  /*** choose new name ***/
     211Stars     *MergeStars             PROTO((Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars));
    218212double     scat_subpix            PROTO((double x, double y));
    219 time_t     short_date_to_sec      PROTO((char *date));
    220 void       sort_lists             PROTO((float *X, float *Y, int *S, int N));
    221 void       sort_stars             PROTO((Stars *stars, int N));
    222 int        str_to_radec           PROTO((double *ra, double *dec, char *str1, char *str2));
    223 void       unlock_image_db        PROTO((FITS_DB *db));
    224 void       update_coords          PROTO((Average *average, Measure *measure, int *next));
    225 void       wcatalog               PROTO((Catalog *catalog));
    226 void       free_catalog           PROTO((Catalog *catalog));
    227 void       wimage                 PROTO((FITS_DB *db, Image *image));
    228 void       create_image_db        PROTO((FITS_DB *db));
    229 void       set_db                 PROTO((FITS_DB *in));
    230 void       uppercase              PROTO((char *string));
    231 void       fsort                  PROTO((float *X, int N));
    232 void       fsort2                 PROTO((float *X, float *Y, int N));
    233 int       *init_measure_links     PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure));
    234 int       *init_missing_links     PROTO((Average *average, int Naverage, Missing *missing, int Nmissing));
    235 int        add_meas_link          PROTO((Average *average, int *next, int Nmeasure, int NMEASURE));
    236 int        add_miss_link          PROTO((Average *average, int *next, int Nmissing));
    237 int       *build_measure_links    PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure));
    238 Measure   *sort_measure           PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure, int *next));
    239 Missing   *sort_missing           PROTO((Average *average, int Naverage, Missing *missing, int Nmissing, int *next_miss));
    240 int        ImageOptions           PROTO((AddstarClientOptions *options, Image *images, int Nimages));
     213void       update_coords          PROTO((Average *average, Measure *measure, off_t *next));
     214off_t     *init_measure_links     PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
     215off_t     *init_missing_links     PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing));
     216off_t      add_meas_link          PROTO((Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE));
     217off_t      add_miss_link          PROTO((Average *average, off_t *next_miss, off_t Nmissing));
     218off_t     *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
     219Measure   *sort_measure           PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas));
     220Missing   *sort_missing           PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss));
     221int        ImageOptions           PROTO((AddstarClientOptions *options, Image *images, off_t Nimages));
    241222int        GetFileMode            PROTO((Header *header));
    242223AddstarClientOptions args_client  PROTO((int argc, char **argv, AddstarClientOptions options));
    … …  
    251232int        WaitServerSocket       PROTO((int InitSocket, SockAddress *Address, int *validIP, int Nvalid));
    252233int        GetClientSocket        PROTO((char *hostname));
    253 int        UpdateDatabase_Image   PROTO((AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, int Nstars));
    254 int        UpdateDatabase_Reflist PROTO((AddstarClientOptions *options, Stars *stars, int Nstars));
     234int        UpdateDatabase_Image   PROTO((AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, unsigned int Nstars));
     235int        UpdateDatabase_Reflist PROTO((AddstarClientOptions *options, Stars *stars, unsigned int Nstars));
    255236int        UpdateDatabase_Refcat  PROTO((AddstarClientOptions *options, SkyRegion *UserPatch, char *refcat));
    256 SkyList   *SkyListForStars        PROTO((SkyTable *table, int depth, Stars *stars, int Nstars));
     237SkyList   *SkyListForStars        PROTO((SkyTable *table, int depth, Stars *stars, unsigned int Nstars));
    257238SkyList   *SkyListExistingSubset  PROTO((SkyList *input, char *path));
    258239int        SkyListSetPath         PROTO((SkyList *list, char *path));
    … …  
    265246int        NewReflist_Thread      PROTO((int BindSocket));
    266247
    267 Stars     *Convert_SMPDATA        PROTO((FTable *table, int *nstars));
    268 Stars     *Convert_PS1_DEV_0      PROTO((FTable *table, int *nstars));
    269 Stars     *Convert_PS1_DEV_1      PROTO((FTable *table, int *nstars));
    270 Stars     *Convert_PS1_V1         PROTO((FTable *table, int *nstars));
    271 Stars     *Convert_PS1_V1_Alt     PROTO((FTable *table, int *nstars));
    272 Stars     *Convert_PS1_V2         PROTO((FTable *table, int *nstars));
     248Stars     *Convert_SMPDATA        PROTO((FTable *table, unsigned int *nstars));
     249Stars     *Convert_PS1_DEV_0      PROTO((FTable *table, unsigned int *nstars));
     250Stars     *Convert_PS1_DEV_1      PROTO((FTable *table, unsigned int *nstars));
     251Stars     *Convert_PS1_V1         PROTO((FTable *table, unsigned int *nstars));
     252Stars     *Convert_PS1_V1_Alt     PROTO((FTable *table, unsigned int *nstars));
     253Stars     *Convert_PS1_V2         PROTO((FTable *table, unsigned int *nstars));
    273254
    274255int        InitStar               PROTO((Stars *star));
    … …  
    278259int args_skycells (int argc, char **argv);
    279260int ConfigInit_skycells (int *argc, char **argv);
    280 int UpdateImageIDs (Stars *stars, int Nstars, Image *images, int Nimages);
    281 int LoadDataSDSS (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int Nimages);
     261int UpdateImageIDs (Stars *stars, unsigned int Nstars, Image *images, int Nimages);
     262int LoadDataSDSS (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int Nimages);
    282263int altaz (double *alt, double *az, double ha, double dec, double latitude);
    283264
    284 int LoadDataPMM (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars);
     265int LoadDataPMM (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, unsigned int *Nstars);
    285266PhotCode *LoadMetadataPMM (char *datafile, Image *image);
    286267time_t pmm_date_to_sec (char *date, char *time);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/FilterStars.c

    r26384 r27295  
    109109}
    110110
    111 Stars *MergeStars (Stars *stars, int *Nstars, Stars *instars, int Ninstars) {
     111Stars *MergeStars (Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars) {
    112112
    113113  int i, j;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/LoadData.c

    r26390 r27295  
    66
    77// examine the header sets and set the Image entries for the the valid images
    8 int LoadData (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int Nimages, AddstarClientOptions *options) {
     8int LoadData (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int Nimages, AddstarClientOptions *options) {
    99
    1010  char *name;
    11   int i, j, Nvalid, Nhead, Ndata, Nskip;
     11  off_t Nskip;
     12  int i, j, Nvalid, Nhead, Ndata;
    1213  uint32_t parentID = UINT32_MAX;
    1314  Stars *inStars;
    … …  
    7677      Nskip += extsize[j];
    7778    }
    78     fseek (f, Nskip, SEEK_SET);
     79    fseeko (f, Nskip, SEEK_SET);
    7980         
    8081    inStars = ReadStarsFITS (f, headers[Nhead], headers[Ndata], &images[0][Nvalid].nstar);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/LoadDataPMM.c

    r21508 r27295  
    1616# define MAG_INDEX_ASC 22
    1717
    18 int LoadDataPMM (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars) {
     18int LoadDataPMM (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, unsigned int *Nstars) {
    1919
    2020  char *name, *buffer;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/LoadDataSDSS.c

    r16967 r27295  
    44// there should only be a single data set (phu + table) in this file
    55// each SDSS data set corresponds to 5 images (ugriz)
    6 int LoadDataSDSS (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int Nimages) {
     6int LoadDataSDSS (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int Nimages) {
    77
     8  off_t Nskip;
    89  char *name;
    9   int j, Nvalid, Nhead, Ndata, Nskip;
     10  int j, Nvalid, Nhead, Ndata;
    1011  unsigned int Ninstars;
    1112  Stars *inStars;
    … …  
    3637    Nskip += extsize[j];
    3738  }
    38   fseek (f, Nskip, SEEK_SET);
     39  fseeko (f, Nskip, SEEK_SET);
    3940         
    4041  // XXX I think this is an error?  should this be &images[0][Nvalid] ??

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/LoadHeaders.c

    r16810 r27295  
    44Header **LoadHeaders (FILE *f, int *mode, int *Nheaders) {
    55
    6   int i, status, Nskip, NHEADERS;
     6  off_t Nskip;
     7  int i, status, NHEADERS;
    78  Header **headers;
    89
    … …  
    3132    // advance to the next header
    3233    Nskip = gfits_data_size (headers[i]);
    33     fseek (f, Nskip, SEEK_CUR);
     34    fseeko (f, Nskip, SEEK_CUR);
    3435    if (i == NHEADERS - 1) {
    3536      NHEADERS += 10;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/LoadStars.c

    r26286 r27295  
    11# include "addstar.h"
    22
    3 Stars *LoadStars (char *filename, int *Nstars, Image **images, int *Nimages, AddstarClientOptions *options) {
     3Stars *LoadStars (char *filename, unsigned int *Nstars, Image **images, int *Nimages, AddstarClientOptions *options) {
    44
    5   int i, Nfile, NFILE, Nheaders, NheaderSets, mode, *extsize;
     5  off_t *extsize;
     6  int i, Nfile, NFILE, Nheaders, NheaderSets, mode;
    67  char **file, line[1024];
    78  FILE *f;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/MatchHeaders.c

    r26258 r27295  
    33// XXX largely psphot specific
    44
    5 HeaderSet *MatchHeaders (int **extsize, int *nimage, int mode, Header **headers, int Nheaders) {
     5HeaderSet *MatchHeaders (off_t **extsize, int *nimage, int mode, Header **headers, int Nheaders) {
    66
    77  int i, j, Nimage, NIMAGE;
    … …  
    99  HeaderSet *headerSets;
    1010
    11   ALLOCATE (extsize[0], int, Nheaders);
     11  ALLOCATE (extsize[0], off_t, Nheaders);
    1212
    1313  Nimage = 0;
    … …  
    3434    headerSets[0].extnum_head = 0;
    3535    headerSets[0].extnum_data = 1;
    36     extsize[0][0] = headers[0][0].size;
     36    extsize[0][0] = headers[0][0].datasize;
    3737    *nimage = 1;
    3838    return headerSets;
    … …  
    4242  for (i = 0; i < Nheaders; i++) {
    4343    if (mode == SIMPLE_CMP) {
    44       extsize[0][i] = headers[i][0].size;
     44      extsize[0][i] = headers[i][0].datasize;
    4545    } else {
    46       extsize[0][i] = headers[i][0].size + gfits_data_size (headers[i]);
     46      extsize[0][i] = headers[i][0].datasize + gfits_data_size (headers[i]);
    4747    }
    4848
    … …  
    9292  // extension matched to the header in the PHU
    9393  if (Nimage == 0) {
    94     extsize[0][0] = headers[0][0].size + gfits_data_size (headers[0]);
    95     extsize[0][1] = headers[1][0].size + gfits_data_size (headers[1]);
     94    extsize[0][0] = headers[0][0].datasize + gfits_data_size (headers[0]);
     95    extsize[0][1] = headers[1][0].datasize + gfits_data_size (headers[1]);
    9696    gfits_scan (headers[1], ExtnameKeyword, "%s", 1, extname);
    9797    if (!strcmp (extname, "SMPFILE")) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/ReadStarsFITS.c

    r24400 r27295  
    55Stars *ReadStarsFITS (FILE *f, Header *header, Header *in_theader, unsigned int *nstars) {
    66
    7   int Nskip, Nstars;
     7  off_t Nskip;
     8  unsigned int Nstars;
    89  char type[80];
    910  Header theader;
    … …  
    1617  } else {
    1718    table.header = in_theader;
    18     Nskip = in_theader[0].size;
    19     fseek (f, Nskip, SEEK_CUR);
     19    Nskip = in_theader[0].datasize;
     20    fseeko (f, Nskip, SEEK_CUR);
    2021  }
    2122
    … …  
    5758}
    5859
    59 Stars *Convert_SMPDATA (FTable *table, int *nstars) {
    60 
    61   int i, Nstars, swapped;
     60Stars *Convert_SMPDATA (FTable *table, unsigned int *nstars) {
     61
     62  unsigned int i, Nstars;
     63  char swapped;
    6264  double ZeroPt;
    6365  Stars *stars = NULL;
    … …  
    9698}
    9799
    98 Stars *Convert_PS1_DEV_0 (FTable *table, int *nstars) {
    99 
    100   int i, Nstars;
     100Stars *Convert_PS1_DEV_0 (FTable *table, unsigned int *nstars) {
     101
     102  unsigned int i, Nstars;
    101103  double ZeroPt;
    102104  Stars *stars;
    … …  
    140142// XXX I need to make the IPP I/O functions and these functions
    141143// consistent wrt ZERO_POINT....
    142 Stars *Convert_PS1_DEV_1 (FTable *table, int *nstars) {
    143 
    144   int i, Nstars;
     144Stars *Convert_PS1_DEV_1 (FTable *table, unsigned int *nstars) {
     145
     146  unsigned int i, Nstars;
    145147  double ZeroPt;
    146148  Stars *stars;
    … …  
    185187}
    186188
    187 Stars *Convert_PS1_V1 (FTable *table, int *nstars) {
    188 
    189   int i, Nstars;
     189Stars *Convert_PS1_V1 (FTable *table, unsigned int *nstars) {
     190
     191  unsigned int i, Nstars;
    190192  double ZeroPt;
    191193  Stars *stars;
    … …  
    261263}
    262264
    263 Stars *Convert_PS1_V1_Alt (FTable *table, int *nstars) {
    264 
    265   int i, Nstars;
     265Stars *Convert_PS1_V1_Alt (FTable *table, unsigned int *nstars) {
     266
     267  unsigned int i, Nstars;
    266268  double ZeroPt;
    267269  Stars *stars;
    … …  
    332334}
    333335
    334 Stars *Convert_PS1_V2 (FTable *table, int *nstars) {
    335 
    336   int i, Nstars;
     336Stars *Convert_PS1_V2 (FTable *table, unsigned int *nstars) {
     337
     338  unsigned int i, Nstars;
    337339  double ZeroPt;
    338340  Stars *stars;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/ReadStarsSDSS.c

    r21508 r27295  
    3333Stars *ReadStarsSDSS (FILE *f, char *name, Header *header, Header *in_theader, Image *images, int *nimages, unsigned int *nstars) {
    3434
    35   int i, j, N, Nskip, Nstars, camcol;
     35  off_t Nskip;
     36  int i, j, N, Nstars, camcol;
    3637  char type[80];
    3738  Header theader;
    … …  
    5051  } else {
    5152    table.header = in_theader;
    52     Nskip = in_theader[0].size;
    53     fseek (f, Nskip, SEEK_CUR);
     53    Nskip = in_theader[0].datasize;
     54    fseeko (f, Nskip, SEEK_CUR);
    5455  }
    5556

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/SkyListForStars.c

    r21508 r27295  
    1313}
    1414
    15 SkyList *SkyListForStars (SkyTable *table, int depth, Stars *stars, int Nstars) {
     15SkyList *SkyListForStars (SkyTable *table, int depth, Stars *stars, unsigned int Nstars) {
    1616 
    1717  int i, j, Nr, NR;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/SkyTableFromTychoIndex.c

    r15036 r27295  
    147147    skytable[0].filename[i] = NULL;
    148148  }
    149   if (VERBOSE) fprintf (stderr, "loaded %d tables from tycho index\n", skytable[0].Nregions);
     149  if (VERBOSE) fprintf (stderr, "loaded %lld tables from tycho index\n", (long long) skytable[0].Nregions);
    150150
    151151  return (skytable);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/UpdateDatabase_Image.c

    r15743 r27295  
    11# include "addstar.h"
    22
    3 int UpdateDatabase_Image (AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, int Nstars) {
     3int UpdateDatabase_Image (AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, unsigned int Nstars) {
    44
    55  int i, status;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/UpdateDatabase_Reflist.c

    r15743 r27295  
    11# include "addstar.h"
    22
    3 int UpdateDatabase_Reflist (AddstarClientOptions *options, Stars *stars, int Nstars) {
     3int UpdateDatabase_Reflist (AddstarClientOptions *options, Stars *stars, unsigned int Nstars) {
    44
    55  int i, Nsubset;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/UpdateImageIDs.c

    r26390 r27295  
    11# include "addstar.h"
    22
    3 int UpdateImageIDs (Stars *stars, int Nstars, Image *images, int Nimages) {
     3int UpdateImageIDs (Stars *stars, unsigned int Nstars, Image *images, int Nimages) {
    44
    55  int i, status, isEmpty;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/addstar.c

    r26280 r27295  
    11# include "addstar.h"
    22
     3// LARGEFILES: this program currently limits Nstars (input file) to < 2^31
    34int main (int argc, char **argv) {
    45
     6  unsigned int Nstars, Nsubset;
    57  int Nmatch, status, loadObjects;
    6   int i, Nstars, Nimages, Nsubset;
    7   unsigned long long Naverage, Nmeasure;
     8  int i, Nimages;
     9  off_t Naverage, Nmeasure;
    810  Stars *stars, **subset;
    911  Image *images;
    … …  
    4648        newlist = SkyListByImage (sky, -1, &images[i]);
    4749        SkyListMerge (&skylist, newlist);
    48         if (VERBOSE) fprintf (stderr, "added %d regions to yield %d total\n", newlist[0].Nregions, skylist[0].Nregions);
     50        if (VERBOSE) fprintf (stderr, "added %lld regions to yield %lld total\n", (long long) newlist[0].Nregions, (long long) skylist[0].Nregions);
    4951        SkyListFree (newlist);
    5052      }
    … …  
    7880    skylist = tmp;
    7981  }
    80   if (VERBOSE) fprintf (stderr, "writing to %d regions\n", skylist[0].Nregions);
     82  if (VERBOSE) fprintf (stderr, "writing to %lld regions\n", (long long) skylist[0].Nregions);
    8183
    8284  /* don't load the object tables for only_images, unless we are getting the calibration. */
    … …  
    203205  gettimeofday (&stop, NULL);
    204206  dtime = DTIME (stop, start);
    205   fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), %6lld average, %7lld measure\n", dtime, Nstars, Nmatch, Naverage, Nmeasure);
     207  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), %6lld average, %7lld measure\n", dtime, Nstars, Nmatch, (long long) Naverage, (long long) Nmeasure);
    206208
    207209  exit (0);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/build_links.c

    r26399 r27295  
    2626/* build the initial links assuming the table is sorted,
    2727   not partial, and has a correct set of average[].measureOffset,Nmeasure values */
    28 int *init_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    29 
    30   int i, j, N;
    31   int *next;
     28off_t *init_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
     29
     30  off_t i, j, N;
     31  off_t *next_meas;
    3232
    3333  N = 0;
    3434
    35   ALLOCATE (next, int, Nmeasure);
     35  ALLOCATE (next_meas, off_t, Nmeasure);
    3636  for (i = 0; i < Naverage; i++, N++) {
    3737    for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
    38       next[N] = N + 1;
     38      next_meas[N] = N + 1;
    3939      if (N >= Nmeasure) {
    4040        fprintf (stderr, "WARNING: N out of bounds (1)\n");
    4141      }
    4242    }
    43     next[N] = -1;
     43    next_meas[N] = -1;
    4444    if (N >= Nmeasure) {
    4545      fprintf (stderr, "WARNING: N out of bounds (2)\n");
    … …  
    5151    }
    5252  }
    53   return (next);
     53  return (next_meas);
    5454}
    5555
    … …  
    6161 */
    6262
    63 int *build_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    64 
    65   int i, m, k, Nm, averef;
    66   int *next;
    67 
    68   ALLOCATE (next, int, Nmeasure);
     63off_t *build_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
     64
     65  off_t i, m, k, Nm, averef;
     66  off_t *next_meas;
     67
     68  ALLOCATE (next_meas, off_t, Nmeasure);
    6969
    7070  /* reset the Nm, offset values for average */
    … …  
    7777    averef = measure[Nm].averef;
    7878    m = average[averef].measureOffset; 
    79     next[Nm] = -1;
     79    next_meas[Nm] = -1;
    8080
    8181    if (m == -1) { /* no links yet for source */
    … …  
    8585    }
    8686
    87     for (k = 0; next[m] != -1; k++) {
    88       m = next[m];
     87    for (k = 0; next_meas[m] != -1; k++) {
     88      m = next_meas[m];
    8989      if (m >= Nmeasure) {
    9090        fprintf (stderr, "WARNING: m out of bounds (1)\n");
    … …  
    9393
    9494    average[averef].Nmeasure = k + 2;
    95     next[m] = Nm;
     95    next_meas[m] = Nm;
    9696    if (m >= Nmeasure) {
    9797      fprintf (stderr, "WARNING: m out of bounds (2)\n");
    9898    }
    9999  }
    100   return (next);
     100  return (next_meas);
    101101}
    102102
    103103/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
    104 int add_meas_link (Average *average, int *next, int Nmeasure, int NMEASURE) {
    105 
    106   int k, m;
    107 
    108   /* if we have trouble, check validity of next[m] : m < Nmeasure */
     104off_t add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
     105
     106  off_t k, m;
     107
     108  /* if we have trouble, check validity of next_meas[m] : m < Nmeasure */
    109109  m = average[0].measureOffset; 
    110110
    111111  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
    112     m = next[m];
     112    m = next_meas[m];
    113113    if (m >= NMEASURE) {
    114114      fprintf (stderr, "WARNING: m out of bounds (3)\n");
    … …  
    117117
    118118  /* set up references */
    119   next[Nmeasure] = -1;
     119  next_meas[Nmeasure] = -1;
    120120  if (Nmeasure >= NMEASURE) {
    121121    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
    … …  
    125125    average[0].measureOffset = Nmeasure;
    126126  } else {
    127     next[m] = Nmeasure;
     127    next_meas[m] = Nmeasure;
    128128    if (m >= NMEASURE) {
    129129      fprintf (stderr, "WARNING: m out of bounds (4)\n");
    … …  
    137137   we must always save the missing table, if it exists */
    138138
    139 Measure *sort_measure (Average *average, int Naverage, Measure *measure, int Nmeasure, int *next) {
    140 
    141   int i, k, n, N;
     139Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
     140
     141  off_t i, k, n, N;
    142142  Measure *tmpmeasure;
    143143
    … …  
    153153      if (measure[n].averef != i) abort();
    154154      tmpmeasure[N].averef = i;
    155       n = next[n];
     155      n = next_meas[n];
    156156    }
    157157  }
    … …  
    161161
    162162/* build the initial links assuming the table is sorted */
    163 int *init_missing_links (Average *average, int Naverage, Missing *missing, int Nmissing) {
    164 
    165   int i, j, N;
    166   int *next;
     163off_t *init_missing_links (Average *average, off_t Naverage, Missing *missing, off_t Nmissing) {
     164
     165  off_t i, j, N;
     166  off_t *next_miss;
    167167
    168168  N = 0;
    169169
    170   ALLOCATE (next, int, Nmissing);
     170  ALLOCATE (next_miss, off_t, Nmissing);
    171171  for (i = 0; i < Naverage; i++) {
    172172    for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
    173       next[N] = N + 1;
     173      next_miss[N] = N + 1;
    174174    }
    175175    if (average[i].Nmissing > 0) {
    176       next[N] = -1;
     176      next_miss[N] = -1;
    177177      if (N >= Nmissing) {
    178178        fprintf (stderr, "overflow in init_missing_links");
    … …  
    183183
    184184  }
    185   return (next);
    186 }
    187 
    188 int add_miss_link (Average *average, int *next, int Nmissing) {
    189 
    190   int k, m;
     185  return (next_miss);
     186}
     187
     188off_t add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
     189
     190  off_t k, m;
    191191
    192192  /* there may be 0 Nmiss; this is not true for Nmeas */
    193193  if (average[0].Nmissing < 1) {
    194194    average[0].missingOffset = Nmissing;
    195     next[Nmissing] = -1;
     195    next_miss[Nmissing] = -1;
    196196    return (TRUE);
    197197  }
    198198
    199199  m = average[0].missingOffset; 
    200   for (k = 0; k < average[0].Nmissing - 1; k++) m = next[m];
     200  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_miss[m];
    201201  /* set up references */
    202   next[Nmissing] = -1;
    203   next[m] = Nmissing;
     202  next_miss[Nmissing] = -1;
     203  next_miss[m] = Nmissing;
    204204  return (TRUE);
    205205}
    206206
    207 Missing *sort_missing (Average *average, int Naverage, Missing *missing, int Nmissing, int *next) {
    208 
    209   int i, k, n, N;
     207Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
     208
     209  off_t i, k, n, N;
    210210  Missing *tmpmissing;
    211211
    … …  
    218218    for (k = 0; k < average[i].Nmissing; k++, N++) {
    219219      tmpmissing[N] = missing[n];
    220       n = next[n];
     220      n = next_miss[n];
    221221    }
    222222  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/calibrate.c

    r16810 r27295  
    22
    33static int InternalCal;
    4 static int Ncal, NCAL, *Nstar;
     4static int Ncal, NCAL;
     5static off_t *Nstar;
    56static float *Mobs, *dMobs, *Mref, *dMref, *Minst;
    67
    … …  
    1314  NCAL = 1000;
    1415  ALLOCATE (Mobs,  float,  NCAL);
    15   ALLOCATE (dMobs, float, NCAL);
     16  ALLOCATE (dMobs, float,  NCAL);
    1617  ALLOCATE (Mref,  float,  NCAL);
    1718  ALLOCATE (dMref, float,  NCAL);
    1819  ALLOCATE (Minst, float,  NCAL);
    19   ALLOCATE (Nstar, int, NCAL);
     20  ALLOCATE (Nstar, off_t, NCAL);
    2021}
    2122 
    22 void SaveCalibration (float Mo, float dMo, float Mr, float dMr, float Mi, int N) {
     23void SaveCalibration (float Mo, float dMo, float Mr, float dMr, float Mi, off_t N) {
    2324
    2425  Mobs[Ncal]  = Mo;
    … …  
    3738    REALLOCATE (dMref, float, NCAL);
    3839    REALLOCATE (Minst, float, NCAL);
    39     REALLOCATE (Nstar, int,  NCAL);
     40    REALLOCATE (Nstar, off_t, NCAL);
    4041  }
    4142}
    4243
    4344/* use the linked list to navigate the measures; safe for unsorted measures */
    44 void AddToCalibration (Average *average, SecFilt *secfilt, Measure *measure, Measure *new, int *next, int Nstar) {
     45void AddToCalibration (Average *average, SecFilt *secfilt, Measure *measure, Measure *new, off_t *next, off_t Nstar) {
    4546
    4647  int i, j, m, Nsec, found0, found1, found2;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/dump.c

    r21508 r27295  
    11# include "addstar.h"
    22
    3 int dump_rawstars (Stars *stars, int Nstars) {
     3int dump_rawstars (Stars *stars, unsigned int Nstars) {
    44
    5   int i;
     5  unsigned int i;
    66  FILE *f;
    77

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/find_matches.c

    r26384 r27295  
    11# include "addstar.h"
    22
    3 int find_matches (SkyRegion *region, Stars *stars, int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J, status, Nstars;
     3int find_matches (SkyRegion *region, Stars *stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
     4
     5  off_t i, j, n, N, J, status, Nstars;
    66  double RADIUS, RADIUS2;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2, *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     9  off_t *N1, *N2, *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  int Nsecfilt, Nsec;
    1212  unsigned int objID, catID;
    … …  
    2424  ALLOCATE (X1, double, NstarsIn);
    2525  ALLOCATE (Y1, double, NstarsIn);
    26   ALLOCATE (N1, int,    NstarsIn);
     26  ALLOCATE (N1, off_t,  NstarsIn);
    2727
    2828  /** allocate local arrays (catalog) **/
    … …  
    3030  ALLOCATE (X2, double, NAVE);
    3131  ALLOCATE (Y2, double, NAVE);
    32   ALLOCATE (N2, int,   NAVE);
    33   ALLOCATE (catalog[0].found, int, NAVE);
     32  ALLOCATE (N2, off_t,  NAVE);
     33  ALLOCATE (catalog[0].found, off_t, NAVE);
    3434  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    3535
    … …  
    140140      if (Nmeas >= NMEAS) {
    141141        NMEAS = Nmeas + 1000;
    142         REALLOCATE (next_meas, int, NMEAS);
     142        REALLOCATE (next_meas, off_t, NMEAS);
    143143        REALLOCATE (catalog[0].measure, Measure, NMEAS);
    144144      }
    … …  
    231231    if (Nmeas >= NMEAS) {
    232232      NMEAS = Nmeas + 1000;
    233       REALLOCATE (next_meas, int, NMEAS);
     233      REALLOCATE (next_meas, off_t, NMEAS);
    234234      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    235235    }
    … …  
    339339  catalog[0].Nmeasure = Nmeas;
    340340  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    341   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     341  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    342342
    343343  free (catalog[0].found);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/find_matches_closest.c

    r26384 r27295  
    11# include "addstar.h"
    22
    3 int find_matches_closest (SkyRegion *region, Stars *stars, int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J, Jmin, status, Nstars;
     3int find_matches_closest (SkyRegion *region, Stars *stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
     4 
     5  off_t i, j, n, N, J, Jmin, status, Nstars;
    66  double RADIUS, RADIUS2, Rmin;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2, *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     9  off_t *N1, *N2, *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  int Nsecfilt, Nsec;
    1212  unsigned int objID, catID;
    … …  
    2424  ALLOCATE (X1, double, NstarsIn);
    2525  ALLOCATE (Y1, double, NstarsIn);
    26   ALLOCATE (N1, int,    NstarsIn);
     26  ALLOCATE (N1, off_t,  NstarsIn);
    2727
    2828  /** allocate local arrays (catalog) **/
    … …  
    3030  ALLOCATE (X2, double, NAVE);
    3131  ALLOCATE (Y2, double, NAVE);
    32   ALLOCATE (N2, int,   NAVE);
    33   ALLOCATE (catalog[0].found, int, NAVE);
     32  ALLOCATE (N2, off_t,  NAVE);
     33  ALLOCATE (catalog[0].found, off_t, NAVE);
    3434  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    3535
    … …  
    155155    if (Nmeas >= NMEAS) {
    156156      NMEAS = Nmeas + 1000;
    157       REALLOCATE (next_meas, int, NMEAS);
     157      REALLOCATE (next_meas, off_t, NMEAS);
    158158      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    159159    }
    … …  
    226226    if (Nmeas >= NMEAS) {
    227227      NMEAS = Nmeas + 1000;
    228       REALLOCATE (next_meas, int, NMEAS);
     228      REALLOCATE (next_meas, off_t, NMEAS);
    229229      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    230230    }
    … …  
    335335  catalog[0].Nmeasure = Nmeas;
    336336  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    337   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     337  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    338338
    339339  free (catalog[0].found);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/find_matches_closest_refstars.c

    r26384 r27295  
    11# include "addstar.h"
    22
    3 int find_matches_closest_refstars (SkyRegion *region, Stars **stars, int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J, Jmin, status;
     3int find_matches_closest_refstars (SkyRegion *region, Stars **stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
     4
     5  off_t i, j, n, N, J, Jmin, status;
    66  double RADIUS, RADIUS2, Rmin;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2, *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nstars, Nmatch;
     9  off_t *N1, *N2, *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nstars, Nmatch;
    1111  unsigned int objID, catID;
    1212  Coords tcoords;
    … …  
    2424  ALLOCATE (X1, double, NstarsIn);
    2525  ALLOCATE (Y1, double, NstarsIn);
    26   ALLOCATE (N1, int,    NstarsIn);
     26  ALLOCATE (N1, off_t,  NstarsIn);
    2727
    2828  /** allocate local arrays (catalog) **/
    … …  
    3030  ALLOCATE (X2, double, NAVE);
    3131  ALLOCATE (Y2, double, NAVE);
    32   ALLOCATE (N2, int, NAVE);
    33   ALLOCATE (catalog[0].found, int, NAVE);
     32  ALLOCATE (N2, off_t, NAVE);
     33  ALLOCATE (catalog[0].found, off_t, NAVE);
    3434  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    3535
    … …  
    164164    if (Nmeas >= NMEAS) {
    165165      NMEAS = Nmeas + 1000;
    166       REALLOCATE (next_meas, int, NMEAS);
     166      REALLOCATE (next_meas, off_t, NMEAS);
    167167      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    168168    }
    … …  
    239239    if (Nmeas >= NMEAS - NREFSTAR_GROUP) {
    240240      NMEAS = Nmeas + 1000;
    241       REALLOCATE (next_meas, int, NMEAS);
     241      REALLOCATE (next_meas, off_t, NMEAS);
    242242      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    243243    }
    … …  
    351351  catalog[0].Nmeasure = Nmeas;
    352352  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    353   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     353  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    354354
    355355  free (catalog[0].found);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/find_matches_refstars.c

    r26400 r27295  
    11# include "addstar.h"
    22
    3 int find_matches_refstars (SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J;
     3int find_matches_refstars (SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options) {
     4
     5  off_t i, j, n, N, J;
    66  double RADIUS, RADIUS2;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2,  *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     9  off_t *N1, *N2,  *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  unsigned int objID, catID;
    1212  Coords tcoords;
    … …  
    2424  ALLOCATE (X1, double, Nstars);
    2525  ALLOCATE (Y1, double, Nstars);
    26   ALLOCATE (N1, int,   Nstars);
     26  ALLOCATE (N1, off_t,  Nstars);
    2727
    2828  /** allocate local arrays (catalog) **/
    … …  
    3131  ALLOCATE (X2, double, NAVE);
    3232  ALLOCATE (Y2, double, NAVE);
    33   ALLOCATE (N2, int, NAVE);
    34   ALLOCATE (catalog[0].found, int, NAVE);
     33  ALLOCATE (N2, off_t, NAVE);
     34  ALLOCATE (catalog[0].found, off_t, NAVE);
    3535  REALLOCATE (catalog[0].average, Average, NAVE);
    3636  REALLOCATE (catalog[0].secfilt, SecFilt, NAVE*catalog[0].Nsecfilt);
    … …  
    124124      if (Nmeas == NMEAS) {
    125125        NMEAS = Nmeas + 1000;
    126         REALLOCATE (next_meas, int, NMEAS);
     126        REALLOCATE (next_meas, off_t, NMEAS);
    127127        REALLOCATE (catalog[0].measure, Measure, NMEAS);
    128128      }
    … …  
    209209    if (Nmeas >= NMEAS - NREFSTAR_GROUP) {
    210210      NMEAS = Nmeas + 1000;
    211       REALLOCATE (next_meas, int, NMEAS);
     211      REALLOCATE (next_meas, off_t, NMEAS);
    212212      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    213213    }
    … …  
    325325  catalog[0].Nmeasure = Nmeas;
    326326  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    327   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     327  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    328328
    329329  free (catalog[0].found);

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/find_subset.c

    r21508 r27295  
    22
    33/* find stars within this region */
    4 Stars **find_subset (SkyRegion *region, Stars *stars, int Nstars, int *Nsubset) {
     4Stars **find_subset (SkyRegion *region, Stars *stars, unsigned int Nstars, unsigned int *Nsubset) {
    55
    66  int i, N, NSUBSET;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/get2mass.c

    r17439 r27295  
    22# include "2mass.h"
    33
    4 Stars *get2mass (SkyRegion *patch, int photcode, int mode, int *NSTARS) {
     4Stars *get2mass (SkyRegion *patch, int photcode, int mode, unsigned int *NSTARS) {
    55 
    66  char *path;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/getgsc.c

    r21508 r27295  
    77static SkyTable *sky = NULL;
    88
    9 Stars *getgsc (SkyRegion *patch, int *NSTARS) {
     9Stars *getgsc (SkyRegion *patch, unsigned int *NSTARS) {
    1010 
    1111  int i, Ngsc, Nstars;
    … …  
    4545} 
    4646
    47 Stars *rd_gsc (char *filename, int *nstars) {
     47Stars *rd_gsc (char *filename, unsigned int *nstars) {
    4848 
    4949  int i, NSTARS, Nstars, Nbytes, nbytes, Nline, Nbyte;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/gettycho.c

    r21508 r27295  
    66static SkyTable *tychoTable = NULL;
    77
    8 Stars *gettycho (SkyRegion *catstats, int photcode, int *nstars) {
     8Stars *gettycho (SkyRegion *catstats, int photcode, unsigned int *nstars) {
    99
    1010  int i, j, nitems;
    … …  
    1313  FILE *f;
    1414  int NTYCHO, Ntycho;
    15   int firstRow, firstByte;
     15  off_t firstRow, firstByte;
    1616  short int TYCHO_B, TYCHO_V;
    1717  e_time TychoEpoch;
    … …  
    6060                          region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
    6161
    62     firstRow  = atoi (region[0].name);
     62    firstRow  = strtol (region[0].name, NULL, 0);
    6363    firstByte = firstRow * NBYTE;
    64     fseek (f, firstByte, SEEK_SET);
     64    fseeko (f, firstByte, SEEK_SET);
    6565
    6666    while (1) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/getusno.c

    r21508 r27295  
    44# define NELEM  3
    55
    6 Stars *getusno (SkyRegion *catstats, int photcode, int *nstars) {
     6Stars *getusno (SkyRegion *catstats, int photcode, unsigned int *nstars) {
    77
    8   long int offset;
     8  off_t offset;
    99  int i, bin, first, last, nitems, Nitems, Nbins, Nstars;
    1010  float hours[100];
    … …  
    8484    /* advance file pointer to first slice */
    8585    offset = NELEM*NBYTE*(start[first] - 1);
    86     fseek (f, offset, SEEK_SET);
     86    fseeko (f, offset, SEEK_SET);
    8787
    8888    /* sum the number of stars in data segment of interest */

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/getusnob.c

    r26280 r27295  
    33# define NELEM  20
    44
    5 Stars *getusnob (SkyRegion *catstats, int photcode, int *nstars) {
     5Stars *getusnob (SkyRegion *catstats, int photcode, unsigned int *nstars) {
    66
    7   long int offset;
     7  off_t offset;
    88  int i, bin, first, last, nitems, Nitems, Nbins, Nitemsum;
    99  float hours[100];
    … …  
    9393    /* advance file pointer to first slice */
    9494    offset = NELEM*NBYTE*(start[first] - 1);
    95     fseek (f, offset, SEEK_SET);
     95    fseeko (f, offset, SEEK_SET);
    9696
    9797    /* sum the number of stars in data segment of interest */

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/greference.c

    r21508 r27295  
    33# define LOAD_DR2    1
    44
    5 Stars *greference (char *Refcat, SkyRegion *region, int photcode, int *nstars) {
     5Stars *greference (char *Refcat, SkyRegion *region, int photcode, unsigned int *nstars) {
    66
    77  int Nstars;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/grefstars.c

    r21508 r27295  
    22
    33/* read ASCII file with ref star data */
    4 Stars *grefstars (char *file, int photcode, int *Nstars) {
     4Stars *grefstars (char *file, int photcode, unsigned int *Nstars) {
    55
    66  FILE *f;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/gztest.c

    r3376 r27295  
    55main (int argc, char **argv) {
    66
    7   int N, Nread, Nseek, Nback;
     7  off_t Nseek, Nback;
     8  int N, Nread;
    89  char *filename, *buffer;
    910  gzFile gf;
    … …  
    6667
    6768    gettimeofday (&start, NULL);
    68     N = fseek (f, Nseek, SEEK_SET);
     69    N = fseeko (f, Nseek, SEEK_SET);
    6970    gettimeofday (&stop, NULL);
    7071    if (N) {
    … …  
    8485
    8586    gettimeofday (&start, NULL);
    86     N = fseek (f, Nback, SEEK_CUR);
     87    N = fseeko (f, Nback, SEEK_CUR);
    8788    gettimeofday (&stop, NULL);
    8889    if (N) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/resort_catalog.c

    r7039 r27295  
    33void resort_catalog (Catalog *catalog) {
    44
    5   int *next_meas;
    6   int Naves, Nmeas;
     5  off_t *next_meas;
     6  off_t Naves, Nmeas;
    77  double dtime;
    88  struct timeval start, stop;
    … …  
    2424  gettimeofday (&stop, NULL);
    2525  dtime = DTIME (stop, start);
    26   fprintf (stderr, "  match time %9.4f sec for %7d measures, %6d average\n", dtime, Nmeas, Naves);
     26  fprintf (stderr, "  match time %9.4f sec for %7lld measures, %6lld average\n", dtime, (long long) Nmeas, (long long) Naves);
    2727
    2828  return;

  • branches/eam_branches/largefiles.20100314/Ohana/src/addstar/src/update_coords.c

    r16810 r27295  
    22
    33/* find the average and scatter for R and D - no outlier rejection */
    4 void update_coords (Average *average, Measure *measure, int *next) {
     4void update_coords (Average *average, Measure *measure, off_t *next) {
    55
    6   int i, m, Npt;
     6  off_t i, m, Npt;
    77  double R, D, r, d;
    88  double r2, d2, dR2, dD2;

  • branches/eam_branches/largefiles.20100314/Ohana/src/delstar/src/gimages.c

    r20184 r27295  
    2525    Shutdown ("ERROR: can't find data file %s", filename);
    2626  }
    27   fseek (f, header.size, SEEK_SET);
     27  fseeko (f, header.datasize, SEEK_SET);
    2828
    2929  /* add file name to image structure */

  • branches/eam_branches/largefiles.20100314/Ohana/src/dvomerge/src/merge_catalogs.c

    r24745 r27295  
    55int merge_catalogs_new (Catalog *output, Catalog *input) {
    66 
    7   int i, j, offset;
    8   int NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
     7  off_t i, j, offset;
     8  off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
    99
    1010  Naverage = output[0].Naverage;

  • branches/eam_branches/largefiles.20100314/Ohana/src/dvomerge/src/merge_catalogs_new.c

    r24745 r27295  
    99int merge_catalogs_new (SkyRegion *region, Catalog *output, Catalog *input) {
    1010 
    11   int i, j, offset;
    12   int NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
     11  off_t i, j, offset;
     12  off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
    1313
    1414  Naverage = output[0].Naverage;

  • branches/eam_branches/largefiles.20100314/Ohana/src/dvomerge/src/merge_catalogs_old.c

    r24750 r27295  
    99int merge_catalogs_old (SkyRegion *region, Catalog *output, Catalog *input, double RADIUS) {
    1010
    11   int i, j, n, N, Nin, offset, J, Jmin, status, Nstars;
     11  off_t i, j, n, N, Nin, offset, J, Jmin, status, Nstars;
    1212  double RADIUS2, Rmin, Rin, Din;
    1313  double *X1, *Y1, *X2, *Y2;
    1414  double dX, dY, dR;
    15   int *N1, *N2,  *next_meas;
    16   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     15  off_t *N1, *N2,  *next_meas;
     16  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1717  int Nsecfilt;
    1818  unsigned int objID, catID;
    … …  
    2424  ALLOCATE (X1, double, input[0].Naverage);
    2525  ALLOCATE (Y1, double, input[0].Naverage);
    26   ALLOCATE (N1, int,    input[0].Naverage);
    27   ALLOCATE (input[0].found, int, input[0].Naverage);
     26  ALLOCATE (N1, off_t,  input[0].Naverage);
     27  ALLOCATE (input[0].found, off_t, input[0].Naverage);
    2828
    2929  /** allocate local arrays (catalog) **/
    … …  
    3131  ALLOCATE (X2, double, NAVE);
    3232  ALLOCATE (Y2, double, NAVE);
    33   ALLOCATE (N2, int,    NAVE);
    34   ALLOCATE (output[0].found, int, NAVE);
     33  ALLOCATE (N2, off_t,    NAVE);
     34  ALLOCATE (output[0].found, off_t, NAVE);
    3535  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    3636
    … …  
    157157    if (Nmeas + input[0].average[N].Nmeasure >= NMEAS) {
    158158      NMEAS = Nmeas + input[0].average[N].Nmeasure + 1000;
    159       REALLOCATE (next_meas, int, NMEAS);
     159      REALLOCATE (next_meas, off_t, NMEAS);
    160160      REALLOCATE (output[0].measure, Measure, NMEAS);
    161161    }
    … …  
    220220    if (Nmeas + input[0].average[N].Nmeasure >= NMEAS) {
    221221      NMEAS = Nmeas + input[0].average[N].Nmeasure + 1000;
    222       REALLOCATE (next_meas, int, NMEAS);
     222      REALLOCATE (next_meas, off_t, NMEAS);
    223223      REALLOCATE (output[0].measure, Measure, NMEAS);
    224224    }

  • branches/eam_branches/largefiles.20100314/Ohana/src/elixir/src/DumpStatus.c

    r10336 r27295  
    1818    f = fsetlockfile (filename, 0.1, LCK_XCLD, &state);
    1919    if (f == NULL) return (2);
    20     fseek (f, 0, SEEK_END);
     20    fseeko (f, 0, SEEK_END);
    2121  } 
    2222 

  • branches/eam_branches/largefiles.20100314/Ohana/src/elixir/src/MachineOps.c

    r10336 r27295  
    454454    f = fsetlockfile (filename, 0.1, LCK_XCLD, &state);
    455455    if (f == NULL) return (2);
    456     fseek (f, 0, SEEK_END);
     456    fseeko (f, 0, SEEK_END);
    457457  } 
    458458

  • branches/eam_branches/largefiles.20100314/Ohana/src/elixir/src/MsgOps.c

    r10336 r27295  
    9999
    100100  /* write message to end of file */
    101   fseek (f, 0, SEEK_END);
     101  fseeko (f, 0, SEEK_END);
    102102  fprintf (f, "%s\n", message);
    103103

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/aregion.c

    r19823 r27295  
    7979    NLINES += NDecLines[i];
    8080  }
    81   fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     81  fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    8282     
    8383  done = FALSE;

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/find_bright_stars.c

    r16040 r27295  
    66{
    77
    8   int i, j, n, m, first_j, Nave, Ngsc;
     8  int j, n, m, first_j, Ngsc;
    99  Catalog GSCdata;
    1010  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    1111  Coords *tcoords;
    1212  double *X1, *Y1, *X2, *Y2;
    13   int *N1, *N2;
     13  off_t i, Nave;
     14  off_t *N1, *N2;
    1415  char *mark;
    1516  double dX, dY, dR, MaxDist, MaxDist1, MaxRadius, radius, radius2;
    … …  
    2728  ALLOCATE (X1, double, Ngsc);
    2829  ALLOCATE (Y1, double, Ngsc);
    29   ALLOCATE (N1, int, Ngsc);
     30  ALLOCATE (N1, off_t, Ngsc);
    3031  ALLOCATE (mark, char, Nave);
    3132  bzero (mark, Nave);

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/find_images.c

    r7080 r27295  
    7373    exit (0);
    7474  }
    75   fseek (f, header.size, SEEK_SET);
     75  fseeko (f, header.datasize, SEEK_SET);
    7676
    7777  /* set up buffers for images, temporary storage */

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/find_matches.c

    r16040 r27295  
    1111  double *X1, *Y1, *X2, *Y2;
    1212  double dX, dY, dR;
    13   int *N1, *N2;
     13  off_t *N1, *N2;
    1414  int Nstar, Nghost, Ng;
    1515  unsigned int flags;
    … …  
    2929  ALLOCATE (X1, double, Nghost);
    3030  ALLOCATE (Y1, double, Nghost);
    31   ALLOCATE (N1, int, Nghost);
     31  ALLOCATE (N1, off_t, Nghost);
    3232
    3333  /* project ghosts to the frame of the catalog */

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/gcatalog.c

    r7080 r27295  
    2828    exit (0);
    2929  }
    30   fseek (f, catalog[0].header.size, SEEK_SET);
     30  fseeko (f, catalog[0].header.datasize, SEEK_SET);
    3131
    3232  /** find number of stars, measurements **/

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/gcatstats.c

    r16040 r27295  
    66{
    77
    8   int i;
     8  off_t i;
    99  double RaCenter, DecCenter;
    1010  double MinRA, MaxRA, MinDEC, MaxDEC;
    1111  double *X1, *Y1;
    12   int *N1;
    1312  Coords tcoords;
    1413 

  • branches/eam_branches/largefiles.20100314/Ohana/src/fixcat/src/wcatalog.c

    r7080 r27295  
    11# include "markstar.h"
    22
    3 wcatalog (catname, catalog)
    4 char *catname;
    5 Catalog catalog[];
    6 {
     3int wcatalog (char *catname, catalog *catalog) {
    74 
    8   int i, Nitems, nitems, status, mode;
     5  int status, mode;
     6  off_t i, Nitems, nitems;
    97  char filename[128], line[256];
    108  FILE *f;
    … …  
    3634  chmod (filename, mode);
    3735 
    38   gfits_modify (&catalog[0].header, "NSTARS", "%d", 1, catalog[0].Naverage);
    39   gfits_modify (&catalog[0].header, "NMEAS", "%d", 1, catalog[0].Nmeasure);
    40   gfits_modify (&catalog[0].header, "NMISS", "%d", 1, catalog[0].Nmissing);
     36  gfits_modify (&catalog[0].header, "NSTARS", "%lld", 1, catalog[0].Naverage);
     37  gfits_modify (&catalog[0].header, "NMEAS",  "%lld", 1, catalog[0].Nmeasure);
     38  gfits_modify (&catalog[0].header, "NMISS",  "%lld", 1, catalog[0].Nmissing);
    4139
    4240  gfits_modify (&catalog[0].header, "MARKSTAR", "%t", 1, TRUE);
    4341
    44   nitems = Fwrite (catalog[0].header.buffer, 1, catalog[0].header.size, f, "char");
     42  nitems = Fwrite (catalog[0].header.buffer, 1, catalog[0].header.datasize, f, "char");
    4543  if (nitems != catalog[0].header.size) {
    4644    fprintf (stderr, "ERROR: failed to write header\n");
    … …  
    7169  fclose (f);
    7270
     71  return TRUE;
    7372}
    74 

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro/src/getusno.c

    r2435 r27295  
    1111USNOdata *getusno (USNOstats *usnostats, CatStats *catstats, int *Nusno) {
    1212
    13   long int offset;
     13  off_t offset;
    1414  int i, bin, first, last, nitems, Nitems, Nbins;
    1515  float hours[100];
    … …  
    9191    /* advance file pointer to first slice */
    9292    offset = 3*sizeof(int)*(start[first] - 1);
    93     fseek (f, offset, SEEK_SET);
     93    fseeko (f, offset, SEEK_SET);
    9494    /* on each loop, load data from an RA slice of the catalog */
    9595    for (bin = first; bin < last; bin++) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro/src/gfit.c

    r19823 r27295  
    88 
    99  int i, j, iteration, Niter, last, halt, first_j, *Nextra, extras;
    10   int *tmpN1, *tmpN2;
     10  off_t *tmpN1, *tmpN2;
    1111  double X_O, X_X, X_Y, dX;
    1212  double Y_O, Y_X, Y_Y, dY;

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro/src/gfitpoly.c

    r19823 r27295  
    55  int i, j, m, n, M, N;
    66  int first_j, last;
    7   int *tmpN1, *tmpN2;
     7  off_t *tmpN1, *tmpN2;
    88  int NORDER, NTERM, NPARS, NPOWR;
    99  double **sum, **xsum, **ysum;

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro/src/gheader.c

    r12332 r27295  
    55  Header header;
    66  FILE *f, *g;
    7   int i, oldsize, nbytes, status;
     7  off_t i, oldsize, nbytes, status;
    88  char line[1024];
    99
    … …  
    1212    exit(0);
    1313  }
    14   oldsize = header.size;
     14  oldsize = header.datasize;
    1515
    1616  /* validating the photcode name should be the job of DVO/addstar */
    … …  
    8080
    8181skipstuff:
    82   if (header.size > oldsize) {
     82  if (header.datasize > oldsize) {
    8383    if (VERBOSE) fprintf (stderr, "header expanded, creating new copy\n");
    8484    sprintf (line, "mv %s %s~", file, file);
    … …  
    9999      exit(0);
    100100    }
    101     nbytes = fwrite (header.buffer, 1, header.size, g);
    102     fseek (f, oldsize, SEEK_SET);
    103     for (i = 0; (nbytes = fread (header.buffer, 1, header.size, f)) > 0; i++) {
     101    nbytes = fwrite (header.buffer, 1, header.datasize, g);
     102    fseeko (f, oldsize, SEEK_SET);
     103    for (i = 0; (nbytes = fread (header.buffer, 1, header.datasize, f)) > 0; i++) {
    104104      if (nbytes != fwrite (header.buffer, 1, nbytes, g)) {
    105105        fprintf (stderr, "ERROR: failure writing output data file\n");
    … …  
    116116    }
    117117   
    118     fseek (f, 0, SEEK_SET);
    119     nbytes = fwrite (header.buffer, 1, header.size, f);
     118    fseeko (f, 0, SEEK_SET);
     119    nbytes = fwrite (header.buffer, 1, header.datasize, f);
    120120   
    121121    fclose (f);

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro/src/gstars.c

    r19823 r27295  
    162162    exit(0);
    163163  }
    164   fseek (f, header.size, SEEK_SET);
     164  fseeko (f, header.datasize, SEEK_SET);
    165165
    166166  N = nstar = 0;

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro2/src/getusno.c

    r8496 r27295  
    1111int getusno (CatStats *catstats, RefCatalog *Ref) {
    1212
    13   long int offset;
     13  off_t offset;
    1414  int i, bin, first, last, nitems, Nitems, Nbins;
    1515  float hours[100];
    … …  
    8686    /* advance file pointer to first slice */
    8787    offset = 3*sizeof(int)*(start[first] - 1);
    88     fseek (f, offset, SEEK_SET);
     88    fseeko (f, offset, SEEK_SET);
    8989    /* on each loop, load data from an RA slice of the catalog */
    9090    for (bin = first; bin < last; bin++) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro2/src/getusnob.c

    r8513 r27295  
    55int getusnob (CatStats *catstats, RefCatalog *Ref, double epoch) {
    66
    7   long int offset;
     7  off_t offset;
    88  int i, bin, first, last, nitems, Nitems, Nbins;
    99  float hours[100];
    … …  
    7676    /* advance file pointer to first slice */
    7777    offset = NELEM*NBYTE*(start[first] - 1);
    78     fseek (f, offset, SEEK_SET);
     78    fseeko (f, offset, SEEK_SET);
    7979
    8080    /* sum the number of stars in data segment of interest */

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro2/src/gheader2.c

    r8300 r27295  
    66  Header header;
    77  FILE *f, *g;
    8   int i, oldsize, nbytes, status;
     8  off_t i, oldsize, nbytes, status;
    99  char line[1024];
    1010
    … …  
    1313    exit(0);
    1414  }
    15   oldsize = header.size;
     15  oldsize = header.datasize;
    1616
    1717  /* check for insufficient number of stars */
    … …  
    5959
    6060skipstuff:
    61   if (header.size > oldsize) {
     61  if (header.datasize > oldsize) {
    6262    if (VERBOSE) fprintf (stderr, "header expanded, creating new copy\n");
    6363    sprintf (line, "mv %s %s~", file, file);
    … …  
    7878      exit(0);
    7979    }
    80     nbytes = fwrite (header.buffer, 1, header.size, g);
    81     fseek (f, oldsize, SEEK_SET);
    82     for (i = 0; (nbytes = fread (header.buffer, 1, header.size, f)) > 0; i++) {
     80    nbytes = fwrite (header.buffer, 1, header.datasize, g);
     81    fseeko (f, oldsize, SEEK_SET);
     82    for (i = 0; (nbytes = fread (header.buffer, 1, header.datasize, f)) > 0; i++) {
    8383      if (nbytes != fwrite (header.buffer, 1, nbytes, g)) {
    8484        fprintf (stderr, "ERROR: failure writing output data file\n");
    … …  
    9595    }
    9696   
    97     fseek (f, 0, SEEK_SET);
    98     nbytes = fwrite (header.buffer, 1, header.size, f);
     97    fseeko (f, 0, SEEK_SET);
     98    nbytes = fwrite (header.buffer, 1, header.datasize, f);
    9999   
    100100    fclose (f);

  • branches/eam_branches/largefiles.20100314/Ohana/src/gastro2/src/gstars2.c

    r19823 r27295  
    66  char line[80];
    77  double det;
    8   int NX, NY, Nskip, FoundAstrom, extend, naxis;
     8  off_t Nskip;
     9  int NX, NY, FoundAstrom, extend, naxis;
    910  StarData *stars;
    1011  FILE *f;
    … …  
    2122  }
    2223  /* this line should not be needed */
    23   fseek (f, Target[0].header.size, SEEK_SET);
     24  fseeko (f, Target[0].header.datasize, SEEK_SET);
    2425
    2526  NX = Target[0].header.Naxis[0];
    … …  
    128129  if ((naxis == 0) && !TEXTMODE) {
    129130    Nskip = gfits_data_size (&Target[0].header);
    130     fseek (f, Nskip, SEEK_CUR);
     131    fseeko (f, Nskip, SEEK_CUR);
    131132    stars = rfits (f, &Nstars);
    132133  } else {

  • branches/eam_branches/largefiles.20100314/Ohana/src/getstar/src/ReadImageFiles.c

    r24418 r27295  
    44Image *ReadImageFiles (char *filename, int *Nimages) {
    55
    6   int i, j, N, Nfile, Nheader, NHEADER, Nimage, NIMAGE;
     6  off_t Nskip, *extsize;
     7  int i, j, N, Nfile, Nheader, Nimage, NHEADER, NIMAGE;
    78  int Nskip, Nhead, Ndata, done, status, mode;
    89  char **file, *name;
    … …  
    1011  glob_t globList;
    1112  char **exthead, **extdata, **exttype, tmpword[80];
    12   int *extnum_head, *extnum_data, *extsize;
     13  int *extnum_head, *extnum_data;
    1314  Header *header, **headers;
    1415  Image *image;
    … …  
    8990  headers[0] = header;
    9091  Nskip = gfits_data_size (header);
    91   fseek (f, Nskip, SEEK_CUR);
     92  fseeko (f, Nskip, SEEK_CUR);
    9293
    9394  // load all headers into memory
    … …  
    118119  ALLOCATE (extnum_head, int, NIMAGE);
    119120  ALLOCATE (extnum_data, int, NIMAGE);
    120   ALLOCATE (extsize, int, Nheader);
     121  ALLOCATE (extsize, off_t, Nheader);
    121122
    122123  if (mode == MOSAIC_MEF) {
    … …  
    130131  // now examine the headers, count the table entries, find corresponding headers
    131132  for (i = 0; i < Nheader; i++) {
    132       extsize[i] = headers[i][0].size + gfits_data_size (headers[i]);
     133      extsize[i] = headers[i][0].datasize + gfits_data_size (headers[i]);
    133134      gfits_scan (headers[i], "EXTTYPE", "%s", 1, tmpword);
    134135
    … …  
    166167  // extension matched to the header in the PHU
    167168  if (Nimage == 0) {
    168       extsize[0] = headers[0][0].size + gfits_data_size (headers[0]);
    169       extsize[1] = headers[1][0].size + gfits_data_size (headers[1]);
     169      extsize[0] = headers[0][0].datasize + gfits_data_size (headers[0]);
     170      extsize[1] = headers[1][0].datasize + gfits_data_size (headers[1]);
    170171      gfits_scan (headers[1], "EXTNAME", "%s", 1, tmpword);
    171172      if (!strcmp (tmpword, "SMPFILE")) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/gophot/src/gophot.c

    r20652 r27295  
    2626  /* convert to float, set up noise array and axes */
    2727  gfits_convert_format (&header, &matrix, -32, 1.0, 0.0, 0xffff, 0);
    28   ALLOCATE (noise, float, matrix.size);
     28  ALLOCATE (noise, float, matrix.datasize);
    2929  big = (float *) matrix.buffer;
    3030  nfast = matrix.Naxis[0];

  • branches/eam_branches/largefiles.20100314/Ohana/src/imclean/src/wstars.c

    r3519 r27295  
    1414  }
    1515
    16   fwrite (header[0].buffer, 1, header[0].size, g);
     16  fwrite (header[0].buffer, 1, header[0].datasize, g);
    1717
    1818  for (i = 0; i < Nstars; i++) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/imregister/base/WriteFIFO.c

    r3648 r27295  
    1212  }
    1313
    14   fseek (f, 0, SEEK_END);
     14  fseeko (f, 0LL, SEEK_END);
    1515  fprintf (f, "%s\n", line);
    1616

  • branches/eam_branches/largefiles.20100314/Ohana/src/imregister/imphot/rtext.c

    r15487 r27295  
    44int rtext (FITS_DB *db) {
    55
    6   int Nimage, size, nimage;
     6  off_t Nimage, size, nimage;
    77  struct stat filestatus;
    88  Image *image;
    … …  
    1010  /* check that file size makes sense */
    1111  Nimage = 0;
    12   gfits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimage);
     12  gfits_scan (&db[0].header, "NIMAGES", "%lld", 1, &Nimage);
    1313  if (stat (db[0].filename, &filestatus) == -1) {
    1414    if (VERBOSE) fprintf (stderr, "ERROR: failed to get status of image catalog\n");
    1515    exit (1);
    1616  }
    17   size = Nimage*sizeof(Image) + db[0].header.size;
     17  size = Nimage*sizeof(Image) + db[0].header.datasize;
    1818  if (size != filestatus.st_size) {
    1919    int Ndata;
    2020
    21     Ndata = (filestatus.st_size - db[0].header.size) / sizeof (Image);
     21    Ndata = (filestatus.st_size - db[0].header.datasize) / sizeof (Image);
    2222    if (VERBOSE) fprintf (stderr, "ERROR: image catalog has inconsistent size\n");
    2323    if (VERBOSE) fprintf (stderr, "header: %d, data: %d\n", Nimage, Ndata);
    … …  
    4141  }
    4242  db[0].ftable.buffer = (char *) image;
    43   gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
     43  gfits_modify (&db[0].theader, "NAXIS2", "%lld", 1, Nimage);
    4444  db[0].theader.Naxis[1] = Nimage;
    45   db[0].ftable.size = gfits_data_size (&db[0].theader);
     45  db[0].ftable.datasize = gfits_data_size (&db[0].theader);
    4646 
    4747  return (TRUE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/imregister/src/imphotmerge.c

    r12332 r27295  
    88int main (int argc, char **argv) {
    99 
     10  off_t status, Nimage;
    1011  Header header, theader;
    1112  Image *image, *input;
    1213  FILE *f, *g;
    13   int i, j, status, N;
     14  int i, j, N;
    1415  char *dBFile;
    15   int Nimage, Ninput, *index, Ntimes;
     16  int Ninput, *index, Ntimes;
    1617  time_t *tstart, *tstop;
    1718  int VERBOSE, PHOTCODE, dbstate;
    … …  
    115116
    116117  /* position to begining of file to write header */
    117   fseek (f, 0, SEEK_SET);
    118   status = Fwrite (header.buffer, 1, header.size, f, "char");
    119   if (status != header.size) {
     118  fseeko (f, 0, SEEK_SET);
     119  status = Fwrite (header.buffer, 1, header.datasize, f, "char");
     120  if (status != header.datasize) {
    120121    fprintf (stderr, "ERROR: failed writing data to image header\n");
    121122    exit (0);
    … …  
    123124
    124125  /* position to end of file for new image data */
    125   fseek (f, header.size, SEEK_SET);
     126  fseeko (f, header.datasize, SEEK_SET);
    126127  status = Fwrite (image, sizeof(Image), Nimage, f, "image");
    127128  if (status != Nimage) {
    … …  
    137138}
    138139
    139 Image *LoadImageTable (FILE *f, Header *header, int *nimage) {
     140Image *LoadImageTable (FILE *f, Header *header, off_t *nimage) {
    140141
    141   int Nimage, Ndata, Nread, size;
     142  off_t Nimage, Ndata, Nread, size;
    142143  struct stat filestatus;
    143144  Image *image;
    … …  
    151152  /* check that file size makes sense */
    152153  Nimage = 0;
    153   gfits_scan (header, "NIMAGES", "%d", 1, &Nimage);
     154  gfits_scan (header, "NIMAGES", "%lld", 1, &Nimage);
    154155  if (fstat (fileno(f), &filestatus) == -1) {
    155156    fprintf (stderr, "ERROR: failed to get status of image catalog\n");
    156157    exit (1);
    157158  }
    158   size = Nimage*sizeof(Image) + header[0].size;
     159  size = Nimage*sizeof(Image) + header[0].datasize;
    159160  if (size != filestatus.st_size) {
    160161    Ndata = (filestatus.st_size - header[0].size) / sizeof (Image);

  • branches/eam_branches/largefiles.20100314/Ohana/src/kapa2/src/Image.c

    r25757 r27295  
    1111
    1212  channel->coords.Npolyterms = 0;
    13   channel->matrix.size = 0; /* a flag to show there is no data in the matrix */
     13  channel->matrix.datasize = 0; /* a flag to show there is no data in the matrix */
    1414  ALLOCATE (channel->matrix.buffer, char, 1);  /* allocate so later free will not crash! */
    1515

  • branches/eam_branches/largefiles.20100314/Ohana/src/kapa2/src/LoadPicture.c

    r26891 r27295  
    55  Header header;
    66  char *buff;
    7   int status, bytes_left;
     7  off_t status, bytes_left;
    88  Section *section;
    99  KapaImageWidget *image;
    … …  
    2424  Xoffset = 0.0;
    2525  Yoffset = 0.0;
    26   if (image[0].image[0].matrix.size) {
     26  if (image[0].image[0].matrix.datasize) {
    2727    // XXX enforce int center here?
    2828    Xoffset = image[0].picture.Xc - 0.5*image[0].image[0].matrix.Naxis[0];
    … …  
    4141
    4242  KiiScanMessage (sock, "%lf %lf %s %s",  &image[0].image[0].zero, &image[0].image[0].range, image[0].image[0].name, image[0].image[0].file);
    43   KiiScanMessage (sock, "%lf %lf %d", &image[0].image[0].min,  &image[0].image[0].max, &header.size);
     43  KiiScanMessage (sock, "%lf %lf %lld", &image[0].image[0].min,  &image[0].image[0].max, &header.datasize);
    4444  KiiScanMessage (sock, "%lf %f %f %f %f", &image[0].image[0].coords.crval1, &image[0].image[0].coords.crpix1, &image[0].image[0].coords.cdelt1, &image[0].image[0].coords.pc1_1, &image[0].image[0].coords.pc1_2);
    4545  KiiScanMessage (sock, "%lf %f %f %f %f", &image[0].image[0].coords.crval2, &image[0].image[0].coords.crpix2, &image[0].image[0].coords.cdelt2, &image[0].image[0].coords.pc2_1, &image[0].image[0].coords.pc2_2);
    … …  
    6767  status = 1;
    6868  buff = image[0].image[0].matrix.buffer;
    69   bytes_left = header.size;
    70   image[0].image[0].matrix.size = 0;
     69  bytes_left = header.datasize;
     70  image[0].image[0].matrix.datasize = 0;
    7171  while (bytes_left > 0) {
    7272    status = read (sock, buff, bytes_left);
    … …  
    7777    }
    7878    if (status != -1) { /* pipe has data */
    79       image[0].image[0].matrix.size += status;
     79      image[0].image[0].matrix.datasize += status;
    8080      bytes_left -= status;
    8181      buff = (char *)(buff + status);
    … …  
    8585  fcntl (sock, F_SETFL, !O_NONBLOCK); 
    8686
    87   if (DEBUG) fprintf (stderr, "read %d bytes\n", image[0].image[0].matrix.size);
     87  if (DEBUG) fprintf (stderr, "read %d bytes\n", image[0].image[0].matrix.datasize);
    8888  /* it it not obvious this condition should kill kii, but ... */
    89   if (image[0].image[0].matrix.size != header.size) { 
    90     fprintf (stderr, "error: expected %d bytes, but got only %d\n", header.size, image[0].image[0].matrix.size);
     89  if (image[0].image[0].matrix.datasize != header.datasize) { 
     90    fprintf (stderr, "error: expected %lld bytes, but got only %lld\n", header.datasize, image[0].image[0].matrix.datasize);
    9191    return (FALSE);
    9292  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libautocode/def/autocode.c

    r24399 r27295  
    11# include "autocode.h"
    22
    3 int gfits_convert_$STRUCT ($STRUCT *data, int size, int nitems) {
     3int gfits_convert_$STRUCT ($STRUCT *data, off_t size, off_t nitems) {
    44
    5   int i;
     5  off_t i;
    66  unsigned char *byte, tmp;
    77
    88  if (size != $SIZE) {
    9     fprintf (stderr, "WARNING: mismatch in data types $STRUCT: %d vs %d\n", size, $SIZE);
     9    fprintf (stderr, "WARNING: mismatch in data types $STRUCT: %lld vs %lld\n", (long long) size, (long long) $SIZE);
    1010    return (FALSE);
    1111  }
    … …  
    2525}
    2626
    27 $STRUCT *gfits_downsize_and_convert_$STRUCT ($STRUCT *data, int size, int nitems) {
     27$STRUCT *gfits_downsize_and_convert_$STRUCT ($STRUCT *data, off_t size, off_t nitems) {
    2828
    29   int i;
     29  off_t i;
    3030  unsigned char *byte, tmp;
    3131  $STRUCT *output;
    3232
    3333  if ($SIZE > size) {
    34     fprintf (stderr, "ERROR: uncorrectable mismatch in data types $STRUCT: %d vs %d\n", size, $SIZE);
     34    fprintf (stderr, "ERROR: uncorrectable mismatch in data types $STRUCT: %lld vs %lld\n", (long long) size, (long long) $SIZE);
    3535    exit (1);
    3636  }
    … …  
    5858/*** add test of EXTNAME and header-defined columns? ***/
    5959/* return internal structure representation */
    60 $STRUCT *gfits_table_get_$STRUCT (FTable *ftable, int *Ndata, int *swapped) {
     60$STRUCT *gfits_table_get_$STRUCT (FTable *ftable, off_t *Ndata, char *swapped) {
    6161
    6262  $STRUCT *data, *output;
    … …  
    6868      output = gfits_downsize_and_convert_$STRUCT (data, sizeof ($STRUCT), *Ndata);
    6969      free (ftable[0].buffer);
    70       ftable[0].buffer = output;
     70      ftable[0].buffer = (char *) output;
    7171      // XXX do I need to change NX?
    7272    }
    … …  
    7777}
    7878
    79 int gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, int Ndata) {
     79int gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, off_t Ndata) {
    8080
    8181  Header *header;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libautocode/def/autocode.h

    r7080 r27295  
    22/** STRUCT DEFINITION **/
    33
    4 $STRUCT *gfits_table_get_$STRUCT (FTable *table, int *Ndata, int *swapped);
    5 int      gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, int Ndata);
     4$STRUCT *gfits_table_get_$STRUCT (FTable *table, off_t *Ndata, char *swapped);
     5int      gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, off_t Ndata);
    66int      gfits_table_mkheader_$STRUCT (Header *header);
    7 int      gfits_convert_$STRUCT ($STRUCT *data, int size, int nitems);
    8 int Send_$STRUCT (int device, $STRUCT *data, int Ndata, int copy);
    9 int Recv_$STRUCT (int device, $STRUCT **data, int *Ndata);
     7int      gfits_convert_$STRUCT ($STRUCT *data, off_t size, off_t nitems);
     8int      Send_$STRUCT (int device, $STRUCT *data, int Ndata, int copy);
     9int      Recv_$STRUCT (int device, $STRUCT **data, int *Ndata);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/include/dvo.h

    r25757 r27295  
    1010
    1111/* DVO table formats */
    12 typedef enum {DVO_FORMAT_UNDEF,
    13               DVO_FORMAT_INTERNAL,
    14               DVO_FORMAT_ELIXIR,
    15               DVO_FORMAT_LONEOS,
    16               DVO_FORMAT_PANSTARRS_DEV_0,
    17               DVO_FORMAT_PANSTARRS_DEV_1,
    18               DVO_FORMAT_PS1_DEV_1,
    19               DVO_FORMAT_PS1_DEV_2,
    20               DVO_FORMAT_PS1_DEV_3,
    21               DVO_FORMAT_PS1_V1,
    22               DVO_FORMAT_PS1_REF
     12typedef enum {
     13  DVO_FORMAT_UNDEF,
     14  DVO_FORMAT_INTERNAL,
     15  DVO_FORMAT_ELIXIR,
     16  DVO_FORMAT_LONEOS,
     17  DVO_FORMAT_PANSTARRS_DEV_0,
     18  DVO_FORMAT_PANSTARRS_DEV_1,
     19  DVO_FORMAT_PS1_DEV_1,
     20  DVO_FORMAT_PS1_DEV_2,
     21  DVO_FORMAT_PS1_DEV_3,
     22  DVO_FORMAT_PS1_V1,
     23  DVO_FORMAT_PS1_REF
    2324} DVOTableFormat;
    2425
    … …  
    155156  FILE  *f;
    156157  char  *filename;
    157   int    dbstate;
    158   int    lockstate;
    159158  double timeout;
    160159  Header header;
    … …  
    163162  FTable ftable;
    164163  VTable vtable;
    165   int    mode;          /* what data storage mode is used for disk file? */
    166   int    format;        /* what data format is used for disk file? */
    167   int    virtual;       /* is table in ftable or vtable? */
    168   int    swapped;       /* is table in internal byte-order? */
     164  int    dbstate;
     165  char   lockstate;
     166  char   mode;          /* what data storage mode is used for disk file? */
     167  char   format;        /* what data format is used for disk file? */
     168  char   virtual;       /* is table in ftable or vtable? */
     169  char   swapped;       /* is table in internal byte-order? */
    169170} FITS_DB;
    170171
    … …  
    174175/* SkyRegion : better implementation than GSCRegion */
    175176typedef struct {
    176   int Nregions;
     177  off_t Nregions;
    177178  char **filename;
    178179  SkyRegion *regions;
    … …  
    180181
    181182typedef struct {
    182   int Nregions;
     183  off_t Nregions;
    183184  int ownElements;                                /* does this list own filename, regions? */
    184185  char **filename;
    … …  
    187188
    188189// special-case function:
    189 CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, int *Ndata, int *swapped);
    190 
    191 # if (0)
    192 /* structure for data on a catalog region */
    193 typedef struct {
    194   char filename[256];
    195   double DEC[2], RA[2];
    196 } GSCRegion;
    197 # endif
     190CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, off_t *Ndata, char *swapped);
    198191
    199192typedef struct {
    … …  
    219212
    220213  int Nsecfilt;  /* number of secfilt entries for each average entry */
    221   int Naverage,   Nmeasure,   Nmissing,   Nsecf_mem;  /* current number of each component in memory */
    222   int Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */
    223   int Naves_off,  Nmeas_off,  Nmiss_off,  Nsecf_off;  /* index of first loaded data value */
     214  off_t Naverage,   Nmeasure,   Nmissing,   Nsecf_mem;  /* current number of each component in memory */
     215  off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */
     216  off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nsecf_off;  /* index of first loaded data value */
     217
     218  /* the Nsecf_* values above are number of table rows (eg, Naverage*Nsecfilt) */
    224219
    225220  /* note the different counting for Nsecfilt:
    … …  
    239234
    240235  /* extra catalog information */
    241   int lockmode;
    242   int catmode;                          /* storage mode (raw, mef, split, mysql) */
    243   int catformat;                        /* storage format (elixir, panstarrs, etc) */
    244   int catflags;                         /* choices to be loaded */
    245   int sorted;                           /* is measure table average-sorted? */
     236  char lockmode;
     237  char catmode;                         /* storage mode (raw, mef, split, mysql) */
     238  char catformat;                       /* storage format (elixir, panstarrs, etc) */
     239  char catflags;                                /* choices to be loaded */
     240  char sorted;                          /* is measure table average-sorted? */
    246241 
    247242  /* pointers for data manipulation */
    248   int *found;
    249   int *image;
    250   int *mosaic;
     243  off_t *found;
     244  off_t *image;
     245  off_t *mosaic;
    251246  float *X;
    252247  float *Y;
    … …  
    261256int   gfits_db_lock                PROTO((FITS_DB *db, char *filename));
    262257int   gfits_db_load                PROTO((FITS_DB *db));
    263 int   gfits_db_load_segment        PROTO((FITS_DB *db, int start, int Nrows));
     258int   gfits_db_load_segment        PROTO((FITS_DB *db, off_t start, off_t Nrows));
    264259int   gfits_db_save                PROTO((FITS_DB *db));
    265260int   gfits_db_update              PROTO((FITS_DB *db));
    … …  
    348343char *get_mode_name (int mode);
    349344
    350 /* these functions refer to the DVO structures defined in the includes above
    351  *  they are being replaced with autocode entries (drop when totally autocoded)
    352  */
    353 
     345// read/write with byteswap for generic types
    354346int   Fread (void *ptr, int size, int nitems, FILE *f, char *type);
    355347int   Fwrite (void *ptr, int size, int nitems, FILE *f, char *type);
    356 int   ByteSwap (char *ptr, int size, int nitems, char *type);
    357 int   ConvertStruct (char *buffer, int size, int Nbytes, char *type);
    358348
    359349/** dvo_catalog APIs */
    … …  
    384374int dvo_catalog_save_split_complete (Catalog *catalog, char VERBOSE);
    385375
    386 int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, int start, int Nrows);
    387 int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, int start, int Nrows);
     376int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows);
     377int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows);
    388378
    389379/*** conversion functions / I/O conversions ***/
    390 Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary);
    391 Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format);
    392 SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format);
    393 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary);
    394 int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format);
    395 int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format);
    396 
    397 Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary);
    398 Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format);
    399 SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format);
    400 int FtableToImage (FTable *ftable, Header *theader, int *format);
    401 
    402 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary);
    403 int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format);
    404 int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format);
    405 int ImageToFtable (FTable *ftable, Header *theader, int format);
    406 int ImageToVtable (VTable *vtable, Header *theader, int format);
     380Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary);
     381Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format);
     382SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format);
     383int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary);
     384int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format);
     385int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format);
     386
     387Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary);
     388Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format);
     389SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format);
     390int      FtableToImage   (FTable *ftable, Header *theader, char *format);
     391
     392int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary);
     393int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format);
     394int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format);
     395int ImageToFtable (FTable *ftable, Header *theader, char format);
     396int ImageToVtable (VTable *vtable, Header *theader, char format);
    407397
    408398# include "loneos_defs.h"
    … …  
    425415int dvo_image_update_raw (FITS_DB *db, int VERBOSE);
    426416int dvo_image_save_raw (FITS_DB *db, int VERBOSE);
    427 int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew);
     417int dvo_image_addrows (FITS_DB *db, Image *new, off_t Nnew);
    428418void dvo_image_create (FITS_DB *db, double ZeroPoint);
    429419
    … …  
    454444
    455445/* dvo-specific sorting functions */
    456 void sortave (Average *ave, int N);
    457 void sort_image_subset (Image *image, int *subset, int N);
    458 void sort_coords_index (double *X, double *Y, int *S, int N);
    459 void sort_regions (SkyRegion *region, int N);
     446void sortave (Average *ave, off_t N);
     447void sort_image_subset (Image *image, off_t *subset, off_t N);
     448void sort_coords_index (double *X, double *Y, off_t *S, off_t N);
     449void sort_regions (SkyRegion *region, off_t N);
    460450
    461451# endif

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/include/dvo_util.h

    r26410 r27295  
    99
    1010typedef struct {
    11     char        gscfile[256];
    12     char        catdir[256];
    13     char        catmode[256];
    14     char        catformat[256];
    15     char        photcodeFile[256];
    16     char        skyTableFile[256];
    17     int         skyDepth;
    18     FITS_DB     imageDB;
    19     Image       *images;
    20     int         nImages;
    21     SkyTable    *skyTable;
     11  char        gscfile[256];
     12  char        catdir[256];
     13  char        catmode[256];
     14  char        catformat[256];
     15  char        photcodeFile[256];
     16  char        skyTableFile[256];
     17  int         skyDepth;
     18  FITS_DB     imageDB;
     19  Image       *images;
     20  off_t       nImages;
     21  SkyTable    *skyTable;
    2222#if (DVO_UTIL_READ_CAMERA_CONFIG)
    23     char        cameraConfig[256];
    24     int         *ccdNum;
    25     int         nCCD;
     23  char        cameraConfig[256];
     24  int         *ccdNum;
     25  int         nCCD;
    2626#endif
    2727} dvoConfig;
    … …  
    2929// This structure needs to be fleshed out
    3030typedef struct {
    31     int         valid;
    32     Average     ave;
    33     Measure     meas;
     31  int         valid;
     32  Average     ave;
     33  Measure     meas;
    3434#ifdef notdef
    35     int         objID;
    36     int         catID;
    37     int         detID;
    38     uint64_t    pspsObjID;
    39     uint64_t    pspsDetID;
     35  int         objID;
     36  int         catID;
     37  int         detID;
     38  uint64_t    pspsObjID;
     39  uint64_t    pspsDetID;
    4040#endif
    4141} dvoDetection;
    … …  
    7272// return a list of detectsions from a particular image id
    7373// Use dvoFree() to free the memory pointed to by results
    74 int dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID);
     74off_t dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID);
    7575
    7676// free memory returned by various dvo util functions

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/LoadPhotcodesFITS.c

    r24748 r27295  
    1111  char extname[80];
    1212
    13   int i, code, Ncode, Nsec, Nsecfilt;
     13  int i, code, Nsec, Nsecfilt;
     14  off_t Ncode;
    1415
    1516  /* XXX choose more sensible lock timeouts! */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/cmf-ps1-v1-alt.c

    r24400 r27295  
    11# include "dvo.h"
    22
    3 CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, int *Ndata, int *swapped) {
     3CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, off_t *Ndata, char *swapped) {
    44
    5   int i, nitems;
     5  off_t i, nitems;
    66  unsigned char *byte, *inbyte, *otbyte, tmp;
    77  CMF_PS1_V2 *output;
    … …  
    1313  // this function is a special case : it must have Nx = 136
    1414  if (ftable[0].header[0].Naxis[0] != 136) {
    15     fprintf (stderr, "ERROR: wrong format for CMF_PS1_V1_Alt: %d vs %d\n", ftable[0].header[0].Naxis[0], 136);
     15    fprintf (stderr, "ERROR: wrong format for CMF_PS1_V1_Alt: %lld vs %d\n", (long long) ftable[0].header[0].Naxis[0], 136);
    1616    exit (2);
    1717  }
    … …  
    8383
    8484  free (ftable[0].buffer);
    85   ftable[0].buffer = output;
     85  ftable[0].buffer = (char *) output;
    8686
    8787  // XXX other mods to make ftable consistent with CMF_PS1_V2? (Nx, EXTNAME?)

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/coordops.c

    r27025 r27295  
    307307  int i;
    308308  double Ro, Xo, Yo;
    309   double dX, dY, X, Y, Lo, Mo, dL, dM;
     309  double dX, dY, Lo, Mo, dL, dM;
    310310  double dLdX, dLdY, dMdX, dMdY, Do;
    311311

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_catalog.c

    r26398 r27295  
    141141  if (catalog[0].f == NULL)   return (DVO_CAT_OPEN_FAIL);
    142142
    143   fseek (catalog[0].f, 0, SEEK_SET);
     143  fseeko (catalog[0].f, 0, SEEK_SET);
    144144  return (DVO_CAT_OPEN_OK);
    145145}
    … …  
    376376int dvo_catalog_check (Catalog *catalog, int Nsecfilt, int extend) {
    377377
    378   int i, j, Nextra, in, out;
     378  off_t in, out, i;
     379  int j, Nextra;
    379380  SecFilt *insec, *outsec;
    380381
    … …  
    444445*/
    445446
    446 int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, int start, int Nrows) {
     447int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows) {
    447448
    448449  switch (catalog[0].catmode) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_catalog_mef.c

    r24755 r27295  
    33int dvo_catalog_load_mef (Catalog *catalog, int VERBOSE) {
    44 
    5   int Nitems, Nbytes, Nexpect, Naverage, Nmeasure, Nmissing, Nsecfilt;
     5  off_t Nitems, Nbytes, Nexpect, Naverage, Nmeasure, Nmissing, Nsecfilt;
    66  FILE *f;
    77
    … …  
    1515
    1616  /* move pointer past header -- must be already read (load_catalog) */
    17   fseek (f, catalog[0].header.size, SEEK_SET);
     17  fseeko (f, catalog[0].header.datasize, SEEK_SET);
    1818
    1919  /* matrix should be empty */
    … …  
    2323  }
    2424  /* get the components from the header */
    25   if (!gfits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &Naverage)) return (FALSE);
    26   if (!gfits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &Nmeasure)) return (FALSE);
    27   if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &Nmissing)) return (FALSE);
    28   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
     25  if (!gfits_scan (&catalog[0].header, "NSTARS",   "%lld", 1, &Naverage)) return (FALSE);
     26  if (!gfits_scan (&catalog[0].header, "NMEAS",    "%lld", 1, &Nmeasure)) return (FALSE);
     27  if (!gfits_scan (&catalog[0].header, "NMISS",    "%lld", 1, &Nmissing)) return (FALSE);
     28  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%lld", 1, &Nsecfilt)) Nsecfilt = 0;
    2929
    3030  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    7272    catalog[0].average = FtableToAverage (&ftable, &Naverage, &catalog[0].catformat, &primary);
    7373    if (Naverage != catalog[0].Naves_disk) {
    74       fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naves_disk);
     74      fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%lld vs %lld)\n", (long long) Naverage, (long long) catalog[0].Naves_disk);
    7575    }
    7676    catalog[0].Naverage = catalog[0].Naves_disk;
    … …  
    7878  } else {
    7979    Nbytes = gfits_data_size (&header);
    80     fseek (f, Nbytes, SEEK_CUR);
     80    fseeko (f, Nbytes, SEEK_CUR);
    8181    ALLOCATE (catalog[0].average, Average, 1);
    8282    catalog[0].Naverage = 0;
    … …  
    9999    catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, &catalog[0].catformat);
    100100    if (Nmeasure != catalog[0].Nmeas_disk) {
    101       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, catalog[0].Nmeas_disk);
     101      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%lld vs %lld)\n", (long long) Nmeasure, (long long) catalog[0].Nmeas_disk);
    102102    }
    103103    catalog[0].Nmeasure = catalog[0].Nmeas_disk;
    … …  
    105105  } else {
    106106    Nbytes = gfits_data_size (&header);
    107     fseek (f, Nbytes, SEEK_CUR);
     107    fseeko (f, Nbytes, SEEK_CUR);
    108108    ALLOCATE (catalog[0].measure, Measure, 1);
    109109    catalog[0].Nmeasure = 0;
    … …  
    125125    catalog[0].missing = gfits_table_get_Missing (&ftable, &catalog[0].Nmissing, NULL);
    126126    if (Nmissing != catalog[0].Nmiss_disk) {
    127       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, catalog[0].Nmiss_disk);
     127      fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%lld vs %lld)\n", (long long) Nmissing, (long long) catalog[0].Nmiss_disk);
    128128    }
    129129    catalog[0].Nmissing = catalog[0].Nmiss_disk;
    … …  
    131131  } else {
    132132    Nbytes = gfits_data_size (&header);
    133     fseek (f, Nbytes, SEEK_CUR);
     133    fseeko (f, Nbytes, SEEK_CUR);
    134134    ALLOCATE (catalog[0].missing, Missing, 1);
    135135    catalog[0].Nmissing = 0;
    … …  
    153153    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    154154    if (Nexpect != Nitems) {
    155       fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nexpect, Nitems);
     155      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%lld vs %lld)\n", (long long) Nexpect, (long long) Nitems);
    156156    }
    157157
    … …  
    159159       we need to interleave these magnitudes with the secfilt entries just loaded */
    160160    if (primary != NULL) {
    161       int Ntmpfilt, Ntotal, i, j;
     161      off_t Ntmpfilt, Ntotal, i, j;
    162162      SecFilt *tmpfilt;
    163163      tmpfilt  = catalog[0].secfilt;
    … …  
    182182    /* no real need to skip the data array here... */
    183183    Nbytes = gfits_data_size (&header);
    184     fseek (f, Nbytes, SEEK_CUR);
     184    fseeko (f, Nbytes, SEEK_CUR);
    185185    if (primary != NULL) {
    186186      free (primary);
    … …  
    200200int dvo_catalog_save_mef (Catalog *catalog, char VERBOSE) {
    201201
    202   int Nitems;
     202  off_t Nitems;
    203203  FILE *f;
    204204  Matrix matrix;
    … …  
    207207  SecFilt *primary;
    208208  SecFilt *secfilt;
    209   int i, j, Nsecfilt, Nallfilt, Ntotal;
     209  off_t i, j, Nsecfilt, Nallfilt, Ntotal;
    210210
    211211  if (catalog[0].Naverage == 0) {
    … …  
    236236
    237237  /* make sure header is consistent with data */
    238   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
    239   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure);
    240   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
    241   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     238  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, catalog[0].Naverage);
     239  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, catalog[0].Nmeasure);
     240  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, catalog[0].Nmissing);
     241  gfits_modify (&catalog[0].header, "NSECFILT", "%lld", 1, Nsecfilt);
    242242  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    243243  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    245245  f = catalog[0].f;
    246246  /* rewind file pointers and truncate */
    247   fseek (f, 0, SEEK_SET);
     247  fseeko (f, 0LL, SEEK_SET);
    248248  ftruncate (fileno (catalog[0].f), 0);
    249249  ftable.header = &header;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r24748 r27295  
    55int dvo_catalog_load_raw (Catalog *catalog, int VERBOSE) {
    66 
    7   int Nitems, nitems;
    8   int i, Nmeas, Nmiss, size;
    9   int NewMeasure, Nskip;
    10   int AverageSize, MeasureSize, MissingSize, SecFiltSize;
     7  off_t Nitems, nitems;
     8  off_t i, Nmeas, Nmiss, size;
     9  off_t NewMeasure, Nskip;
     10  off_t AverageSize, MeasureSize, MissingSize, SecFiltSize;
    1111  FILE *f;
    1212  struct stat filestatus;
    … …  
    1717
    1818  /* move pointer past header -- must be already read (load_catalog) */
    19   fseek (f, catalog[0].header.size, SEEK_SET);
     19  fseeko (f, catalog[0].header.datasize, SEEK_SET);
    2020
    2121  /* get the components from the header */
    2222  catalog[0].Naverage = catalog[0].Nmeasure = catalog[0].Nmissing = catalog[0].Nsecfilt = 0;
    23   if (!gfits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &catalog[0].Naverage)) return (FALSE);
    24   if (!gfits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &catalog[0].Nmeasure)) return (FALSE);
    25   if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &catalog[0].Nmissing)) return (FALSE);
    26   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
     23  if (!gfits_scan (&catalog[0].header, "NSTARS",   "%lld", 1, &catalog[0].Naverage)) return (FALSE);
     24  if (!gfits_scan (&catalog[0].header, "NMEAS",    "%lld", 1, &catalog[0].Nmeasure)) return (FALSE);
     25  if (!gfits_scan (&catalog[0].header, "NMISS",    "%lld", 1, &catalog[0].Nmissing)) return (FALSE);
     26  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%lld", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
    2727
    2828  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    9898
    9999  /* predicted file size - for double checking data validity */
    100   size = catalog[0].header.size;
     100  size = catalog[0].header.datasize;
    101101  size += AverageSize * catalog[0].Naverage;
    102102  size += MeasureSize * catalog[0].Nmeasure;
    … …  
    112112    if (VERBOSE) {
    113113      fprintf (stderr, "star catalog has inconsistent size\n");
    114       fprintf (stderr, "average: %d = %d bytes\n", catalog[0].Naverage, catalog[0].Naverage*AverageSize);
    115       fprintf (stderr, "measure: %d = %d bytes\n", catalog[0].Nmeasure, catalog[0].Nmeasure*MeasureSize);
    116       fprintf (stderr, "missing: %d = %d bytes\n", catalog[0].Nmissing, catalog[0].Nmissing*MissingSize);
    117       fprintf (stderr, "secfilt: %d = %d bytes\n", catalog[0].Nsecfilt, catalog[0].Nsecfilt*SecFiltSize*catalog[0].Naverage);
    118       fprintf (stderr, "expect: %d, found: %d\n", size, (int)filestatus.st_size);
     114      fprintf (stderr, "average: %lld = %lld bytes\n", (long long) catalog[0].Naverage, (long long) catalog[0].Naverage*AverageSize);
     115      fprintf (stderr, "measure: %lld = %lld bytes\n", (long long) catalog[0].Nmeasure, (long long) catalog[0].Nmeasure*MeasureSize);
     116      fprintf (stderr, "missing: %lld = %lld bytes\n", (long long) catalog[0].Nmissing, (long long) catalog[0].Nmissing*MissingSize);
     117      fprintf (stderr, "secfilt: %lld = %lld bytes\n", (long long) catalog[0].Nsecfilt, (long long) catalog[0].Nsecfilt*SecFiltSize*catalog[0].Naverage);
     118      fprintf (stderr, "expect: %lld, found: %lld\n", (long long) size, (long long) filestatus.st_size);
    119119    }
    120120    return (FALSE);
    … …  
    136136    /* skip over averages */
    137137    Nskip = catalog[0].Naverage * AverageSize;
    138     fseek (f, Nskip, SEEK_CUR);
     138    fseeko (f, Nskip, SEEK_CUR);
    139139  }   
    140140 
    … …  
    145145    /* skip over measures */
    146146    Nskip = catalog[0].Nmeasure * MeasureSize;
    147     fseek (f, Nskip, SEEK_CUR);
     147    fseeko (f, Nskip, SEEK_CUR);
    148148  }   
    149149
    … …  
    154154    nitems = fread (catalog[0].missing, MissingSize, Nitems, f);
    155155    if (nitems != Nitems) {
    156       if (VERBOSE) fprintf (stderr, "failed to read missing from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
     156      if (VERBOSE) fprintf (stderr, "failed to read missing from catalog file %s (%lld vs %lld)\n", catalog[0].filename, (long long) nitems, (long long) Nitems);
    157157      return (FALSE);
    158158    }
    … …  
    161161    /* skip over missings */
    162162    Nskip = catalog[0].Nmissing * MissingSize;
    163     fseek (f, Nskip, SEEK_CUR);
     163    fseeko (f, Nskip, SEEK_CUR);
    164164  }
    165165 
    … …  
    172172       we need to interleave these magnitudes with the secfilt entries just loaded */
    173173    if (primary != NULL) {
    174       int Ntmpfilt, Nsecfilt, Ntotal, i, j;
     174      off_t Ntmpfilt, Nsecfilt, Ntotal, i, j;
    175175      SecFilt *tmpfilt;
    176176      tmpfilt  = catalog[0].secfilt;
    … …  
    193193    /* skip over secfilts */
    194194    Nskip = catalog[0].Nsecfilt * catalog[0].Naverage * SecFiltSize;
    195     fseek (f, Nskip, SEEK_CUR);
     195    fseeko (f, Nskip, SEEK_CUR);
    196196    if (primary != NULL) free (primary);
    197197  }
    198198
    199   if (VERBOSE) fprintf (stderr, "read %d stars from catalog file %s (%d measurements, %d missing, %d secondary filters)\n",
    200                         catalog[0].Naverage, catalog[0].filename, catalog[0].Nmeasure, catalog[0].Nmissing, catalog[0].Nsecfilt);
     199  if (VERBOSE) fprintf (stderr, "read %lld stars from catalog file %s (%lld measurements, %lld missing, %lld secondary filters)\n",
     200                        (long long) catalog[0].Naverage,
     201                        catalog[0].filename,
     202                        (long long) catalog[0].Nmeasure,
     203                        (long long) catalog[0].Nmissing,
     204                        (long long) catalog[0].Nsecfilt);
    201205
    202206  /* check data integrity */
    … …  
    209213      if (VERBOSE) {
    210214        fprintf (stderr, "****** data in catalog %s is corrupt, sums don't check\n", catalog[0].filename);
    211         fprintf (stderr, "****** Nmeas: %d, %d\n", Nmeas, catalog[0].Nmeasure);
    212         fprintf (stderr, "****** Nmiss: %d, %d\n", Nmiss, catalog[0].Nmissing);
     215        fprintf (stderr, "****** Nmeas: %lld, %lld\n", (long long) Nmeas, (long long) catalog[0].Nmeasure);
     216        fprintf (stderr, "****** Nmiss: %lld, %lld\n", (long long) Nmiss, (long long) catalog[0].Nmissing);
    213217      }
    214218      return (FALSE);
    … …  
    226230int dvo_catalog_save_raw (Catalog *catalog, char VERBOSE) {
    227231
    228   int Nitems, nitems;
     232  off_t Nitems, nitems;
    229233  FILE *f;
    230234  SecFilt *primary;
    231235  SecFilt *secfilt;
    232   int i, j, Nsecfilt, Nallfilt, Ntotal;
     236  off_t i, j, Nsecfilt, Nallfilt, Ntotal;
    233237
    234238  if (catalog[0].Naverage == 0) {
    … …  
    259263
    260264  /* make sure header is consistent with data */
    261   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
    262   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure);
    263   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
    264   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, catalog[0].Nsecfilt);
     265  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, (long long) catalog[0].Naverage);
     266  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, (long long) catalog[0].Nmeasure);
     267  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, (long long) catalog[0].Nmissing);
     268  gfits_modify (&catalog[0].header, "NSECFILT", "%lld", 1, (long long) catalog[0].Nsecfilt);
    265269  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    266270
    … …  
    278282  /* rewind file pointers and truncate file */
    279283  f = catalog[0].f;
    280   fseek (f, 0, SEEK_SET);
     284  fseeko (f, 0, SEEK_SET);
    281285  ftruncate (fileno (catalog[0].f), 0);
    282286
    283287  /* write header data (use gfits_write_header?) */
    284   nitems = fwrite (catalog[0].header.buffer, 1, catalog[0].header.size, f);
    285   if (nitems != catalog[0].header.size) {
     288  nitems = fwrite (catalog[0].header.buffer, 1, catalog[0].header.datasize, f);
     289  if (nitems != catalog[0].header.datasize) {
    286290    if (VERBOSE) fprintf (stderr, "failed to write header\n");
    287291    goto failure;
    … …  
    330334   in these cases, save these values in primary; otherwise set primary to NULL */
    331335
    332 Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary) {
     336Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary) {
    333337
    334338  Average *average;
    … …  
    339343# define FORMAT_CASE(NAME,TYPE) \
    340344    case DVO_FORMAT_##NAME: { \
    341       int nitems; \
     345      off_t nitems; \
    342346      Average_##TYPE *tmpAverage; \
    343347      ALLOCATE (tmpAverage, Average_##TYPE, MAX (Naverage, 1)); \
    344348      nitems = fread (tmpAverage, sizeof(Average_##TYPE), Naverage, f); \
    345349      if (nitems != Naverage) { \
    346         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage); \
     350        fprintf (stderr, "failed to read averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage); \
    347351        return (NULL); \
    348352      } \
    … …  
    354358  switch (format) {
    355359    case DVO_FORMAT_INTERNAL: {
    356       int nitems;
     360      off_t nitems;
    357361      ALLOCATE (average, Average, MAX (Naverage, 1));
    358362      nitems = fread (average, sizeof(Average), Naverage, f);
    359363      if (nitems != Naverage) {
    360         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     364        fprintf (stderr, "failed to read averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage);
    361365        return (NULL);
    362366      }
    … …  
    384388/* accepts and converts internal average formats and outputs
    385389   raw data in the specified format */
    386 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary) {
     390int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary) {
    387391
    388392// this macro generates the case statements for each type
    389393# define FORMAT_CASE(NAME,TYPE) \
    390394    case DVO_FORMAT_##NAME: { \
    391       int nitems; \
     395      off_t nitems; \
    392396      Average_##TYPE *tmpAverage; \
    393397      tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
    … …  
    396400      free (tmpAverage); \
    397401      if (nitems != Naverage) { \
    398         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage); \
     402        fprintf (stderr, "failed to write averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage); \
    399403        return (FALSE); \
    400404      } \
    … …  
    403407  switch (format) {
    404408    case DVO_FORMAT_INTERNAL: {
    405       int nitems;
     409      off_t nitems;
    406410      gfits_convert_Average (average, sizeof(Average), Naverage);
    407411      nitems = fwrite (average, sizeof(Average), Naverage, f);
    408412      if (nitems != Naverage) {
    409         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     413        fprintf (stderr, "failed to write averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage);
    410414        return (FALSE);
    411415      }
    … …  
    432436/** Average / Raw Table conversions **/
    433437
    434 Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format) {
     438Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format) {
    435439
    436440  Measure *measure;
    … …  
    439443# define FORMAT_CASE(NAME,TYPE) \
    440444    case DVO_FORMAT_##NAME: { \
    441       int nitems; \
     445      off_t nitems; \
    442446      Measure_##TYPE *tmpMeasure; \
    443447      ALLOCATE (tmpMeasure, Measure_##TYPE, MAX (Nmeasure, 1)); \
    444448      nitems = fread (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
    445449      if (nitems != Nmeasure) { \
    446         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure); \
     450        fprintf (stderr, "failed to read measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure); \
    447451        return (NULL); \
    448452      } \
    … …  
    454458  switch (format) {
    455459    case DVO_FORMAT_INTERNAL: {
    456       int nitems;
     460      off_t nitems;
    457461      ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
    458462      nitems = fread (measure, sizeof(Measure), Nmeasure, f);
    459463      if (nitems != Nmeasure) {
    460         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     464        fprintf (stderr, "failed to read measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure);
    461465        return (NULL);
    462466      }
    … …  
    484488/* accepts and converts internal measure formats and outputs
    485489   raw data in the specified format */
    486 int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format) {
     490int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format) {
    487491
    488492// this macro generates the case statements for each type
    489493# define FORMAT_CASE(NAME,TYPE) \
    490494    case DVO_FORMAT_##NAME: { \
    491       int nitems; \
     495      off_t nitems; \
    492496      Measure_##TYPE *tmpMeasure; \
    493497      tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
    … …  
    496500      free (tmpMeasure); \
    497501      if (nitems != Nmeasure) { \
    498         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure); \
     502        fprintf (stderr, "failed to write measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure); \
    499503        return (FALSE); \
    500504      } \
    … …  
    503507  switch (format) {
    504508    case DVO_FORMAT_INTERNAL: {
    505       int nitems;
     509      off_t nitems;
    506510      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    507511      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
    508512      if (nitems != Nmeasure) {
    509         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     513        fprintf (stderr, "failed to write measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure);
    510514        return (FALSE);
    511515      }
    … …  
    532536/** SecFilt / Raw Table conversions **/
    533537
    534 SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format) {
     538SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format) {
    535539
    536540  SecFilt *secfilt;
    … …  
    539543# define FORMAT_CASE(NAME,TYPE) \
    540544    case DVO_FORMAT_##NAME: { \
    541       int nitems; \
     545      off_t nitems; \
    542546      SecFilt_##TYPE *tmpSecFilt; \
    543547      ALLOCATE (tmpSecFilt, SecFilt_##TYPE, MAX (Nsecfilt, 1)); \
    544548      nitems = fread (tmpSecFilt, sizeof(SecFilt_##TYPE), Nsecfilt, f); \
    545549      if (nitems != Nsecfilt) { \
    546         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt); \
     550        fprintf (stderr, "failed to read secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt); \
    547551        return (NULL); \
    548552      } \
    … …  
    554558  switch (format) {
    555559    case DVO_FORMAT_INTERNAL: {
    556       int nitems;
     560      off_t nitems;
    557561      ALLOCATE (secfilt, SecFilt, MAX (Nsecfilt, 1));
    558562      nitems = fread (secfilt, sizeof(SecFilt), Nsecfilt, f);
    559563      if (nitems != Nsecfilt) {
    560         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
     564        fprintf (stderr, "failed to read secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt);
    561565        return (NULL);
    562566      }
    … …  
    584588/* accepts and converts internal secfilt formats and outputs
    585589   raw data in the specified format */
    586 int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format) {
     590int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format) {
    587591
    588592// this macro generates the case statements for each type
    589593# define FORMAT_CASE(NAME,TYPE) \
    590594    case DVO_FORMAT_##NAME: { \
    591       int nitems; \
     595      off_t nitems; \
    592596      SecFilt_##TYPE *tmpSecFilt; \
    593597      tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
    … …  
    596600      free (tmpSecFilt); \
    597601      if (nitems != Nsecfilt) { \
    598         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt); \
     602        fprintf (stderr, "failed to write secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt); \
    599603        return (FALSE); \
    600604      } \
    … …  
    603607  switch (format) {
    604608    case DVO_FORMAT_INTERNAL: {
    605       int nitems;
     609      off_t nitems;
    606610      gfits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
    607611      nitems = fwrite (secfilt, sizeof(SecFilt), Nsecfilt, f);
    608612      if (nitems != Nsecfilt) {
    609         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
     613        fprintf (stderr, "failed to write secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt);
    610614        return (FALSE);
    611615      }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_catalog_split.c

    r20982 r27295  
    66// * ok
    77
    8 int dvo_catalog_secfilt_to_primary (Catalog *catalog, SecFilt **myPrimary, SecFilt **mySecfilt, int *myNsecfilt) {
    9 
    10   int i, j, Nallfilt, Nsecfilt, Ntotal;
     8int dvo_catalog_secfilt_to_primary (Catalog *catalog, SecFilt **myPrimary, SecFilt **mySecfilt, off_t *myNsecfilt) {
     9
     10  off_t i, j, Nallfilt, Nsecfilt, Ntotal;
    1111
    1212  SecFilt *primary;
    … …  
    4343}
    4444
    45 int dvo_catalog_primary_to_secfilt (Catalog *catalog, SecFilt *primary, int Naves) {
    46 
    47   int Ntmpfilt, Nsecfilt, Ntotal, i, j;
     45int dvo_catalog_primary_to_secfilt (Catalog *catalog, SecFilt *primary, off_t Naves) {
     46
     47  off_t Ntmpfilt, Nsecfilt, Ntotal, i, j;
    4848  SecFilt *tmpfilt;
    4949
    … …  
    7171}
    7272
    73 int dvo_catalog_save_subcat (Catalog *catalog, FTable *ftable, int start, int Nrows, int Ndisk, int Ntotal) {
     73int dvo_catalog_save_subcat (Catalog *catalog, FTable *ftable, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal) {
    7474
    7575  Matrix matrix;
    7676
    7777  /* rewind file pointers and truncate (file is still open) */
    78   fseek (catalog->f, 0, SEEK_SET);
     78  fseeko (catalog->f, 0LL, SEEK_SET);
    7979
    8080  // write PHU header
    … …  
    103103int dvo_catalog_open_subcat (Catalog *catalog, Catalog **Subcat, Header *header, char *name, int VERBOSE) {
    104104
    105   int Nskip, status;
     105  off_t Nskip;
     106  int status;
    106107  char *path, string[80];
    107108  Catalog *subcat;
    … …  
    145146  }
    146147  Nskip = gfits_data_size (&subcat[0].header);
    147   fseek (subcat[0].f, Nskip, SEEK_CUR);
     148  fseeko (subcat[0].f, Nskip, SEEK_CUR);
    148149
    149150  /* read Measure table header */
    … …  
    158159int dvo_catalog_load_split (Catalog *catalog, int VERBOSE) {
    159160
    160   int Nbytes, Nitems, Naverage, Nmeasure, Nmissing, Nsecfilt, status;
     161  off_t Nbytes;
     162  off_t Naverage, Nmeasure, Nmissing;
     163  off_t Nitems, Nsecfilt;
     164  int status;
    161165  Header header;
    162166  FTable ftable;
    … …  
    170174
    171175  /* get the components from the header - these duplicate information in the split files (NAXIS2) */
    172   if (!gfits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &Naverage)) return (FALSE);
    173   if (!gfits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &Nmeasure)) return (FALSE);
    174   if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &Nmissing)) return (FALSE);
    175   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
     176  if (!gfits_scan (&catalog[0].header, "NSTARS",   "%lld", 1, &Naverage)) return (FALSE);
     177  if (!gfits_scan (&catalog[0].header, "NMEAS",    "%lld", 1, &Nmeasure)) return (FALSE);
     178  if (!gfits_scan (&catalog[0].header, "NMISS",    "%lld", 1, &Nmissing)) return (FALSE);
     179  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%lld", 1, &Nsecfilt)) Nsecfilt = 0;
    176180
    177181  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    178182     it is not defined for a legacy database, we can generate them using the existing index values.
    179183     If it is missing, give a warning and recommend the user upgrade the DB */
    180   if (!gfits_scan (&catalog[0].header, "OBJID",    "%d", 1, &catalog[0].objID)) {
     184  if (!gfits_scan (&catalog[0].header, "OBJID",    "%u", 1, &catalog[0].objID)) {
    181185    if (VERBOSE) fprintf (stderr, "WARNING: OBJID is not set for this database: upgrade for full feature set\n");
    182186    catalog[0].objID = 0;
    183187  }
    184   if (!gfits_scan (&catalog[0].header, "CATID",    "%d", 1, &catalog[0].catID)) {
     188  if (!gfits_scan (&catalog[0].header, "CATID",    "%u", 1, &catalog[0].catID)) {
    185189    if (VERBOSE) fprintf (stderr, "WARNING: CATID is not set for this database: upgrade for full feature set\n");
    186190    catalog[0].catID = 0;
    … …  
    206210  if (catalog[0].catflags & LOAD_AVES) {
    207211    /* move pointer past header -- must be already read (load_catalog) */
    208     Nbytes = catalog[0].header.size + gfits_data_size (&catalog[0].header);
    209     fseek (catalog[0].f, Nbytes, SEEK_SET);
     212    Nbytes = catalog[0].header.datasize + gfits_data_size (&catalog[0].header);
     213    fseeko (catalog[0].f, Nbytes, SEEK_SET);
    210214    /* read Average table header */
    211215    if (!gfits_fread_header (catalog[0].f, &header)) {
    … …  
    223227    catalog[0].average = FtableToAverage (&ftable, &Naverage, &catalog[0].catformat, &primary);
    224228    if (Naverage != catalog[0].Naves_disk) {
    225       fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naves_disk);
     229      fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%lld vs %lld)\n", (long long) Naverage, (long long) catalog[0].Naves_disk);
    226230    }
    227231    gfits_free_header (&header);
    … …  
    252256    catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
    253257    if (Nmeasure != catalog[0].Nmeas_disk) {
    254       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, catalog[0].Nmeas_disk);
     258      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%lld vs %lld)\n", (long long) Nmeasure, (long long) catalog[0].Nmeas_disk);
    255259    }
    256260    catalog[0].Nmeasure = catalog[0].Nmeas_disk;
    … …  
    282286    catalog[0].missing = gfits_table_get_Missing (&ftable, &Nmissing, NULL);
    283287    if (Nmissing != catalog[0].Nmiss_disk) {
    284       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, catalog[0].Nmiss_disk);
     288      fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%lld vs %lld)\n", (long long) Nmissing, (long long) catalog[0].Nmiss_disk);
    285289    }
    286290    catalog[0].Nmissing = catalog[0].Nmiss_disk;
    … …  
    311315    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    312316    if (Nitems != catalog[0].Nsecf_disk) {
    313       fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nitems, catalog[0].Nsecf_disk);
     317      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%lld vs %lld)\n", (long long) Nitems, (long long) catalog[0].Nsecf_disk);
    314318    }
    315319    catalog[0].Nsecf_mem = catalog[0].Nsecf_disk;
    … …  
    339343// I need to always read both average and secfilt at the same time to correctly manage the
    340344// primary secfilt values...
    341 int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, int start, int Nrows) {
    342 
    343   int Nbytes, Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
     345int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows) {
     346
     347  off_t Nbytes;
     348  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
    344349  Header header;
    345350  FTable ftable;
    … …  
    357362    /*** load the Average data ***/
    358363    /* move pointer past header and matrix -- must be already read (load_catalog) */
    359     Nbytes = catalog[0].header.size + gfits_data_size (&catalog[0].header);
    360     fseek (catalog[0].f, Nbytes, SEEK_SET);
     364    Nbytes = catalog[0].header.datasize + gfits_data_size (&catalog[0].header);
     365    fseeko (catalog[0].f, Nbytes, SEEK_SET);
    361366    /* read Average table header */
    362367    if (!gfits_fread_header (catalog[0].f, &header)) {
    … …  
    386391
    387392    /* move pointer past header -- must be already read (load_catalog) */
    388     Nbytes = subcat[0].header.size + gfits_data_size (&subcat[0].header);
    389     fseek (subcat[0].f, Nbytes, SEEK_SET);
     393    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     394    fseeko (subcat[0].f, Nbytes, SEEK_SET);
    390395
    391396    /* read Secfilt table header */
    … …  
    403408    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    404409    if (Nitems != Nexpect) {
    405       fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nitems, Nexpect);
     410      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%lld vs %lld)\n", (long long) Nitems, (long long) Nexpect);
    406411    }
    407412    catalog[0].Nsecf_mem = catalog[0].Naverage * catalog[0].Nsecfilt;
    … …  
    422427
    423428    /* move pointer past header -- must be already read (load_catalog) */
    424     Nbytes = subcat[0].header.size + gfits_data_size (&subcat[0].header);
    425     fseek (subcat[0].f, Nbytes, SEEK_SET);
     429    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     430    fseeko (subcat[0].f, Nbytes, SEEK_SET);
    426431
    427432    /* read Measure table header */
    … …  
    439444    catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
    440445    if (Nmeasure != Nrows) {
    441       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, Nrows);
     446      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%lld vs %lld)\n", (long long) Nmeasure, (long long) Nrows);
    442447    }
    443448    gfits_free_header (&header);
    … …  
    452457
    453458    /* move pointer past header -- must be already read (load_catalog) */
    454     Nbytes = subcat[0].header.size + gfits_data_size (&subcat[0].header);
    455     fseek (subcat[0].f, Nbytes, SEEK_SET);
     459    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     460    fseeko (subcat[0].f, Nbytes, SEEK_SET);
    456461
    457462    /* read Missing table header */
    … …  
    469474    catalog[0].missing = gfits_table_get_Missing (&ftable, &Nmissing, NULL);
    470475    if (Nmissing != Nrows) {
    471       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, Nrows);
     476      fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%lld vs %lld)\n", (long long) Nmissing, (long long) Nrows);
    472477    }
    473478    gfits_free_header (&header);
    … …  
    481486int dvo_catalog_save_split (Catalog *catalog, char VERBOSE) {
    482487
    483   int Nitems;
     488  off_t Nitems;
    484489  Header header;
    485490  FTable ftable;
    486491  SecFilt *primary, *secfilt;
    487   int Nsecfilt;
    488   int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
    489   int first, start, Nrows;
     492  off_t Nsecfilt;
     493  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     494  off_t first, start, Nrows;
    490495
    491496  ftable.header = &header;
    … …  
    519524
    520525  /* make sure header is consistent with data */
    521   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
    522   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
    523   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
    524   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     526  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, Naves_disk_new);
     527  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, Nmeas_disk_new);
     528  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, Nmiss_disk_new);
     529  gfits_modify (&catalog[0].header, "NSECFILT", "%lld", 1, Nsecfilt);
    525530  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    526531  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    555560    // even if we do not save the average table, we need to keep the header in sync
    556561    /* rewind file pointers and truncate (file is still open) */
    557     fseek (catalog[0].f, 0, SEEK_SET);
     562    fseeko (catalog[0].f, 0, SEEK_SET);
    558563
    559564    /* write table PHU header - always write this out */
    … …  
    662667int dvo_catalog_save_split_complete (Catalog *catalog, char VERBOSE) {
    663668
    664   int Nitems;
     669  off_t Nitems;
    665670  Header header;
    666671  FTable ftable;
    667672  SecFilt *primary, *secfilt;
    668   int Nsecfilt;
    669   int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
    670   int first, start, Nrows;
     673  off_t Nsecfilt;
     674  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     675  off_t first, start, Nrows;
    671676
    672677  ftable.header = &header;
    … …  
    693698  }
    694699
    695   if ((catalog[0].Naverage > 0) && (Naves_disk_new == 0)) {
    696     Naves_disk_new = catalog[0].Naverage;
     700  Naves_disk_new = catalog[0].Naverage;
     701  if (Naves_disk_new == 0) {
    697702    if (VERBOSE) fprintf (stderr, "resulting catalog is empty; delete it\n");
    698703    // unlink ();
    699704    return (TRUE);
    700705  }
    701 
    702   Naves_disk_new = catalog[0].Naverage;
    703706
    704707  // for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary
    … …  
    720723
    721724  /* make sure header is consistent with data */
    722   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
    723   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
    724   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
    725   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     725  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, Naves_disk_new);
     726  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, Nmeas_disk_new);
     727  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, Nmiss_disk_new);
     728  gfits_modify (&catalog[0].header, "NSECFILT", "%lld", 1, Nsecfilt);
    726729  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    727730  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    756759    // even if we do not save the average table, we need to keep the header in sync
    757760    /* rewind file pointers and truncate (file is still open) */
    758     fseek (catalog[0].f, 0, SEEK_SET);
     761    fseeko (catalog[0].f, 0, SEEK_SET);
    759762
    760763    /* write table PHU header - always write this out */
    … …  
    866869  FTable ftable;
    867870  SecFilt *primary, *secfilt;
    868   int Nsecfilt;
    869   int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
    870   int first, start, Nrows;
     871  off_t Nsecfilt;
     872  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     873  off_t first, start, Nrows;
    871874
    872875  ftable.header = &header;
    … …  
    899902
    900903  /* make sure header is consistent with data */
    901   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
    902   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
    903   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
    904   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     904  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, Naves_disk_new);
     905  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, Nmeas_disk_new);
     906  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, Nmiss_disk_new);
     907  gfits_modify (&catalog[0].header, "NSECFILT", "%lld", 1, Nsecfilt);
    905908  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    906909  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    935938    // even if we do not save the average table, we need to keep the header in sync
    936939    /* rewind file pointers and truncate (file is still open) */
    937     fseek (catalog[0].f, 0, SEEK_SET);
     940    fseeko (catalog[0].f, 0, SEEK_SET);
    938941
    939942    /* write table PHU header - always write this out */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_convert.c

    r24748 r27295  
    1313/*** Average / FTable conversion functions ***/
    1414
    15 Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary) {
     15Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary) {
    1616
    1717  Average *average;
    … …  
    5959}
    6060
    61 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary) {
     61int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary) {
    6262
    6363# define FORMAT_CASE(FORMAT, TYPE) \
    … …  
    9494/*** Measure / FTable conversion functions ***/
    9595
    96 Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format) {
     96Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format) {
    9797
    9898  Measure *measure;
    … …  
    136136}
    137137
    138 int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format) {
     138int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format) {
    139139
    140140# define FORMAT_CASE(FORMAT, TYPE) \
    … …  
    171171/*** SecFilt / FTable conversion functions ***/
    172172
    173 SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format) {
     173SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format) {
    174174
    175175  SecFilt *secfilt;
    … …  
    213213}
    214214
    215 int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format) {
     215int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format) {
    216216
    217217# define FORMAT_CASE(FORMAT, TYPE) \
    … …  
    248248/*** Image Conversions ***/
    249249
    250 int FtableToImage (FTable *ftable, Header *theader, int *format) {
    251 
    252   int Nimage;
     250int FtableToImage (FTable *ftable, Header *theader, char *format) {
     251
     252  off_t Nimage;
    253253  char extname[80];
    254254
    … …  
    261261    gfits_free_header (theader);
    262262    gfits_table_mkheader_Image (theader);
    263     gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
     263    gfits_modify (theader, "NAXIS2", "%lld", 1, Nimage);
    264264    theader[0].Naxis[1] = Nimage;
    265     ftable[0].size = gfits_data_size (theader);
     265    ftable[0].datasize = gfits_data_size (theader);
    266266    return (TRUE);
    267267  }
    … …  
    282282    gfits_free_header (theader); \
    283283    gfits_table_mkheader_Image (theader); \
    284     gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
     284    gfits_modify (theader, "NAXIS2", "%lld", 1, Nimage); \
    285285    theader[0].Naxis[1] = Nimage; \
    286     ftable[0].size = gfits_data_size (theader); \
     286    ftable[0].datasize = gfits_data_size (theader); \
    287287    return (TRUE); }
    288288
    … …  
    312312}
    313313
    314 int ImageToFtable (FTable *ftable, Header *theader, int format) {
    315 
    316   int Nimage;
     314int ImageToFtable (FTable *ftable, Header *theader, char format) {
     315
     316  off_t Nimage;
    317317
    318318  Nimage = theader[0].Naxis[1];
    … …  
    353353}
    354354
    355 int ImageToVtable (VTable *vtable, Header *theader, int format) {
    356 
    357   int i, Nrow, Nimage;
     355int ImageToVtable (VTable *vtable, Header *theader, char format) {
     356
     357  off_t i, Nrow, Nimage;
    358358
    359359  Nrow = vtable[0].Nrow;
    … …  
    370370      } \
    371371      /* convert header from old format to new format */ \
    372       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage); \
     372      gfits_scan (theader, "NAXIS2", "%lld", 1, &Nimage); \
    373373      gfits_free_header (theader); \
    374374      gfits_table_mkheader_Image_##TYPE (theader); \
    375       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
     375      gfits_modify (theader, "NAXIS2", "%lld", 1, Nimage); \
    376376      theader[0].Naxis[1] = Nimage; \
    377       vtable[0].size = gfits_data_size (theader); \
     377      vtable[0].datasize = gfits_data_size (theader); \
    378378      return (TRUE); }
    379379

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c

    r26482 r27295  
    9797    out[i].P             = NAN;
    9898    out[i].dP            = NAN;
    99     out[i].Xp            = NAN;
     99    out[i].Xp            = NAN_S_SHORT;
    100100    out[i].ChiSq         = NAN;
    101101    out[i].Npos          = 0;
    … …  
    148148    out[i].M     = in[i].M;     
    149149    out[i].dM    = in[i].dM;     
    150     out[i].Xm    = NAN;
     150    out[i].Xm    = NAN_S_SHORT;
    151151    out[i].Ncode = 0;
    152152    out[i].Nused = 0;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_image.c

    r25757 r27295  
    5252  /* test for NAXIS == 2 in line 3 */
    5353  bzero (buffer, 241);
    54   fseek (db[0].f, 0, SEEK_SET);
     54  fseeko (db[0].f, 0, SEEK_SET);
    5555  Nread = fread (buffer, 1, 240, db[0].f);
    5656  if (Nread != 240) {
    … …  
    6363    return (FALSE);
    6464  }
    65   fseek (db[0].f, 0, SEEK_SET);
     65  fseeko (db[0].f, 0, SEEK_SET);
    6666
    6767  /* default values */
    … …  
    114114}
    115115
    116 int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew) {
    117 
    118   int Nimages;
     116int dvo_image_addrows (FITS_DB *db, Image *new, off_t Nnew) {
     117
     118  off_t Nimages;
    119119
    120120  /* adjust header */
    121121  Nimages = 0;
    122   gfits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimages);
     122  gfits_scan (&db[0].header, "NIMAGES", "%lld", 1, &Nimages);
    123123  Nimages += Nnew;
    124   gfits_modify (&db[0].header, "NIMAGES", "%d", 1, Nimages);
     124  gfits_modify (&db[0].header, "NIMAGES", "%lld", 1, Nimages);
    125125
    126126  gfits_table_to_vtable (&db[0].ftable, &db[0].vtable, 0, 0);
    … …  
    195195  gfits_table_set_Image (&db[0].ftable, NULL, 0);
    196196
    197   gfits_modify (&db[0].header, "NIMAGES", "%d", 1, 0);
     197  gfits_modify (&db[0].header, "NIMAGES", "%lld", 1, 0);
    198198  gfits_modify (&db[0].header, "ZERO_PT", "%lf", 1, ZeroPoint);
    199199

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_image_raw.c

    r24748 r27295  
    77int dvo_image_load_raw (FITS_DB *db, int VERBOSE, int FORCE_READ) {
    88
    9   int Nimage, Ndata, size, ImageSize, nbytes, Nbytes;
     9  off_t Nimage, Ndata, size, ImageSize, nbytes, Nbytes;
    1010  struct stat filestatus;
    1111  char format[80], telescope[80];
    … …  
    3939  /* find number of images */
    4040  Nimage = 0;
    41   gfits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimage);
     41  gfits_scan (&db[0].header, "NIMAGES", "%lld", 1, &Nimage);
    4242  if (stat (db[0].filename, &filestatus) == -1) {
    4343    if (VERBOSE) fprintf (stderr, "ERROR: failed to get status of image catalog\n");
    … …  
    5959
    6060  /* check that filesize makes sense */
    61   size = Nimage*ImageSize + db[0].header.size;
     61  size = Nimage*ImageSize + db[0].header.datasize;
    6262  if (size != filestatus.st_size) {
    63     Ndata = (filestatus.st_size - db[0].header.size) / ImageSize;
     63    Ndata = (filestatus.st_size - db[0].header.datasize) / ImageSize;
    6464    if (VERBOSE) fprintf (stderr, "ERROR: image catalog has inconsistent size\n");
    65     if (VERBOSE) fprintf (stderr, "header: %d, data: %d\n", Nimage, Ndata);
     65    if (VERBOSE) fprintf (stderr, "header: %lld, data: %lld\n", (long long) Nimage, (long long) Ndata);
    6666    if (!FORCE_READ) exit (1);
    6767    Nimage = Ndata;
    … …  
    9494  }
    9595
    96   gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
     96  gfits_modify (&db[0].theader, "NAXIS2", "%lld", 1, Nimage);
    9797  db[0].theader.Naxis[1] = Nimage;
    98   db[0].ftable.size = gfits_data_size (&db[0].theader);
     98  db[0].ftable.datasize = gfits_data_size (&db[0].theader);
    9999  db[0].swapped = FALSE;  /* table does not have internal byte-order */
    100100  return (TRUE);
    … …  
    104104int dvo_image_update_raw (FITS_DB *db, int VERBOSE) {
    105105
    106   int i, Nx, Ny, Nrow, Nbytes;
    107   int status, start, offset;
    108   int *row;
     106  off_t i, Nx, Ny, Nrow, Nbytes, start, offset;
     107  off_t status;
     108  off_t *row;
    109109
    110   if (VERBOSE) fprintf (stderr, "writing out %d images\n", db[0].vtable.Nrow);
     110  if (VERBOSE) fprintf (stderr, "writing out %lld images\n", (long long) db[0].vtable.Nrow);
    111111
    112112  /* position to start of file */
    113   Fseek (db[0].f, 0, SEEK_SET);
     113  fseeko (db[0].f, 0, SEEK_SET);
    114114 
    115115  /* write out complete header (no check on disk size?) */
    116   status = fwrite (db[0].header.buffer, 1, db[0].header.size, db[0].f);
    117   if (status != db[0].header.size) {
     116  status = fwrite (db[0].header.buffer, 1, db[0].header.datasize, db[0].f);
     117  if (status != db[0].header.datasize) {
    118118    fprintf (stderr, "ERROR: failed writing data to image header\n");
    119119    exit (1);
    … …  
    123123  Nrow = db[0].vtable.Nrow;
    124124  row = db[0].vtable.row;
    125   gfits_scan (db[0].vtable.header, "NAXIS1", "%d", 1, &Nx);
    126   gfits_scan (db[0].vtable.header, "NAXIS2", "%d", 1, &Ny);
     125  gfits_scan (db[0].vtable.header, "NAXIS1", "%lld", 1, &Nx);
     126  gfits_scan (db[0].vtable.header, "NAXIS2", "%lld", 1, &Ny);
    127127
    128128  /* file pointer is at beginning of desired table data */
    … …  
    131131  for (i = 0; i < Nrow; i++) {
    132132    offset = start + Nx*row[i];
    133     fseek (db[0].f, offset, SEEK_SET);
     133    fseeko (db[0].f, offset, SEEK_SET);
    134134    Nbytes = fwrite (db[0].vtable.buffer[i], sizeof (char), Nx, db[0].f);
    135135    if (Nbytes != Nx) { return (FALSE); }
    … …  
    141141int dvo_image_save_raw (FITS_DB *db, int VERBOSE) {
    142142
    143   int status, Nx, Ny, size, Nbytes;
     143  off_t Nx, Ny, size, Nbytes;
     144  int status;
    144145
    145   if (VERBOSE) fprintf (stderr, "writing out %d images\n", db[0].theader.Naxis[1]);
     146  if (VERBOSE) fprintf (stderr, "writing out %lld images\n", (long long) db[0].theader.Naxis[1]);
    146147
    147148  /* position to start of file */
    … …  
    149150 
    150151  /* write out complete header (no check on disk size?) */
    151   status = fwrite (db[0].header.buffer, 1, db[0].header.size, db[0].f);
    152   if (status != db[0].header.size) {
     152  status = fwrite (db[0].header.buffer, 1, db[0].header.datasize, db[0].f);
     153  if (status != db[0].header.datasize) {
    153154    fprintf (stderr, "ERROR: failed writing data to image header\n");
    154155    exit (1);
    155156  }
    156157
    157   gfits_scan (db[0].ftable.header, "NAXIS1", "%d", 1, &Nx);
    158   gfits_scan (db[0].ftable.header, "NAXIS2", "%d", 1, &Ny);
     158  gfits_scan (db[0].ftable.header, "NAXIS1", "%lld", 1, &Nx);
     159  gfits_scan (db[0].ftable.header, "NAXIS2", "%lld", 1, &Ny);
    159160  size = Nx * Ny;
    160161  Nbytes = fwrite (db[0].ftable.buffer, sizeof(char), size, db[0].f);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvo_util.c

    r26410 r27295  
    1818
    1919    memset(config, 0, sizeof(dvoConfig));
     20    return config;
    2021}
    2122
    … …  
    9899    }
    99100
    100     char *catdir, filename[256];
     101    char filename[256];
    101102 
    102103    sprintf (filename, "%s/Images.dat", dvoConfig->catdir);
    … …  
    136137Image *dvoImageByExternID(dvoConfig *dvoConfig, int sourceID, int externID)
    137138{
    138     Image *images;
    139     int Nimage;
    140139    int i;
    141140   
    … …  
    199198}
    200199
    201 int dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID)
    202 {
    203   int QUIET = 0;
    204   int FULL_OUTPUT = 0;
     200off_t dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID)
     201{
    205202  int GetMeasures = 1;
    206   int SaveVectors = 0;
    207203  int reg;
    208   int Ndetect = 0;
     204  off_t Ndetect = 0;
    209205
    210206  int detectionsArrayLength = 1000;
    … …  
    226222      dvo_catalog_unlock (&catalog);
    227223
    228       int Nstars = catalog.Naverage;
    229       int Nmeasure = catalog.Nmeasure;
    230 
    231       int i;
     224      off_t Nmeasure = catalog.Nmeasure;
     225
     226      off_t i;
    232227      for (i=0; i< Nmeasure; i++) {
    233228        Measure *m = catalog.measure + i;
    … …  
    265260
    266261      memset(sorted, 0, sizeof(dvoDetection) * *pMaxDetID);
    267       int i;
     262      off_t i;
    268263      for (i = 0; i < Ndetect; i++) {
    269264           sorted[detections[i].meas.detID] = detections[i];

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/dvosorts.c

    r21508 r27295  
    44
    55/* values are ave[i].R, ave[i].D, ave[i].M */
    6 void sortave (Average *ave, int N) {
     6void sortave (Average *ave, off_t N) {
    77
    88# define SWAPFUNC(A,B){ Average tmp; tmp = ave[A]; ave[A] = ave[B]; ave[B] = tmp; }
    … …  
    1717
    1818/* sort subset by image[subset[i]].tzero */
    19 void sort_image_subset (Image *image, int *subset, int N) {
     19void sort_image_subset (Image *image, off_t *subset, off_t N) {
    2020
    2121# define SWAPFUNC(A,B){ int tmp; tmp = subset[A]; subset[A] = subset[B]; subset[B] = tmp; }
    … …  
    3030
    3131/* sort a coordinate pair (X,Y) and the associated index (S) */
    32 void sort_coords_index (double *X, double *Y, int *S, int N) {
     32void sort_coords_index (double *X, double *Y, off_t *S, off_t N) {
    3333 
    34 # define SWAPFUNC(A,B){ double dtmp; int itmp; \
     34# define SWAPFUNC(A,B){ double dtmp; off_t itmp; \
    3535  dtmp = X[A]; X[A] = X[B]; X[B] = dtmp; \
    3636  dtmp = Y[A]; Y[A] = Y[B]; Y[B] = dtmp; \
    … …  
    4646}
    4747
    48 void sort_regions (SkyRegion *region, int N) {
     48void sort_regions (SkyRegion *region, off_t N) {
    4949
    5050# define SWAPFUNC(A,B){ SkyRegion tmp; tmp = region[A]; region[A] = region[B]; region[B] = tmp; }
    … …  
    5757
    5858}
    59 
    60 # if (0)
    61 // deprecated along with Stars as an autocode type
    62 void sort_stars_ra (Stars *stars, int N) {
    63 
    64 # define SWAPFUNC(A,B){ Stars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
    65 # define COMPARE(A,B)(stars[A].R < stars[B].R)
    66 
    67   OHANA_SORT (N, COMPARE, SWAPFUNC);
    68 
    69 # undef SWAPFUNC
    70 # undef COMPARE
    71 
    72 }
    73 # endif

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/fits_db.c

    r15750 r27295  
    9292}
    9393
    94 /* load the data from Nrows from table starting at start; load header, etc if needed */
    95 int gfits_db_load_segment (FITS_DB *db, int start, int Nrows) {
    96 
    97   int Nskip;
     94/* load the Nrows data from table starting at start; load header, etc if needed */
     95int gfits_db_load_segment (FITS_DB *db, off_t start, off_t Nrows) {
     96
     97  off_t Nskip;
    9898
    9999  /* database name must be set first */
    … …  
    119119    }
    120120  } else {
    121     Nskip = db[0].header.size;
     121    Nskip = db[0].header.datasize;
    122122    Fseek (db[0].f, Nskip, SEEK_CUR);
    123123  }
    … …  
    141141    }
    142142  } else {
    143     Nskip = db[0].header.size;
     143    Nskip = db[0].header.datasize;
    144144    Fseek (db[0].f, Nskip, SEEK_CUR);
    145145  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libdvo/src/skyregion_ops.c

    r24976 r27295  
    386386SkyList *SkyListChildrenByBounds_List (SkyList *table, int depth, double Rmin, double Rmax, double Dmin, double Dmax) {
    387387
    388   int i, j, Ns, Ne, Nnew, NNEW;
    389   int append;
    390   SkyList *children;
     388  int i, Nnew, NNEW;
    391389  SkyList *list;
    392390  SkyRegion **region;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_H_field.c

    r21059 r27295  
    66
    77  char *buf;
    8   int i, Nwant, Nfound;
     8  off_t i;
     9  int Nwant, Nfound;
    910  char keyword[10];
    1011
    … …  
    1920    /* find the Nth entry */
    2021    Nfound = 0;
    21     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     22    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    2223      if (!strncmp (keyword, buf, 8)) {
    2324        Nfound ++;
    … …  
    3031    /* count the entries */
    3132    Nfound = 0;
    32     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     33    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    3334      if (!strncmp (keyword, buf, 8)) {
    3435        Nfound ++;
    … …  
    4142    /* find the Nwant entry */
    4243    Nfound = 0;
    43     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     44    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    4445      if (!strncmp (keyword, buf, 8)) {
    4546        Nfound ++;
    … …  
    6667
    6768  char *buf, *ptr;
    68   int i, Nwant, Nfound, Nfield;
     69  off_t i;
     70  int Nwant, Nfound, Nfield;
    6971
    7072  Nfield = strlen (field);
    … …  
    7678  if (N > 0) {
    7779    Nfound = 0;
    78     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     80    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    7981      // have we found a HIERARCH entry?
    8082      if (strncmp ("HIERARCH", buf, 8)) continue;
    … …  
    9092    /* count the entries */
    9193    Nfound = 0;
    92     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     94    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    9395      if (strncmp ("HIERARCH", buf, 8)) continue;
    9496      ptr = buf + 9; // start of following keyword
    … …  
    102104    /* find the Nwant entry */
    103105    Nfound = 0;
    104     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     106    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    105107      if (strncmp ("HIERARCH", buf, 8)) continue;
    106108      ptr = buf + 9; // start of following keyword
    … …  
    122124
    123125/*********************** fits header field ****************************/
    124 char *gfits_header_lineno (Header *header, int N) {
     126char *gfits_header_lineno (Header *header, off_t N) {
    125127
    126128  char *buf;
    127129
    128   if (N*80 >= header[0].size) return NULL;
     130  if (N*80 >= header[0].datasize) return NULL;
    129131
    130132  buf = &header[0].buffer[N*80];

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_copy_H.c

    r17903 r27295  
    1616    out[0].Naxis[i] = in[0].Naxis[i];
    1717
    18   out[0].size   = in[0].size;
     18  out[0].datasize = in[0].datasize;
    1919
    2020  out[0].pcount = in[0].pcount;
    … …  
    2424
    2525  if (out[0].buffer != NULL) free (out[0].buffer);
    26   ALLOCATE (out[0].buffer, char, out[0].size);
     26  ALLOCATE (out[0].buffer, char, out[0].datasize);
    2727 
    28   strncpy (out[0].buffer, in[0].buffer, out[0].size);
     28  memcpy (out[0].buffer, in[0].buffer, out[0].datasize);
    2929
    3030  return (TRUE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_create_H.c

    r15487 r27295  
    99  char axis[10];
    1010 
    11   header[0].size = NBYTES;
     11  header[0].datasize = NBYTES;
    1212
    1313  ALLOCATE (header[0].buffer, char, NBYTES);
    … …  
    2323  for (i = 0; i < header[0].Naxes; i++) {
    2424    snprintf (axis, 10, "NAXIS%d", i + 1);
    25     gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i]);
     25    gfits_modify (header,  axis, "%lld", 1, header[0].Naxis[i]);
    2626  }
    2727

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_delete.c

    r7054 r27295  
    55int gfits_delete (Header *header, char *field, int N) {
    66 
    7   int i, Nbytes;
     7  int i;
     8  off_t Nbytes;
    89  char *p1, *p2;
    910 
    … …  
    2223
    2324  p2 = gfits_header_field (header, "END", 1);
    24   if (header[0].size - (p2 - header[0].buffer + FT_LINE_LENGTH) > FT_RECORD_SIZE) {
    25     header[0].size -= FT_RECORD_SIZE;
    26     REALLOCATE (header[0].buffer, char, header[0].size);
     25  if (header[0].datasize - (p2 - header[0].buffer + FT_LINE_LENGTH) > FT_RECORD_SIZE) {
     26    header[0].datasize -= FT_RECORD_SIZE;
     27    REALLOCATE (header[0].buffer, char, header[0].datasize);
    2728  }
    2829  return (TRUE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_modify.c

    r21059 r27295  
    2929   
    3030    /* is there enough space for 1 more line? */
    31     if (header[0].size - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
    32       header[0].size += FT_RECORD_SIZE;
    33       REALLOCATE (header[0].buffer, char, header[0].size);
     31    if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     32      header[0].datasize += FT_RECORD_SIZE;
     33      REALLOCATE (header[0].buffer, char, header[0].datasize);
    3434      p = gfits_header_field (header, "END", 1);
    3535      if (p == NULL) return (FALSE);
    … …  
    5050
    5151  /* write the numeric modes */
    52   if (!strcmp (mode, "%d"))  snprintf (string, 81, "%-8s= %20d / %-s ",     field, va_arg (argp, int),      comment);
    53   if (!strcmp (mode, "%u"))  snprintf (string, 81, "%-8s= %20d / %-s ",     field, va_arg (argp, unsigned), comment);
    54   if (!strcmp (mode, "%ld")) snprintf (string, 81, "%-8s= %20ld / %-s ",    field, va_arg (argp, long),     comment);
    55   if (!strcmp (mode, "%hd")) snprintf (string, 81, "%-8s= %20d / %-s ",     field, va_arg (argp, int),      comment);
    56   if (!strcmp (mode, "%f"))  snprintf (string, 81, "%-8s= %20.10f / %-s ",  field, va_arg (argp, double),   comment);
    57   if (!strcmp (mode, "%lf")) snprintf (string, 81, "%-8s= %20.10f / %-s ",  field, va_arg (argp, double),   comment);
    58   if (!strcmp (mode, "%e"))  snprintf (string, 81, "%-8s= %20.10E / %-s ",  field, va_arg (argp, double),   comment);
    59   if (!strcmp (mode, "%le")) snprintf (string, 81, "%-8s= %20.10E / %-s ",  field, va_arg (argp, double),   comment);
    60   if (!strcmp (mode, "%g"))  snprintf (string, 81, "%-8s= %20.10G / %-s ",  field, va_arg (argp, double),   comment);
    61   if (!strcmp (mode, "%lg")) snprintf (string, 81, "%-8s= %20.10G / %-s ",  field, va_arg (argp, double),   comment);
     52  if (!strcmp (mode, "%d"))   snprintf (string, 81, "%-8s= %20d / %-s ",    field, va_arg (argp, int),                comment);
     53  if (!strcmp (mode, "%ld"))  snprintf (string, 81, "%-8s= %20ld / %-s ",   field, va_arg (argp, long),               comment);
     54  if (!strcmp (mode, "%lld")) snprintf (string, 81, "%-8s= %20lld / %-s ",  field, va_arg (argp, long long),          comment);
     55  if (!strcmp (mode, "%Ld"))  snprintf (string, 81, "%-8s= %20lld / %-s ",  field, va_arg (argp, long long),          comment);
     56  if (!strcmp (mode, "%u"))   snprintf (string, 81, "%-8s= %20u / %-s ",    field, va_arg (argp, unsigned),           comment);
     57  if (!strcmp (mode, "%lu"))  snprintf (string, 81, "%-8s= %20lu / %-s ",   field, va_arg (argp, unsigned long),      comment);
     58  if (!strcmp (mode, "%llu")) snprintf (string, 81, "%-8s= %20llu / %-s ",  field, va_arg (argp, unsigned long long), comment);
     59  if (!strcmp (mode, "%Lu"))  snprintf (string, 81, "%-8s= %20llu / %-s ",  field, va_arg (argp, unsigned long long), comment);
     60  if (!strcmp (mode, "%hd"))  snprintf (string, 81, "%-8s= %20d / %-s ",    field, va_arg (argp, int),                comment);
     61  if (!strcmp (mode, "%f"))   snprintf (string, 81, "%-8s= %20.10f / %-s ", field, va_arg (argp, double),             comment);
     62  if (!strcmp (mode, "%lf"))  snprintf (string, 81, "%-8s= %20.10f / %-s ", field, va_arg (argp, double),             comment);
     63  if (!strcmp (mode, "%e"))   snprintf (string, 81, "%-8s= %20.10E / %-s ", field, va_arg (argp, double),             comment);
     64  if (!strcmp (mode, "%le"))  snprintf (string, 81, "%-8s= %20.10E / %-s ", field, va_arg (argp, double),             comment);
     65  if (!strcmp (mode, "%g"))   snprintf (string, 81, "%-8s= %20.10G / %-s ", field, va_arg (argp, double),             comment);
     66  if (!strcmp (mode, "%lg"))  snprintf (string, 81, "%-8s= %20.10G / %-s ", field, va_arg (argp, double),             comment);
    6267
    6368  /* write the boolean mode */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_print.c

    r7054 r27295  
    2727
    2828  /* is there enough space for 1 more line? */
    29   if (header[0].size - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
    30     header[0].size += FT_RECORD_SIZE;
    31     REALLOCATE (header[0].buffer, char, header[0].size);
     29  if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     30    header[0].datasize += FT_RECORD_SIZE;
     31    REALLOCATE (header[0].buffer, char, header[0].datasize);
    3232    /* re-find the "END" marker, in case new memory block is used */
    3333    p = gfits_header_field (header, "END", 1);
    … …  
    4545
    4646  /* write the numeric modes */
    47   if (!strcmp (mode, "%d"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),      blank); }
    48   if (!strcmp (mode, "%u"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, unsigned), blank); }
    49   if (!strcmp (mode, "%ld")) { snprintf (string, 81, "%-8s= %20ld / %46s ",   field, va_arg (argp, long),     blank); }
    50   if (!strcmp (mode, "%hd")) { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),      blank); }
    51   if (!strcmp (mode, "%f"))  { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),   blank); }
    52   if (!strcmp (mode, "%lf")) { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),   blank); }
    53   if (!strcmp (mode, "%e"))  { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),   blank); }
    54   if (!strcmp (mode, "%le")) { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),   blank); }
    55   if (!strcmp (mode, "%g"))  { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),   blank); }
    56   if (!strcmp (mode, "%lg")) { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),   blank); }
     47  if (!strcmp (mode, "%d"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),                blank); }
     48  if (!strcmp (mode, "%ld")) { snprintf (string, 81, "%-8s= %20ld / %46s ",   field, va_arg (argp, long),               blank); }
     49  if (!strcmp (mode, "%lld")){ snprintf (string, 81, "%-8s= %20lld / %46s ",  field, va_arg (argp, long long),          blank); }
     50  if (!strcmp (mode, "%Ld")) { snprintf (string, 81, "%-8s= %20lld / %46s ",  field, va_arg (argp, long long),          blank); }
     51  if (!strcmp (mode, "%u"))  { snprintf (string, 81, "%-8s= %20u / %46s ",    field, va_arg (argp, unsigned),           blank); }
     52  if (!strcmp (mode, "%lu")) { snprintf (string, 81, "%-8s= %20lu / %46s ",   field, va_arg (argp, unsigned long),      blank); }
     53  if (!strcmp (mode, "%llu")){ snprintf (string, 81, "%-8s= %20llu / %46s ",  field, va_arg (argp, unsigned long long), blank); }
     54  if (!strcmp (mode, "%Lu")) { snprintf (string, 81, "%-8s= %20llu / %46s ",  field, va_arg (argp, unsigned long long), blank); }
     55  if (!strcmp (mode, "%hd")) { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),                blank); }
     56  if (!strcmp (mode, "%f"))  { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),             blank); }
     57  if (!strcmp (mode, "%lf")) { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),             blank); }
     58  if (!strcmp (mode, "%e"))  { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),             blank); }
     59  if (!strcmp (mode, "%le")) { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),             blank); }
     60  if (!strcmp (mode, "%g"))  { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),             blank); }
     61  if (!strcmp (mode, "%lg")) { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),             blank); }
    5762
    5863  /* write the boolean mode */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_read_H.c

    r15904 r27295  
    2323int gfits_load_header (FILE *f, Header *header) {
    2424
    25   int i, done, Nbytes, t1, t2;
     25  off_t i, Nbytes;
     26  int done, t1, t2;
    2627  char *p;
    2728
    28   header[0].size = 0;
     29  header[0].datasize = 0;
    2930  done = FALSE;
    3031  ALLOCATE (header[0].buffer, char, 1);
    … …  
    3233  for (i = 0; !done; i++) {
    3334    REALLOCATE (header[0].buffer, char, (i + 1)*FT_RECORD_SIZE);
    34     Nbytes = fread (&header[0].buffer[i*FT_RECORD_SIZE],
    35                     sizeof(char), FT_RECORD_SIZE, f);
     35    Nbytes = fread (&header[0].buffer[i*FT_RECORD_SIZE], sizeof(char), FT_RECORD_SIZE, f);
    3636    if (Nbytes != FT_RECORD_SIZE) {
    3737      if (feof(f)) return (FALSE);
    … …  
    4040    }
    4141   
    42     header[0].size += Nbytes;
     42    header[0].datasize += Nbytes;
    4343
    4444    if (i == 0) {
    … …  
    6969  gfits_scan (header,  "BZERO",  "%lf",  1, &header[0].bzero);
    7070                                       
    71   gfits_scan (header,  "NAXIS1", "%d", 1, &header[0].Naxis[0]);
    72   gfits_scan (header,  "NAXIS2", "%d", 1, &header[0].Naxis[1]);
    73   gfits_scan (header,  "NAXIS3", "%d", 1, &header[0].Naxis[2]);
    74   gfits_scan (header,  "NAXIS4", "%d", 1, &header[0].Naxis[3]);
    75   gfits_scan (header,  "NAXIS5", "%d", 1, &header[0].Naxis[4]);
    76   gfits_scan (header,  "NAXIS6", "%d", 1, &header[0].Naxis[5]);
    77   gfits_scan (header,  "NAXIS7", "%d", 1, &header[0].Naxis[6]);
    78   gfits_scan (header,  "NAXIS8", "%d", 1, &header[0].Naxis[7]);
    79   gfits_scan (header,  "NAXIS9", "%d", 1, &header[0].Naxis[8]);
    80   gfits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]);
     71  gfits_scan (header,  "NAXIS1", "%lld", 1, &header[0].Naxis[0]);
     72  gfits_scan (header,  "NAXIS2", "%lld", 1, &header[0].Naxis[1]);
     73  gfits_scan (header,  "NAXIS3", "%lld", 1, &header[0].Naxis[2]);
     74  gfits_scan (header,  "NAXIS4", "%lld", 1, &header[0].Naxis[3]);
     75  gfits_scan (header,  "NAXIS5", "%lld", 1, &header[0].Naxis[4]);
     76  gfits_scan (header,  "NAXIS6", "%lld", 1, &header[0].Naxis[5]);
     77  gfits_scan (header,  "NAXIS7", "%lld", 1, &header[0].Naxis[6]);
     78  gfits_scan (header,  "NAXIS8", "%lld", 1, &header[0].Naxis[7]);
     79  gfits_scan (header,  "NAXIS9", "%lld", 1, &header[0].Naxis[8]);
     80  gfits_scan (header, "NAXIS10", "%lld", 1, &header[0].Naxis[9]);
    8181
    8282  if (!gfits_scan (header, "PCOUNT",  "%d", 1, &header[0].pcount)) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_read_XH.c

    r19250 r27295  
    3131  /* read header for extension number N */
    3232
    33   int j, Nmatrix, Nskip;
     33  int j;
     34  off_t Nmatrix, Nskip;
    3435  Header theader;
    3536 
    3637  /* set f to beginning of file */
    37   fseek (f, 0, SEEK_SET);
     38  fseeko (f, 0, SEEK_SET);
    3839
    3940  Nskip = 0;
    … …  
    4748
    4849    /* skip to next header */
    49     fseek (f, Nmatrix, SEEK_CUR);
    50     Nskip += (Nmatrix + theader.size);
     50    fseeko (f, Nmatrix, SEEK_CUR);
     51    Nskip += (Nmatrix + theader.datasize);
    5152    gfits_free_header (&theader);
    5253  }
    … …  
    5556    return (FALSE);
    5657  }
    57   Nskip += header[0].size;
     58  Nskip += header[0].datasize;
    5859  return (Nskip);
    5960}       

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_scan.c

    r21059 r27295  
    1717  char *p, *q, *s, tmp[81];
    1818  int Nchar, status;
    19   double value;
     19  long long value;
     20  double fvalue;
    2021 
    2122  /* find the correct line with field */
    … …  
    7778  s = gfits_keyword_start (p); /* points at first char (not ') */
    7879  q = gfits_keyword_end (p); /* points at following space or ' */
    79   value = strtod (s, &q);
    80   if ((*q == 'd') || (*q == 'D'))
    81     value *= pow (10.0, atof (q + 1));
    82 
    83   if (!strcmp (mode, "%d"))  { *va_arg (argp, int *)       = value; return (TRUE); }
    84   if (!strcmp (mode, "%u"))  { *va_arg (argp, unsigned *)  = value; return (TRUE); }
    85   if (!strcmp (mode, "%ld")) { *va_arg (argp, long *)      = value; return (TRUE); }
    86   if (!strcmp (mode, "%hd")) { *va_arg (argp, short *)     = value; return (TRUE); }
    87   if (!strcmp (mode, "%f"))  { *va_arg (argp, float *)     = value; return (TRUE); }
    88   if (!strcmp (mode, "%lf")) { *va_arg (argp, double *)    = value; return (TRUE); }
     80
     81  if (!strcmp (mode, "%f") || !strcmp (mode, "%lf")) {
     82    fvalue = strtod (s, &q);
     83    if ((*q == 'd') || (*q == 'D'))
     84      fvalue *= pow (10.0, atof (q + 1));
     85
     86    if (!strcmp (mode, "%f"))   { *va_arg (argp, float *)  = fvalue; return (TRUE); }
     87    if (!strcmp (mode, "%lf"))  { *va_arg (argp, double *) = fvalue; return (TRUE); }
     88  }
     89
     90  value = strtoll (s, &q, 0);
     91  if ((*q == 'd') || (*q == 'D')) value *= pow (10.0, atof (q + 1));
     92
     93  if (!strcmp (mode, "%d"))   { *va_arg (argp, int *)                = value; return (TRUE); }
     94  if (!strcmp (mode, "%ld"))  { *va_arg (argp, long *)               = value; return (TRUE); }
     95  if (!strcmp (mode, "%lld")) { *va_arg (argp, long long *)          = value; return (TRUE); }
     96  if (!strcmp (mode, "%Ld"))  { *va_arg (argp, long long *)          = value; return (TRUE); }
     97  if (!strcmp (mode, "%u"))   { *va_arg (argp, unsigned *)           = value; return (TRUE); }
     98  if (!strcmp (mode, "%lu"))  { *va_arg (argp, unsigned long *)      = value; return (TRUE); }
     99  if (!strcmp (mode, "%llu")) { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     100  if (!strcmp (mode, "%Lu"))  { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     101  if (!strcmp (mode, "%hd"))  { *va_arg (argp, short *)              = value; return (TRUE); }
    89102
    90103  /* no valid mode found */
    … …  
    97110  char *p, *q, *s, tmp[81];
    98111  int Nchar, Nfield;
    99   double value;
     112  long long value;
     113  double fvalue;
    100114 
    101115  /* find the correct line with field */
    … …  
    156170  s = gfits_hierarch_keyword_start (p, field); /* points at first char (not ') */
    157171  q = gfits_hierarch_keyword_end (p, field); /* points at following space or ' */
    158   value = strtod (s, &q);
    159   if ((*q == 'd') || (*q == 'D'))
    160     value *= pow (10.0, atof (q + 1));
    161 
    162   if (!strcmp (mode, "%d"))  { *va_arg (argp, int *)       = value; return (TRUE); }
    163   if (!strcmp (mode, "%u"))  { *va_arg (argp, unsigned *)  = value; return (TRUE); }
    164   if (!strcmp (mode, "%ld")) { *va_arg (argp, long *)      = value; return (TRUE); }
    165   if (!strcmp (mode, "%hd")) { *va_arg (argp, short *)     = value; return (TRUE); }
    166   if (!strcmp (mode, "%f"))  { *va_arg (argp, float *)     = value; return (TRUE); }
    167   if (!strcmp (mode, "%lf")) { *va_arg (argp, double *)    = value; return (TRUE); }
     172
     173  if (!strcmp (mode, "%f") || !strcmp (mode, "%lf")) {
     174    fvalue = strtod (s, &q);
     175    if ((*q == 'd') || (*q == 'D'))
     176      fvalue *= pow (10.0, atof (q + 1));
     177
     178    if (!strcmp (mode, "%f"))   { *va_arg (argp, float *)  = fvalue; return (TRUE); }
     179    if (!strcmp (mode, "%lf"))  { *va_arg (argp, double *) = fvalue; return (TRUE); }
     180  }
     181
     182  value = strtoll (s, &q, 0);
     183  if ((*q == 'd') || (*q == 'D')) value *= pow (10.0, atof (q + 1));
     184
     185  if (!strcmp (mode, "%d"))   { *va_arg (argp, int *)                = value; return (TRUE); }
     186  if (!strcmp (mode, "%ld"))  { *va_arg (argp, long *)               = value; return (TRUE); }
     187  if (!strcmp (mode, "%lld")) { *va_arg (argp, long long *)          = value; return (TRUE); }
     188  if (!strcmp (mode, "%Ld"))  { *va_arg (argp, long long *)          = value; return (TRUE); }
     189  if (!strcmp (mode, "%u"))   { *va_arg (argp, unsigned *)           = value; return (TRUE); }
     190  if (!strcmp (mode, "%lu"))  { *va_arg (argp, unsigned long *)      = value; return (TRUE); }
     191  if (!strcmp (mode, "%llu")) { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     192  if (!strcmp (mode, "%Lu"))  { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     193  if (!strcmp (mode, "%hd"))  { *va_arg (argp, short *)              = value; return (TRUE); }
    168194
    169195  /* no valid mode found */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/header/F_write_H.c

    r7054 r27295  
    66
    77  FILE *f;
    8   int Nbytes, status;
     8  off_t Nbytes;
     9  int status;
    910 
    1011  status = TRUE;
    … …  
    1314  if (f == (FILE *) NULL) return (FALSE);
    1415
    15   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].size, f);
     16  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    1617
    17   if (Nbytes != header[0].size) {
     18  if (Nbytes != header[0].datasize) {
    1819    status = FALSE;
    1920  }
    … …  
    2728int gfits_save_header (FILE *f, Header *header) {
    2829
    29   int Nbytes, status;
     30  off_t Nbytes;
     31  int status;
    3032 
    3133  status = TRUE;
    3234
    33   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].size, f);
     35  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    3436
    35   if (Nbytes != header[0].size) {
     37  if (Nbytes != header[0].datasize) {
    3638    status = FALSE;
    3739  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/include/gfitsio.h

    r21059 r27295  
    4444
    4545typedef struct {
    46   int                     simple;
    47   int                     unsign;
    48   int                     extend;
    49   int                     bitpix;
    50   int                     Naxes;
    51   int                     Naxis[FT_MAX_NAXES];
    52   int                     size;
     46  int                     simple; // T or F
     47  int                     unsign; // T or F
     48  int                     extend; // T or F
     49  int                     bitpix; // 8, 16, 32, 64, or -32, -64
     50  int                     Naxes;  // < FT_MAX_NAXES (10)
     51  off_t                   Naxis[FT_MAX_NAXES];
     52  off_t                   datasize;
    5353  int                     pcount;
    5454  int                     gcount;
    … …  
    6565  int                     bitpix;
    6666  int                     Naxes;
    67   int                     Naxis[FT_MAX_NAXES];
    68   int                     size;
     67  off_t                   Naxis[FT_MAX_NAXES];
     68  off_t                   datasize;
    6969  double                  bzero;
    7070  double                  bscale;
    … …  
    7676  Header                 *header;
    7777  char                   *buffer;
    78   int                     size;
     78  off_t                   datasize;
    7979} FTable;
    8080
    … …  
    8383  Header                 *header;
    8484  char                  **buffer;
    85   int                     Nrow;
    86   int                    *row;
    87   int                     size;  /* total buffer size */
    88   int                     pad;   /* bytes of padding at the end */
     85  off_t                   Nrow;
     86  off_t                  *row;
     87  off_t                   datasize;  /* total buffer size */
     88  off_t                   pad;   /* bytes of padding at the end */
    8989} VTable;
    9090
    9191typedef struct {
    92   int  maxlen;                // max size of all table rows
    93   int  nbytes;                // number of bytes per column element
    94   int  Nstart;                // byte offset of this column
    95   int  heap_start;            // byte offset to start of HEAP
    96   char format;                // data format character (one of: XLABIJEDCM)
     92  int   maxlen;               // max size of all table rows
     93  int   nbytes;               // number of bytes per column element
     94  int   Nstart;               // byte offset of this column relative to first column
     95  off_t heap_start;           // byte offset to start of HEAP
     96  char  format;               // data format character (one of: XLABIJEDCM)
     97  char  mode;                 // access data pointer type (one of P or Q)
    9798} VarLengthColumn;
    9899
    … …  
    106107
    107108char   *gfits_header_field             PROTO((Header *header, char *field, int N));
    108 char   *gfits_header_lineno            PROTO((Header *header, int N));
     109char   *gfits_header_lineno            PROTO((Header *header, off_t N));
    109110char   *gfits_keyword_end              PROTO((char *line));
    110111int     gfits_copy_header              PROTO((Header *in, Header *out));
    … …  
    128129int     gfits_vscan                    PROTO((Header *header, char *field, char *mode, int N, va_list argp));
    129130int     gfits_write_header             PROTO((char *filename, Header *header));
    130 int     gfits_data_size                PROTO((Header *header));
    131 int     gfits_data_min_size            PROTO((Header *header));
     131off_t   gfits_data_size                PROTO((Header *header));
     132off_t   gfits_data_min_size            PROTO((Header *header));
    132133int     gfits_extended_to_primary      PROTO((Header *header, int simple, char *comment));
    133134int     gfits_primary_to_extended      PROTO((Header *header, char *exttype, char *comment));
    … …  
    143144/******************************* Matrix functions *************/
    144145
    145 void    gfits_add_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     146void    gfits_add_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y, double value));
    146147int     gfits_convert_format           PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int inBlank, int outUnsign));
    147148int     gfits_copy_matrix              PROTO((Matrix *in, Matrix *out));
    … …  
    152153void    gfits_free_matrix              PROTO((Matrix *matrix));
    153154int     gfits_fwrite_matrix            PROTO((FILE *f, Matrix *matrix));     
    154 double  gfits_get_matrix_value         PROTO((Matrix *matrix, int x, int y));
    155 void    gfits_insert_array             PROTO((Matrix *matrix, Matrix *array, int x, int y));
     155double  gfits_get_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y));
     156void    gfits_insert_matrix            PROTO((Matrix *matrix, Matrix *array, off_t x, off_t y));
    156157int     gfits_load_matrix              PROTO((FILE *f, Matrix *matrix, Header *header));
    157158int     gfits_multiply_matrix          PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
    158159int     gfits_read_matrix              PROTO((char *filename, Matrix *matrix));     
    159160int     gfits_read_matrix_segment      PROTO((char *filename, Matrix *matrix, char *region));
    160 int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
    161 void    gfits_set_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     161int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, off_t Nskip, off_t Npix));
     162void    gfits_set_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y, double value));
    162163int     gfits_write_matrix             PROTO((char *filename, Matrix *matrix));
    163164int     gfits_uncompress_image         PROTO((Header *header, Matrix *matrix, FTable *ftable));
    … …  
    166167int     gfits_byteswap_zdata           PROTO((char *zdata, int Nzdata, int bitpix));
    167168int     gfits_extension_is_compressed  PROTO((Header *header));
    168 int     gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
     169off_t   gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
    169170int     gfits_uncompressed_data_pixsize PROTO((char *cmptype, int out_bitpix, char **optname, char **optvalue, int Noptions));
    170171int     gfits_vartable_heap_pixsize    PROTO((char format));
    … …  
    173174
    174175char   *gfits_table_print              PROTO((FTable *ftable,...));
    175 int     gfits_add_rows                 PROTO((FTable *ftable, char *data, int Nrow, int Nbytes));
     176int     gfits_add_rows                 PROTO((FTable *ftable, char *data, off_t Nrow, off_t Nbytes));
    176177int     gfits_bintable_format          PROTO((char *format, char *type, int *Nval, int *Nbytes));
    177178int     gfits_create_table             PROTO((Header *header, FTable *ftable));
    … …  
    181182int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
    182183int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable));
    183 int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, int start, int Nrows));
    184 int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, int Nrow, int *row));
    185 int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, int start, int Nrows));
     184int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, off_t start, off_t Nrows));
     185int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, off_t Nrow, off_t *row));
     186int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, off_t start, off_t Nrows));
    186187int     gfits_free_table               PROTO((FTable *ftable));
    187188int     gfits_free_vtable              PROTO((VTable *vtable));
    188189int     gfits_fwrite_table             PROTO((FILE *f, FTable *table));
    189190int     gfits_fwrite_vtable            PROTO((FILE *f, VTable *table));
    190 int     gfits_fwrite_ftable_range      PROTO((FILE *f, FTable *table, int start, int Nrows, int Ndisk, int Ntotal));
     191int     gfits_fwrite_ftable_range      PROTO((FILE *f, FTable *table, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal));
    191192int     gfits_get_bintable_column      PROTO((Header *header, FTable *table, char *label, void **data));
    192193int     gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
    193 void   *gfits_get_bintable_column_data PROTO((Header *header, FTable *table, char *label, char *type, int *Nrow, int *Ncol));
     194void   *gfits_get_bintable_column_data PROTO((Header *header, FTable *table, char *label, char *type, off_t *Nrow, int *Ncol));
    194195int     gfits_get_table_column         PROTO((Header *header, FTable *table, char *label, void **data));
    195196int     gfits_get_table_column_type    PROTO((Header *header, char *label, char *type));
    196197int     gfits_read_ftable              PROTO((char *filename, FTable *table, char *extname));
    197198int     gfits_read_table               PROTO((char *filename, FTable *ftable));
    198 int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
    199 int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
     199int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, off_t Nrow));
     200int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, off_t Nrow));
    200201int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...));
    201202int     gfits_table_format             PROTO((char *format, char *type, int *Nval, int *Nbytes));
    202203int     gfits_table_scale_data         PROTO((FTable *ftable));
    203204int     gfits_table_scale_storage      PROTO((FTable *ftable));
    204 int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, int start, int Nkeep));
    205 int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, int Nrow, int Nbytes));
    206 int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, int *row, int Nrow));
     205int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, off_t start, off_t Nkeep));
     206int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, off_t Nrow, off_t Nbytes));
     207int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, off_t *row, off_t Nrow));
    207208int     gfits_write_table              PROTO((char *filename, FTable *ftable));
    208209
    … …  
    215216
    216217int     gfits_varlength_column_define  PROTO((FTable *ftable, VarLengthColumn *def, int column));
    217 void   *gfits_varlength_column_pointer PROTO((FTable *ftable, VarLengthColumn *column, int row, int *length));
     218void   *gfits_varlength_column_pointer PROTO((FTable *ftable, VarLengthColumn *column, off_t row, off_t *length));
    218219
    219220#endif /* FITSIO */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_add_M.c

    r7054 r27295  
    33
    44/*********************** fits insert array ***********************************/
    5 void gfits_add_matrix (matrix, array, x, y)
    6 Matrix *matrix, *array;
    7 int x, y;
     5void gfits_add_matrix (Matrix *matrix, Matrix *array, off_t x, off_t y)
    86{
    97
    … …  
    1513  if ((x + array[0].Naxis[0] > matrix[0].Naxis[0]) ||
    1614      (y + array[0].Naxis[1] > matrix[0].Naxis[1])) {
    17     fprintf (stderr, "can't add array here: (%d,%d) - (%d,%d) vs (%d,%d)\n",
    18              x, y, x + array[0].Naxis[0], y + array[0].Naxis[1],
    19              matrix[0].Naxis[0], matrix[0].Naxis[1]);
     15    fprintf (stderr, "can't add array here: (%lld,%lld) - (%lld,%lld) vs (%lld,%lld)\n",
     16             (long long) x,
     17             (long long) y,
     18             (long long) x + array[0].Naxis[0],
     19             (long long) y + array[0].Naxis[1],
     20             (long long) matrix[0].Naxis[0],
     21             (long long) matrix[0].Naxis[1]);
    2022    return;
    2123  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_add_M_value.c

    r7054 r27295  
    33
    44/***************** fits add matrix value ***********************************/
    5 void gfits_add_matrix_value (matrix, x, y, Value)
    6 Matrix *matrix;
    7 int x, y;
    8 double Value;
     5void gfits_add_matrix_value (Matrix *matrix, off_t x, off_t y, double Value)
    96{
    107

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_compress_M.c

    r23724 r27295  
    3131int gfits_uncompress_image (Header *header, Matrix *matrix, FTable *ftable) {
    3232
    33   int i, j, status, zimage, zcol, Nzrows, Nout, Nzdata, max_tile_size;
     33  off_t Nzdata, Nzrows, zcol;
     34  int i, j, status, zimage, Nout, max_tile_size;
    3435  char cmptype[80];
    3536  char zaxis[10], naxis[10], key[10], word[81], exttype[81], checksum[81], datasum[81];
    … …  
    196197  if (!gfits_varlength_column_define (ftable, &zdef, zcol)) ESCAPE;
    197198  gfits_delete (header, "TFIELDS", 1);
    198   snprintf (key, 10, "TTYPE%d", zcol);
     199  snprintf (key, 10, "TTYPE%lld", (long long) zcol);
    199200  gfits_delete (header, key, 1);
    200   snprintf (key, 10, "TFORM%d", zcol);
     201  snprintf (key, 10, "TFORM%lld", (long long) zcol);
    201202  gfits_delete (header, key, 1);
    202203
    … …  
    236237  ALLOCATE (out, char, odata_pixsize*max_tile_size);
    237238
     239  off_t row;
     240
    238241  // uncompress the data
    239242  Nzrows = ftable->header->Naxis[1];
    240   for (i = 0; i < Nzrows; i++) {
     243  for (row = 0; row < Nzrows; row++) {
    241244
    242245    // expected output size for this tile
    243246    Nout = gfits_tile_size (matrix, otile, ztile);
    244247
    245     zdata = gfits_varlength_column_pointer (ftable, &zdef, i, &Nzdata);
     248    zdata = gfits_varlength_column_pointer (ftable, &zdef, row, &Nzdata);
    246249    if (!zdata) return (FALSE);
    247250
    … …  
    254257
    255258    // gfits_uncompress_data uncompresses from zdata to the temporary output buffer which must be allocated
     259    // XXX the tile must not be > 2GB
    256260    if (!gfits_uncompress_data ((char *)zdata, Nzdata, cmptype, optname, optvalue, Noptions, out, &Nout, odata_pixsize)) return (FALSE);
    257261
    … …  
    284288
    285289// true sizes of this tile (in pixels)
    286 int gfits_tile_size (Matrix *matrix, int *otile, int *ztile) {
    287 
    288   int i, Npixels, Ndimen;
     290off_t gfits_tile_size (Matrix *matrix, int *otile, int *ztile) {
     291
     292  off_t i, Npixels, Ndimen;
    289293
    290294  Npixels = 1;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_convert_format.c

    r20652 r27295  
    2424      *out = *in*A + B;                                 \
    2525    }                                                   \
    26   REALLOCATE (matrix[0].buffer, char, matrix[0].size);
     26  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);
    2727
    2828# define CONVERTSAME(MY_NAN)                    \
    … …  
    4141  inMode  *in;                                          \
    4242  outMode *out;                                         \
    43   REALLOCATE (matrix[0].buffer, char, matrix[0].size);  \
     43  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);      \
    4444  out = (outMode *)matrix[0].buffer + Npixels - 1;      \
    4545  in  = (inMode  *)matrix[0].buffer + Npixels - 1;      \
    … …  
    6262      *out = *in*A + B;                                 \
    6363    }                                                   \
    64   REALLOCATE (matrix[0].buffer, char, matrix[0].size);
     64  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);
    6565
    6666# define CONVERTSAME_FF(MY_NAN)                 \
    … …  
    7979  inMode  *in;                                          \
    8080  outMode *out;                                         \
    81   REALLOCATE (matrix[0].buffer, char, matrix[0].size);  \
     81  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);      \
    8282  out = (outMode *)matrix[0].buffer + Npixels - 1;      \
    8383  in  = (inMode  *)matrix[0].buffer + Npixels - 1;      \
    … …  
    106106    return (TRUE);
    107107
    108   matrix[0].bitpix = header[0].bitpix = outBitpix;
    109   matrix[0].bscale = header[0].bscale = outScale;
    110   matrix[0].bzero  = header[0].bzero  = outZero;
    111   matrix[0].unsign = header[0].unsign = outUnsign;
    112   matrix[0].size  = gfits_data_size (header);
     108  matrix[0].bitpix   = header[0].bitpix = outBitpix;
     109  matrix[0].bscale   = header[0].bscale = outScale;
     110  matrix[0].bzero    = header[0].bzero  = outZero;
     111  matrix[0].unsign   = header[0].unsign = outUnsign;
     112  matrix[0].datasize = gfits_data_size (header);
    113113  gfits_modify (header, "BITPIX", "%d", 1, outBitpix);
    114114  gfits_modify (header, "BSCALE", "%lf", 1, outScale);
    … …  
    426426  {
    427427    char *out;
    428     int Nextra;
     428    off_t Nextra;
    429429   
    430430    out = (char *)matrix[0].buffer;
    431     Nextra = matrix[0].size - nbytes;
     431    Nextra = matrix[0].datasize - nbytes;
    432432    bzero (&out[nbytes], Nextra);
    433433  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_copy_M.c

    r17903 r27295  
    77  int i;
    88
    9   matrix2[0].unsign = matrix1[0].unsign;
    10   matrix2[0].bitpix = matrix1[0].bitpix;
    11   matrix2[0].size   = matrix1[0].size;
    12   matrix2[0].bzero  = matrix1[0].bzero;
    13   matrix2[0].bscale = matrix1[0].bscale;
    14   matrix2[0].Naxes  = matrix1[0].Naxes;
     9  matrix2[0].unsign   = matrix1[0].unsign;
     10  matrix2[0].bitpix   = matrix1[0].bitpix;
     11  matrix2[0].datasize = matrix1[0].datasize;
     12  matrix2[0].bzero    = matrix1[0].bzero;
     13  matrix2[0].bscale   = matrix1[0].bscale;
     14  matrix2[0].Naxes    = matrix1[0].Naxes;
    1515  for (i = 0; i < FT_MAX_NAXES; i++)
    1616    matrix2[0].Naxis[i] = matrix1[0].Naxis[i];
    1717
    1818  if (matrix2[0].buffer != NULL) free (matrix2[0].buffer);
    19   ALLOCATE (matrix2[0].buffer, char, matrix2[0].size);
     19  ALLOCATE (matrix2[0].buffer, char, matrix2[0].datasize);
    2020 
    21   memcpy (matrix2[0].buffer, matrix1[0].buffer, matrix2[0].size);
     21  memcpy (matrix2[0].buffer, matrix1[0].buffer, matrix2[0].datasize);
    2222
    2323  return (TRUE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_create_M.c

    r17903 r27295  
    33
    44/*********************** fits create matrix *******************************/
    5 int gfits_create_matrix (header, matrix)
    6 Header *header;
    7 Matrix *matrix;
    8 {
     5int gfits_create_matrix (Header *header, Matrix *matrix) {
    96
    10   int i, Nbytes;
     7  int i;
     8  off_t Nbytes;
    119
    1210  matrix[0].bitpix = header[0].bitpix;
    … …  
    2018  Nbytes = gfits_data_size (header);
    2119  ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1));
    22   bzero (matrix[0].buffer, Nbytes);
     20  memset (matrix[0].buffer, 0, Nbytes);
    2321 
    24   matrix[0].size = Nbytes;
     22  matrix[0].datasize = Nbytes;
    2523  return (TRUE);
    2624

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_get_M_value.c

    r15487 r27295  
    33
    44/***************** fits get matrix value ***********************************/
    5 double gfits_get_matrix_value (Matrix *matrix, int x, int y) {
     5double gfits_get_matrix_value (Matrix *matrix, off_t x, off_t y) {
    66
    77  double value;
    … …  
    1111    return (0.0);
    1212  pixel = matrix[0].Naxis[0]*y + x;
    13   value = HUGE_VAL;
     13  value = NAN;
    1414
    1515  if (matrix[0].unsign) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_insert_M.c

    r15487 r27295  
    33
    44/*********************** fits insert array ***********************************/
    5 void gfits_insert_matrix (Matrix *matrix, Matrix *array, int x, int y) {
     5void gfits_insert_matrix (Matrix *matrix, Matrix *array, off_t x, off_t y) {
    66
    77  /* there is no check here to match BITPIX, BZERO, or BSCALE */
    88
    9   int i, start_m, Nbytes_m, Nbytes;
     9  int i;
     10  off_t start_m, Nbytes_m, Nbytes;
    1011
    1112  if ((x + array[0].Naxis[0] > matrix[0].Naxis[0]) ||
    1213      (y + array[0].Naxis[1] > matrix[0].Naxis[1])) {
    13     fprintf (stderr, "can't insert array here: (%d,%d) - (%d,%d) vs (%d,%d)\n",
    14              x, y, x + array[0].Naxis[0], y + array[0].Naxis[1],
    15              matrix[0].Naxis[0], matrix[0].Naxis[1]);
     14    fprintf (stderr, "can't insert array here: (%lld,%lld) - (%lld,%lld) vs (%lld,%lld)\n",
     15             (long long) x,
     16             (long long) y,
     17             (long long) x + array[0].Naxis[0],
     18             (long long) y + array[0].Naxis[1],
     19             (long long) matrix[0].Naxis[0],
     20             (long long) matrix[0].Naxis[1]);
    1621    return;
    1722  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_load_M.c

    r16139 r27295  
    1313int gfits_load_matrix (FILE *f, Matrix *matrix, Header *header) {
    1414
    15   int i, nbytes, Nbytes;
     15 
     16  off_t i, nbytes, Nbytes;
    1617
    1718  matrix[0].bitpix = header[0].bitpix;
    … …  
    2526  Nbytes = gfits_data_size (header);
    2627  ALLOCATE (matrix[0].buffer, char, Nbytes);
    27   matrix[0].size = Nbytes;
     28  matrix[0].datasize = Nbytes;
    2829
    2930  nbytes = fread (matrix[0].buffer, sizeof(char), Nbytes, f);
    … …  
    9495  }
    9596  if (nbytes != Nbytes) {  /* this is a FITS error, but often the image is OK */
    96     fprintf (stderr, "incomplete block in FITS file: (%d, %d)\n", nbytes, Nbytes);
     97    fprintf (stderr, "incomplete block in FITS file: (%lld, %lld)\n", (long long) nbytes, (long long) Nbytes);
    9798    return (TRUE);
    9899  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_matrix.c

    r15751 r27295  
    22# include <gfitsio.h>
    33
    4 int gfits_data_size (Header *header) {
     4off_t gfits_data_size (Header *header) {
    55 
    6   int i, Nrec, size;
     6  int i;
     7  off_t Nrec, size;
    78
    89  if (header[0].Naxes == 0) return (0);
    … …  
    2526}
    2627
    27 int gfits_data_min_size (Header *header) {
     28off_t gfits_data_min_size (Header *header) {
    2829 
    29   int i, size;
     30  int i;
     31  off_t size;
    3032
    3133  if (header[0].Naxes == 0) return (0);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_read_M.c

    r7054 r27295  
    1818  if (f == NULL) return (FALSE);
    1919
    20   fseek (f, header.size, 0);
     20  fseeko (f, header.datasize, 0);
    2121 
    2222  status = gfits_load_matrix (f, matrix, &header);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_read_portion.c

    r16139 r27295  
    99/*********************** fits read matrix ***********************************/
    1010/** the result of this function is a matrix with dimension Npix * 1 **/
    11 int gfits_read_portion (char *filename, Matrix *matrix, int Nskip, int Npix) {
     11int gfits_read_portion (char *filename, Matrix *matrix, off_t Nskip, off_t Npix) {
    1212
    1313  FILE *f;
    1414  Header header;
    15   int status, nbytes, Nbytes, Nrec;
     15  int status;
     16  off_t nbytes, Nbytes, Nrec;
    1617
    1718  status = gfits_read_header (filename, &header);
    … …  
    3738    Nbytes = FT_RECORD_SIZE * Nrec;
    3839  }
    39   matrix[0].size = Nbytes;
     40  matrix[0].datasize = Nbytes;
    4041  ALLOCATE (matrix[0].buffer, char, Nbytes);
    4142
    … …  
    4344  f = fopen (filename, "r");
    4445  if (f == NULL) return (FALSE);
    45   fseek (f, header.size + Nskip, SEEK_SET);
     46  fseeko (f, header.datasize + Nskip, SEEK_SET);
    4647  nbytes = fread (matrix[0].buffer, sizeof(char), Nbytes, f);
    4748  if (nbytes != Nbytes) {
    … …  
    5253
    5354# ifdef BYTE_SWAP 
    54  {
    55   int i, perpix;
    56   unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, ctmp;
     55  {
     56    off_t i;
     57    int perpix;
     58    unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, ctmp;
    5759
    58   perpix = abs(header.bitpix) / 8;
    59   if (perpix > 1) {
    60     byte0 = (unsigned char *) matrix[0].buffer;
    61     byte1 = (unsigned char *) matrix[0].buffer + 1;
    62     byte2 = (unsigned char *) matrix[0].buffer + 2;
    63     byte3 = (unsigned char *) matrix[0].buffer + 3;
    64     byte4 = (unsigned char *) matrix[0].buffer + 4;
    65     byte5 = (unsigned char *) matrix[0].buffer + 5;
    66     byte6 = (unsigned char *) matrix[0].buffer + 6;
    67     byte7 = (unsigned char *) matrix[0].buffer + 7;
    68     if (perpix == 2) {
    69       for (i = 0; i < nbytes; i+=2, byte0 += 2, byte1 += 2) {
    70         ctmp = *byte0;
    71         *byte0 = *byte1;
    72         *byte1 = ctmp;
     60    perpix = abs(header.bitpix) / 8;
     61    if (perpix > 1) {
     62      byte0 = (unsigned char *) matrix[0].buffer;
     63      byte1 = (unsigned char *) matrix[0].buffer + 1;
     64      byte2 = (unsigned char *) matrix[0].buffer + 2;
     65      byte3 = (unsigned char *) matrix[0].buffer + 3;
     66      byte4 = (unsigned char *) matrix[0].buffer + 4;
     67      byte5 = (unsigned char *) matrix[0].buffer + 5;
     68      byte6 = (unsigned char *) matrix[0].buffer + 6;
     69      byte7 = (unsigned char *) matrix[0].buffer + 7;
     70      if (perpix == 2) {
     71        for (i = 0; i < nbytes; i+=2, byte0 += 2, byte1 += 2) {
     72          ctmp = *byte0;
     73          *byte0 = *byte1;
     74          *byte1 = ctmp;
     75        }
    7376      }
    74     }
    75     if (perpix == 4) {
    76       for (i = 0; i < nbytes; i+=4, byte0 += 4, byte1 += 4, byte2 += 4, byte3 += 4) {
    77         ctmp = *byte0;
    78         *byte0 = *byte3;
    79         *byte3 = ctmp;
    80         ctmp = *byte1;
    81         *byte1 = *byte2;
    82         *byte2 = ctmp;
     77      if (perpix == 4) {
     78        for (i = 0; i < nbytes; i+=4, byte0 += 4, byte1 += 4, byte2 += 4, byte3 += 4) {
     79          ctmp = *byte0;
     80          *byte0 = *byte3;
     81          *byte3 = ctmp;
     82          ctmp = *byte1;
     83          *byte1 = *byte2;
     84          *byte2 = ctmp;
     85        }
    8386      }
    84     }
    85     if (perpix == 8) {
    86       for (i = 0; i < nbytes; i+=8, byte0 += 8, byte1 += 8, byte2 += 8, byte3 += 8, byte4 += 8, byte5 += 8, byte6 += 8, byte7 += 8) {
    87         ctmp = *byte0;
    88         *byte0 = *byte7;
    89         *byte7 = ctmp;
    90         ctmp = *byte1;
    91         *byte1 = *byte6;
    92         *byte6 = ctmp;
    93         ctmp = *byte1;
    94         *byte2 = *byte5;
    95         *byte5 = ctmp;
    96         ctmp = *byte1;
    97         *byte3 = *byte4;
    98         *byte4 = ctmp;
     87      if (perpix == 8) {
     88        for (i = 0; i < nbytes; i+=8, byte0 += 8, byte1 += 8, byte2 += 8, byte3 += 8, byte4 += 8, byte5 += 8, byte6 += 8, byte7 += 8) {
     89          ctmp = *byte0;
     90          *byte0 = *byte7;
     91          *byte7 = ctmp;
     92          ctmp = *byte1;
     93          *byte1 = *byte6;
     94          *byte6 = ctmp;
     95          ctmp = *byte1;
     96          *byte2 = *byte5;
     97          *byte5 = ctmp;
     98          ctmp = *byte1;
     99          *byte3 = *byte4;
     100          *byte4 = ctmp;
     101        }
    99102      }
    100103    }
    101104  }
    102  }
    103105# endif
    104106
    … …  
    106108
    107109  if (nbytes < Nbytes - 2880) {  /* this is a bad FITS error: image is not OK */
    108     fprintf (stderr, "error reading in matrix data from FITS file %s (%d < %d - 2880)\n", filename, nbytes, Nbytes);
     110    fprintf (stderr, "error reading in matrix data from FITS file %s (%lld < %lld - 2880)\n", filename, (long long) nbytes, (long long) Nbytes);
    109111    return (FALSE);
    110112  }
    111113  if (nbytes != Nbytes) {  /* this is a FITS error, but often the image is OK */
    112     fprintf (stderr, "incomplete block in %s: (%d, %d)\n", filename, nbytes, Nbytes);
     114    fprintf (stderr, "incomplete block in %s: (%lld, %lld)\n", filename, (long long) nbytes, (long long) Nbytes);
    113115    return (TRUE);
    114116  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_read_segment.c

    r16139 r27295  
    3636int gfits_fread_matrix_segment (FILE *f, Matrix *matrix, Header *header, char *region) {
    3737
    38   int status, i, nbytes, Nbytes, Nskip, NbytesData;
     38  int status;
     39  off_t i, nbytes, Nbytes, Nskip, NbytesData;
    3940  int wantaxis[FT_MAX_NAXES][2];
    4041  double tmp;
    … …  
    6566    matrix[0].Naxis[i] = wantaxis[i][1] - wantaxis[i][0];
    6667
    67   matrix[0].size = abs (matrix[0].bitpix) / 8;
     68  matrix[0].datasize = abs (matrix[0].bitpix) / 8;
    6869  for (i = 0; i < matrix[0].Naxes; i++)
    69     matrix[0].size *= matrix[0].Naxis[i];
     70    matrix[0].datasize *= matrix[0].Naxis[i];
    7071
    7172  Nskip = wantaxis[2][0]*matrix[0].Naxis[0]*matrix[0].Naxis[1]*abs(matrix[0].bitpix)/8;
    72   NbytesData = Nskip + matrix[0].size;
     73  NbytesData = Nskip + matrix[0].datasize;
    7374
    7475  if (NbytesData % FT_RECORD_SIZE)
    75     Nbytes = FT_RECORD_SIZE * ((int) (NbytesData / FT_RECORD_SIZE) + 1) - Nskip;
     76    Nbytes = FT_RECORD_SIZE * ((off_t) (NbytesData / FT_RECORD_SIZE) + 1) - Nskip;
    7677  else
    77     Nbytes = FT_RECORD_SIZE * ((int) (NbytesData / FT_RECORD_SIZE)) - Nskip;
     78    Nbytes = FT_RECORD_SIZE * ((off_t) (NbytesData / FT_RECORD_SIZE)) - Nskip;
    7879
    7980  ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1));
    … …  
    8687
    8788  /* currently only good for reading in full planes in 3-D */
    88   fseek (f, Nskip, SEEK_CUR);
     89  fseeko (f, Nskip, SEEK_CUR);
    8990  nbytes = fread (matrix[0].buffer, sizeof(char), Nbytes, f);
    9091  if (nbytes != Nbytes) {
    … …  
    9293  }
    9394
    94   matrix[0].size = Nbytes;
     95  matrix[0].datasize = Nbytes;
    9596
    9697# ifdef BYTE_SWAP 
    … …  
    147148
    148149  if (nbytes < Nbytes - 2880) {  /* this is a bad FITS error: image is not OK */
    149     fprintf (stderr, "error reading in matrix data from FITS file (%d < %d - 2880)\n", nbytes, Nbytes);
     150    fprintf (stderr, "error reading in matrix data from FITS file (%lld < %lld - 2880)\n", (long long) nbytes, (long long) Nbytes);
    150151    return (FALSE);
    151152  }
    152153  if (nbytes != Nbytes) {  /* this is a FITS error, but often the image is OK */
    153     fprintf (stderr, "incomplete block in FITS file: (%d, %d)\n", nbytes, Nbytes);
     154    fprintf (stderr, "incomplete block in FITS file: (%lld, %lld)\n", (long long) nbytes, (long long) Nbytes);
    154155    return (TRUE);
    155156  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_set_M_value.c

    r15487 r27295  
    33
    44/****************** fits set matrix value ***********************************/
    5 void gfits_set_matrix_value (Matrix *matrix, int x, int y, double Value) {
     5void gfits_set_matrix_value (Matrix *matrix, off_t x, off_t y, double Value) {
    66
    7   int pixel;
     7  off_t pixel;
    88  double value;
    99

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/matrix/F_write_M.c

    r16139 r27295  
    1111  if (f == NULL) return (FALSE);
    1212 
    13   fseek (f, 0, SEEK_END);  /* write matrix to end of file! */
     13  fseeko (f, 0LL, SEEK_END);  /* write matrix to end of file! */
    1414
    1515  status = gfits_fwrite_matrix (f, matrix);
    … …  
    2121int gfits_fwrite_matrix (FILE *f, Matrix *matrix) {
    2222
    23   int status, nbytes, Nbytes;
     23  int status;
     24  off_t nbytes, Nbytes;
    2425
    2526  status = TRUE;
    … …  
    2728  /* this is a bit dangerous: we are not realloc'ing the matrix.
    2829     if the size is wrong, it probably should simply pad the fwrite statement.
    29      better policy should be defined (ie, matrix.size always correct blocking?)
     30     better policy should be defined (ie, matrix.datasize always correct blocking?)
    3031  */
    3132
    32   if (matrix[0].size % FT_RECORD_SIZE)
    33     nbytes = FT_RECORD_SIZE * ((int) (matrix[0].size / FT_RECORD_SIZE) + 1);
     33  if (matrix[0].datasize % FT_RECORD_SIZE)
     34    nbytes = FT_RECORD_SIZE * ((off_t) (matrix[0].datasize / FT_RECORD_SIZE) + 1);
    3435  else
    35     nbytes = FT_RECORD_SIZE * ((int) (matrix[0].size / FT_RECORD_SIZE));
     36    nbytes = FT_RECORD_SIZE * ((off_t) (matrix[0].datasize / FT_RECORD_SIZE));
    3637
    3738  /* this is a bit cumbersome: swap all words, write out file, then swap back... */
    3839# ifdef BYTE_SWAP 
    3940  {
    40     int i;
     41    off_t i;
    4142    unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, tmp;
    4243    int perpix;
    … …  
    9697# ifdef BYTE_SWAP
    9798  {
    98     int i;
     99    off_t i;
    99100    unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, tmp;
    100101    int perpix;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_create_T.c

    r15487 r27295  
    55int gfits_create_table (Header *header, FTable *table) {
    66
    7   int Nbytes;
     7  off_t Nbytes;
    88  char type[80];
    99
    … …  
    1919    memset (table[0].buffer, 0, Nbytes);
    2020  }
    21   table[0].size = Nbytes;
     21  table[0].datasize = Nbytes;
    2222  return (TRUE);
    2323
    … …  
    2929int gfits_create_vtable (Header *header, VTable *table, int Nrow) {
    3030
    31   int i, Nx, Ny;
     31  off_t i, Nx, Ny;
    3232  char type[80];
    3333
    … …  
    3737  Nx = table[0].header[0].Naxis[0];
    3838  Ny = table[0].header[0].Naxis[0];
    39   table[0].size = gfits_data_size (header);
    40   table[0].pad = table[0].size - Nx*Ny;
     39  table[0].datasize = gfits_data_size (header);
     40  table[0].pad = table[0].datasize - Nx*Ny;
    4141 
    4242  table[0].Nrow = Nrow;
    4343  ALLOCATE (table[0].buffer, char *, MAX (Nrow, 1));
    44   ALLOCATE (table[0].row, int, MAX (Nrow, 1));
     44  ALLOCATE (table[0].row, off_t, MAX (Nrow, 1));
    4545  for (i = 0; i < Nrow; i++) {
    4646    ALLOCATE (table[0].buffer[i], char, Nx);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_create_TH.c

    r15487 r27295  
    1313  char axis[10];
    1414 
    15   header[0].size = NBYTES;
     15  header[0].datasize = NBYTES;
    1616
    1717  ALLOCATE (header[0].buffer, char, NBYTES);
    … …  
    2727  for (i = 0; i < header[0].Naxes; i++) {
    2828    sprintf (axis, "NAXIS%d", i + 1);
    29     gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
     29    gfits_modify (header,  axis, "%lld", 1, header[0].Naxis[i]);
    3030  }
    3131 

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_define_column.c

    r26384 r27295  
    55int gfits_define_bintable_column (Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero) {
    66
    7   int Nfields, Nbytes, Nval, Naxis1;
     7  off_t Naxis1;
     8  int Nfields, Nbytes, Nval;
    89  char type[16], field[16];
    910 
    … …  
    1213  Nfields = 0;
    1314  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    14   gfits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
     15  gfits_scan (header, "NAXIS1",  "%lld", 1, &Naxis1);
    1516  Nfields ++;
    1617  Naxis1 += Nbytes*Nval;
    … …  
    3435  /* update TFIELDS & NAXIS1 */
    3536  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
    36   gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     37  gfits_modify (header, "NAXIS1",  "%lld", 1, Naxis1);
    3738  header[0].Naxis[0] = Naxis1;
    3839
    … …  
    4344int gfits_define_table_column (Header *header, char *format, char *label, char *comment, char *unit) {
    4445
    45   int Nstart, Nfields, Nbytes, Nval, Naxis1;
     46  off_t Naxis1;
     47  int Nstart, Nfields, Nbytes, Nval;
    4648  char type[16], field[16], cformat[16];
    4749
    … …  
    5153  Nfields = 0;
    5254  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    53   gfits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
     55  gfits_scan (header, "NAXIS1",  "%lld", 1, &Naxis1);
    5456  Nstart = Naxis1 + 1;
    5557  Nfields ++;
    … …  
    6870
    6971  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
    70   gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     72  gfits_modify (header, "NAXIS1",  "%lld", 1, Naxis1);
    7173  header[0].Naxis[0] = Naxis1;
    7274

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_get_column.c

    r26384 r27295  
    1616  tmp = Pin[3]; Pin[3] = Pin[4]; Pin[4] = tmp; }
    1717
    18 void *gfits_get_bintable_column_data (Header *header, FTable *table, char *label, char *type, int *Nrow, int *Ncol) {
    19 
    20   int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
     18void *gfits_get_bintable_column_data (Header *header, FTable *table, char *label, char *type, off_t *Nrow, int *Ncol) {
     19
     20  off_t Nx, Ny;
     21  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    2122  char tlabel[80], field[80], format[80], tmpline[16];
    2223  char *Pin, *Pout, *array;
    … …  
    5051 
    5152  /* check existing table dimensions */
    52   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    53   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     53  gfits_scan (header, "NAXIS1",  "%lld", 1, &Nx);
     54  gfits_scan (header, "NAXIS2",  "%lld", 1, &Ny);
    5455
    5556  /* scan columns to find insert point */
    … …  
    153154int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) {
    154155
    155   int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
     156  off_t Nx, Ny;
     157  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    156158  char tlabel[80], field[80], format[80], type[16], tmpline[16];
    157159  char *Pin, *Pout, *array;
    … …  
    185187 
    186188  /* check existing table dimensions */
    187   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    188   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     189  gfits_scan (header, "NAXIS1",  "%lld", 1, &Nx);
     190  gfits_scan (header, "NAXIS2",  "%lld", 1, &Ny);
    189191
    190192  /* scan columns to find insert point */
    … …  
    307309int gfits_get_table_column (Header *header, FTable *table, char *label, void **data) {
    308310
    309   int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
     311  off_t Nx, Ny;
     312  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    310313  char tlabel[80], field[80], format[80], cformat[80], type[16], tmp[16];
    311314  char *array, *Pin, *Pout, *line;
    … …  
    333336 
    334337  /* check existing table dimensions */
    335   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    336   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     338  gfits_scan (header, "NAXIS1",  "%lld", 1, &Nx);
     339  gfits_scan (header, "NAXIS2",  "%lld", 1, &Ny);
    337340
    338341  /* scan columns to find insert point */

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_read_T.c

    r15751 r27295  
    1919int gfits_fread_ftable (FILE *f, FTable *table, char *extname) {
    2020
    21   int j, found, Nbytes;
     21  int j, found;
     22  off_t Nbytes;
    2223  Header *header;
    2324  char tname[80];
    2425
    2526  header = table[0].header;
    26   fseek (f, 0, SEEK_SET);
     27  fseeko (f, 0, SEEK_SET);
    2728
    2829  found = FALSE;
    … …  
    4243    /* skip to next header */
    4344    Nbytes = gfits_data_size (header);
    44     fseek (f, Nbytes, SEEK_CUR);
     45    fseeko (f, Nbytes, SEEK_CUR);
    4546    gfits_free_header (header);
    4647  }
    … …  
    5152int gfits_fread_ftable_data (FILE *f, FTable *table) {
    5253
    53   int Nbytes, Nread;
     54  off_t Nbytes, Nread;
    5455  char string[128];
    5556
    … …  
    6364    perror (string);
    6465    if (Nread < gfits_data_min_size (table[0].header)) {
    65       fprintf (stderr, "error: fits read error in %s, read %d, need %d\n", __func__, Nread, gfits_data_min_size (table[0].header));
     66      fprintf (stderr, "error: fits read error in %s, read %lld, need %lld\n", __func__, (long long) Nread, (long long) gfits_data_min_size (table[0].header));
    6667      gfits_free_table  (table);
    6768      return (FALSE);
    … …  
    6970    fprintf (stderr, "warning: file missing pad\n");
    7071  }
    71   table[0].size = Nbytes;
     72  table[0].datasize = Nbytes;
    7273  return (TRUE);
    7374}       
    7475
    7576/*********************** fits read ftable data ***********************************/
    76 int gfits_fread_ftable_range (FILE *f, FTable *table, int start, int Nrows) {
    77 
    78   int Nbytes, Nread, Nskip, Nx, Ny;
     77int gfits_fread_ftable_range (FILE *f, FTable *table, off_t start, off_t Nrows) {
     78
     79  off_t Nbytes, Nread, Nskip, Nx, Ny;
    7980
    8081  /* find disk table size */
    … …  
    9394  ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
    9495
    95   fseek (f, Nskip, SEEK_CUR);
     96  fseeko (f, Nskip, SEEK_CUR);
    9697
    9798  Nread = fread (table[0].buffer, sizeof (char), Nbytes, f);
    … …  
    108109  /* modify structure and header to match actual read rows Ny */
    109110  table[0].header[0].Naxis[1] = Nrows;
    110   gfits_modify (table[0].header, "NAXIS2",  "%d", 1, Nrows);
    111   table[0].size = gfits_data_size (table[0].header);
     111  gfits_modify (table[0].header, "NAXIS2",  "%lld", 1, Nrows);
     112  table[0].datasize = gfits_data_size (table[0].header);
    112113
    113114  return (TRUE);
    … …  
    115116
    116117/*********************** fits read ftable data ***********************************/
    117 int gfits_fread_vtable_range (FILE *f, VTable *table, int start, int Nrows) {
    118 
    119   int i, Nbytes, Nread, Nskip, Nx, Ny;
     118int gfits_fread_vtable_range (FILE *f, VTable *table, off_t start, off_t Nrows) {
     119
     120  off_t i, Nbytes, Nread, Nskip, Nx, Ny;
    120121  char *buffer;
    121122
    … …  
    123124  Nx = table[0].header[0].Naxis[0];
    124125  Ny = table[0].header[0].Naxis[1];
    125   table[0].size = gfits_data_size (table[0].header);
    126   table[0].pad = table[0].size - Nx*Ny;
     126  table[0].datasize = gfits_data_size (table[0].header);
     127  table[0].pad = table[0].datasize - Nx*Ny;
    127128
    128129  if (start < 0) return (FALSE);
    … …  
    133134  ALLOCATE (buffer, char, MAX (Nbytes, 1));
    134135
    135   fseek (f, Nskip, SEEK_CUR);
     136  fseeko (f, Nskip, SEEK_CUR);
    136137  Nread = fread (buffer, sizeof (char), Nbytes, f);
    137138  if (Nread != Nbytes) {
    … …  
    141142  }
    142143
    143   ALLOCATE (table[0].row, int, MAX (Nrows, 1));
     144  ALLOCATE (table[0].row, off_t, MAX (Nrows, 1));
    144145  ALLOCATE (table[0].buffer, char *, MAX (Nrows, 1));
    145146  for (i = 0; i < Nrows; i++) {
    … …  
    154155
    155156/*********************** fits read virtual table ***********************************/
    156 int gfits_fread_vtable (FILE *f, VTable *table, char *extname, int Nrow, int *row) {
    157 
    158   int i, j, Nbytes, Nread;
    159   int start, Nx, Ny, offset;
     157int gfits_fread_vtable (FILE *f, VTable *table, char *extname, off_t Nrow, off_t *row) {
     158
     159  off_t i, j;
     160  off_t Nbytes, Nread;
     161  off_t start, Nx, Ny, offset;
    160162  Header *header;
    161163  char tname[80];
    162164
    163165  header = table[0].header;
    164   fseek (f, 0, SEEK_SET);
     166  fseeko (f, 0, SEEK_SET);
    165167
    166168  for (j = -1; TRUE; j++) {
    … …  
    176178    if (strcmp (tname, extname)) {
    177179      /* skip to next header */
    178       fseek (f, Nbytes, SEEK_CUR);
     180      fseeko (f, Nbytes, SEEK_CUR);
    179181      gfits_free_header (header);
    180182      continue;
    … …  
    182184
    183185    /* file pointer is at beginning of desired table data */
    184     start = ftell (f);
    185     gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    186     gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     186    start = ftello (f);
     187    gfits_scan (header, "NAXIS1", "%lld", 1, &Nx);
     188    gfits_scan (header, "NAXIS2", "%lld", 1, &Ny);
    187189    for (i = 0; i < Nrow; i++) {
    188190      if (row[i] > Ny) { return (FALSE); }
    … …  
    193195      ALLOCATE (table[0].buffer[i], char, MAX (1, Nx));
    194196      offset = start + Nx*row[i];
    195       fseek (f, offset, SEEK_SET);
     197      fseeko (f, offset, SEEK_SET);
    196198      Nread = fread (table[0].buffer[i], sizeof (char), Nx, f);
    197199      if (Nread != Nx) {
    … …  
    202204
    203205    table[0].Nrow  = Nrow;
    204     ALLOCATE (table[0].row, int, MAX (1, Nrow));   
     206    ALLOCATE (table[0].row, off_t, MAX (1, Nrow));   
    205207    for (i = 0; i < Nrow; i++) table[0].row[i] = row[i];
    206     table[0].size  = gfits_data_size (table[0].header);
    207     table[0].pad    = table[0].size - Nx*Ny;
     208    table[0].datasize = gfits_data_size (table[0].header);
     209    table[0].pad      = table[0].datasize - Nx*Ny;
    208210    return (TRUE);
    209211  }
    … …  
    212214int gfits_fread_header_extname (FILE *f, Header *header, char *extname) {
    213215
    214   int Nbytes;
     216  off_t Nbytes;
    215217  char current[80];
    216218
    217   fseek (f, 0, SEEK_SET);
     219  fseeko (f, 0, SEEK_SET);
    218220  gfits_fread_header (f, header);
    219221
    … …  
    221223
    222224  Nbytes = gfits_data_size (header);
    223   fseek (f, Nbytes, SEEK_CUR);
     225  fseeko (f, Nbytes, SEEK_CUR);
    224226
    225227  while (gfits_fread_header (f, header)) {
    … …  
    227229    if (!strcmp (current, extname)) return (TRUE);
    228230    Nbytes = gfits_data_size (header);
    229     fseek (f, Nbytes, SEEK_CUR);
     231    fseeko (f, Nbytes, SEEK_CUR);
    230232  }
    231233  return (FALSE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_read_TH.c

    r15743 r27295  
    77  FILE *f;
    88  Header header;
    9   int status, Nbytes;
     9  int status;
     10  off_t Nbytes;
    1011 
    1112  status = gfits_read_header (filename, &header);
    … …  
    2324
    2425  Nbytes = gfits_data_size (&header);
    25   fseek (f, Nbytes, SEEK_SET);
     26  fseeko (f, Nbytes, SEEK_SET);
    2627  gfits_free_header (&header);
    2728
    … …  
    3637 
    3738  char *p;
    38   int i, done, status, Nbytes;
     39  int i, done, status;
     40  off_t Nbytes;
    3941 
    40   Theader[0].size = 0;
     42  Theader[0].datasize = 0;
    4143  done = FALSE;
    4244  ALLOCATE (Theader[0].buffer, char, 1);
    … …  
    4446  for (i = 0; !done; i++) {
    4547    REALLOCATE (Theader[0].buffer, char, (i + 1)*FT_RECORD_SIZE);
    46     Nbytes = fread (&Theader[0].buffer[i*FT_RECORD_SIZE],
    47                     sizeof(char), FT_RECORD_SIZE, f);
     48    Nbytes = fread (&Theader[0].buffer[i*FT_RECORD_SIZE], sizeof(char), FT_RECORD_SIZE, f);
    4849    if (Nbytes != FT_RECORD_SIZE) {
    4950      perror ("fits matrix read error");
    5051    }
    5152
    52     Theader[0].size += Nbytes;
    53     if (Nbytes != FT_RECORD_SIZE)
     53    Theader[0].datasize += Nbytes;
     54    if (Nbytes != FT_RECORD_SIZE) {
    5455      done = TRUE;
     56    }
    5557    p = gfits_header_field (Theader, "END", 1);
    5658    if (p != NULL)
    … …  
    6870  if (!status) return (FALSE);
    6971                                                           
    70   gfits_scan (Theader,  "NAXIS1", "%d", 1, &Theader[0].Naxis[0]);
    71   gfits_scan (Theader,  "NAXIS2", "%d", 1, &Theader[0].Naxis[1]);
    72   gfits_scan (Theader,  "NAXIS3", "%d", 1, &Theader[0].Naxis[2]);
    73   gfits_scan (Theader,  "NAXIS4", "%d", 1, &Theader[0].Naxis[3]);
    74   gfits_scan (Theader,  "NAXIS5", "%d", 1, &Theader[0].Naxis[4]);
    75   gfits_scan (Theader,  "NAXIS6", "%d", 1, &Theader[0].Naxis[5]);
    76   gfits_scan (Theader,  "NAXIS7", "%d", 1, &Theader[0].Naxis[6]);
    77   gfits_scan (Theader,  "NAXIS8", "%d", 1, &Theader[0].Naxis[7]);
    78   gfits_scan (Theader,  "NAXIS9", "%d", 1, &Theader[0].Naxis[8]);
    79   gfits_scan (Theader, "NAXIS10", "%d", 1, &Theader[0].Naxis[9]);
     72  gfits_scan (Theader,  "NAXIS1", "%lld", 1, &Theader[0].Naxis[0]);
     73  gfits_scan (Theader,  "NAXIS2", "%lld", 1, &Theader[0].Naxis[1]);
     74  gfits_scan (Theader,  "NAXIS3", "%lld", 1, &Theader[0].Naxis[2]);
     75  gfits_scan (Theader,  "NAXIS4", "%lld", 1, &Theader[0].Naxis[3]);
     76  gfits_scan (Theader,  "NAXIS5", "%lld", 1, &Theader[0].Naxis[4]);
     77  gfits_scan (Theader,  "NAXIS6", "%lld", 1, &Theader[0].Naxis[5]);
     78  gfits_scan (Theader,  "NAXIS7", "%lld", 1, &Theader[0].Naxis[6]);
     79  gfits_scan (Theader,  "NAXIS8", "%lld", 1, &Theader[0].Naxis[7]);
     80  gfits_scan (Theader,  "NAXIS9", "%lld", 1, &Theader[0].Naxis[8]);
     81  gfits_scan (Theader, "NAXIS10", "%lld", 1, &Theader[0].Naxis[9]);
    8082
    8183  return (TRUE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_set_column.c

    r16139 r27295  
    1616
    1717/***********************/
    18 int gfits_set_bintable_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
    19 
    20   int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb;
     18int gfits_set_bintable_column (Header *header, FTable *table, char *label, void *data, off_t Nrow) {
     19
     20  off_t Nx, Ny, nbytes;
     21  int i, N, Nfields;
     22  int Nval, Nbytes, Nstart, Nv, Nb;
    2123  char tlabel[80], field[80], format[80], type[16], tmpline[16];
    2224  char *Pin, *Pout, *array;
    … …  
    4749 
    4850  /* check existing table dimensions */
    49   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    50   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     51  gfits_scan (header, "NAXIS1", "%lld", 1, &Nx);
     52  gfits_scan (header, "NAXIS2", "%lld", 1, &Ny);
    5153  if (Ny == 0) {
    5254    Ny = Nrow;
    5355    header[0].Naxis[1] = Ny;
    54     gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     56    gfits_modify (header, "NAXIS2", "%lld", 1, Ny);
    5557
    5658    nbytes = gfits_data_size (header);
    5759    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    5860    bzero (table[0].buffer, nbytes);
    59     table[0].size = nbytes;
     61    table[0].datasize = nbytes;
    6062  }
    6163  if (Ny != Nrow) return (FALSE);
    … …  
    151153
    152154/***********************/
    153 int gfits_set_table_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
    154 
    155   int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb;
     155int gfits_set_table_column (Header *header, FTable *table, char *label, void *data, off_t Nrow) {
     156
     157  off_t Nx, Ny, nbytes;
     158  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    156159  char tlabel[80], field[80], format[80], cformat[80], type[16], tmp[16];
    157160  char *array, *Pin, *Pout, *line;
    … …  
    178181 
    179182  /* check existing table dimensions */
    180   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    181   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     183  gfits_scan (header, "NAXIS1", "%lld", 1, &Nx);
     184  gfits_scan (header, "NAXIS2", "%lld", 1, &Ny);
    182185  if (Ny == 0) {
    183186    Ny = Nrow;
    184187    header[0].Naxis[1] = Ny;
    185     gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     188    gfits_modify (header, "NAXIS2", "%lld", 1, Ny);
    186189
    187190    nbytes = gfits_data_size (header);
    188191    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    189192    bzero (table[0].buffer, nbytes);
    190     table[0].size = nbytes;
     193    table[0].datasize = nbytes;
    191194  }
    192195  if (Ny != Nrow) return (FALSE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_table_format.c

    r26384 r27295  
    33
    44/***********************/
     5// get the format of a table column
     6// Nval : number of joined columns
     7// Nbytes : width of column
    58int gfits_bintable_format (char *format, char *type, int *Nval, int *Nbytes) {
    69
    … …  
    119122
    120123/** extract a table subset to a vtable ***/
    121 int gfits_table_to_vtable (FTable *ftable, VTable *vtable, int start, int Nkeep) {
     124int gfits_table_to_vtable (FTable *ftable, VTable *vtable, off_t start, off_t Nkeep) {
    122125
    123126  /* gfits_table_to_vtable (f, v, 0, Ny - 1) - keep all of table
    … …  
    125128  */ 
    126129
    127   int i, Nx, Ny;
    128 
    129   gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
    130   gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
     130  off_t i, Nx, Ny;
     131
     132  gfits_scan (ftable[0].header, "NAXIS1", "%lld", 1, &Nx);
     133  gfits_scan (ftable[0].header, "NAXIS2", "%lld", 1, &Ny);
    131134 
    132135  if (start + Nkeep > Ny) return (FALSE);
    … …  
    134137  if (Nkeep < 0) return (FALSE);
    135138
    136   ALLOCATE (vtable[0].row, int, MAX (1, Nkeep));
     139  ALLOCATE (vtable[0].row, off_t, MAX (1, Nkeep));
    137140  ALLOCATE (vtable[0].buffer, char *, MAX (1, Nkeep));
    138141  for (i = 0; i < Nkeep; i++) {
    … …  
    143146 
    144147  vtable[0].header = ftable[0].header;
    145   vtable[0].size = ftable[0].size;
     148  vtable[0].datasize = ftable[0].datasize;
    146149  vtable[0].Nrow = Nkeep;
    147   vtable[0].pad = vtable[0].size - Nx*Ny;
     150  vtable[0].pad = vtable[0].datasize - Nx*Ny;
    148151
    149152  return (TRUE);
    … …  
    151154
    152155/** convert specified rows to vtable */
    153 int gfits_vtable_from_ftable (FTable *ftable, VTable *vtable, int *row, int Nrow) {
    154 
    155   int i, N, Nx, Ny;
    156 
    157   gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
    158   gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
     156int gfits_vtable_from_ftable (FTable *ftable, VTable *vtable, off_t *row, off_t Nrow) {
     157
     158  off_t i, N, Nx, Ny;
     159
     160  gfits_scan (ftable[0].header, "NAXIS1", "%lld", 1, &Nx);
     161  gfits_scan (ftable[0].header, "NAXIS2", "%lld", 1, &Ny);
    159162
    160163  /* make empty vtable from table */
    161   vtable[0].header = ftable[0].header;  /* make this a copy? */
    162   vtable[0].size   = ftable[0].size;
    163   vtable[0].pad    = vtable[0].size - Nx*Ny;
    164   vtable[0].Nrow   = Ny;
     164  vtable[0].header   = ftable[0].header;  /* make this a copy? */
     165  vtable[0].datasize = ftable[0].datasize;
     166  vtable[0].pad      = vtable[0].datasize - Nx*Ny;
     167  vtable[0].Nrow     = Ny;
    165168
    166169  /* insert selected rows in vtable (mask rows marked with -1) */
    167   ALLOCATE (vtable[0].row, int, Nrow);
     170  ALLOCATE (vtable[0].row, off_t, Nrow);
    168171  ALLOCATE (vtable[0].buffer, char *, Nrow);
    169172  for (N = i = 0; i < Nrow; i++) {
    … …  
    181184char *gfits_table_print (FTable *table,...) {
    182185 
    183   int i, Nx, Nfields;
    184   int off, Nchar, Nval, Nbytes;
     186  off_t Nx, off;
     187  int i, Nchar, Nval, Nbytes, Nfields;
    185188  char *line, format[64], field[16], type[16];
    186189  va_list argp;
    … …  
    188191  va_start (argp, table);
    189192
    190   gfits_scan (table[0].header, "NAXIS1",  "%d", 1, &Nx);
     193  gfits_scan (table[0].header, "NAXIS1",  "%lld", 1, &Nx);
    191194  gfits_scan (table[0].header, "TFIELDS", "%d", 1, &Nfields);
    192195
    … …  
    220223// apply table tzero, tscal in situ (from storage to data)
    221224int gfits_table_scale_data (FTable *ftable) {
    222 
    223   int i, j, n, Nx, Ny, Nfields;
    224   int off, Nchar, Nval, Nbytes, status;
     225 
     226  off_t Nx, Ny, off;
     227  int i, j, n, Nfields;
     228  int Nchar, Nval, Nbytes, status;
    225229  char format[64], field[16], type[16];
    226230  double tzero, tscale;
    … …  
    232236  off = 0;
    233237
    234   gfits_scan (ftable[0].header, "NAXIS1",  "%d", 1, &Nx);
    235   gfits_scan (ftable[0].header, "NAXIS2",  "%d", 1, &Ny);
     238  gfits_scan (ftable[0].header, "NAXIS1",  "%lld", 1, &Nx);
     239  gfits_scan (ftable[0].header, "NAXIS2",  "%lld", 1, &Ny);
    236240  gfits_scan (ftable[0].header, "TFIELDS", "%d", 1, &Nfields);
    237241
    … …  
    304308int gfits_table_scale_storage (FTable *ftable) {
    305309
    306   int i, j, n, Nx, Ny, Nfields;
    307   int off, Nchar, Nval, Nbytes, status;
     310  off_t Nx, Ny, off;
     311  int i, j, n, Nfields;
     312  int Nchar, Nval, Nbytes, status;
    308313  char format[64], field[16], type[16];
    309314  double tzero, tscale;
    … …  
    315320  off = 0;
    316321
    317   gfits_scan (ftable[0].header, "NAXIS1",  "%d", 1, &Nx);
    318   gfits_scan (ftable[0].header, "NAXIS2",  "%d", 1, &Ny);
     322  gfits_scan (ftable[0].header, "NAXIS1",  "%lld", 1, &Nx);
     323  gfits_scan (ftable[0].header, "NAXIS2",  "%lld", 1, &Ny);
    319324  gfits_scan (ftable[0].header, "TFIELDS", "%d", 1, &Nfields);
    320325

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_table_row.c

    r15487 r27295  
    33
    44/*********************** fits table column ****************************/
    5 int gfits_add_rows (FTable *table, char *data, int Nrow, int Nbytes) {
     5int gfits_add_rows (FTable *table, char *data, off_t Nrow, off_t Nbytes) {
    66
    7   int Nx, Ny;
    8   int nbytes, Nstart;
     7  off_t Nx, Ny;
     8  off_t nbytes, Nstart;
    99  Header *header;
    1010
    1111  header = table[0].header;
    1212
    13   gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    14   gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     13  gfits_scan (header, "NAXIS1", "%lld", 1, &Nx);
     14  gfits_scan (header, "NAXIS2", "%lld", 1, &Ny);
    1515 
    1616  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    2323  Ny += Nrow;
    2424  header[0].Naxis[1] = Ny;
    25   gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     25  gfits_modify (header, "NAXIS2",  "%lld", 1, Ny);
    2626
    2727  nbytes = gfits_data_size (header);
    2828  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    29   table[0].size = nbytes;
     29  table[0].datasize = nbytes;
    3030 
    3131  memcpy (&table[0].buffer[Nstart], data, Nbytes*Nrow);
    … …  
    3535
    3636/*********************** fits add (real) rows to virtual table ****************************/
    37 int gfits_vadd_rows (VTable *table, char *data, int Nrow, int Nbytes) {
     37int gfits_vadd_rows (VTable *table, char *data, off_t Nrow, off_t Nbytes) {
    3838
    39   int i, Nx, Ny;
    40   int Nstart;
     39  off_t i, Nx, Ny;
     40  off_t Nstart;
    4141  Header *header;
    4242
    4343  header = table[0].header;
    4444
    45   gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    46   gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     45  gfits_scan (header, "NAXIS1", "%lld", 1, &Nx);
     46  gfits_scan (header, "NAXIS2", "%lld", 1, &Ny);
    4747 
    4848  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    5454  table[0].Nrow += Nrow;
    5555  REALLOCATE (table[0].buffer, char *, table[0].Nrow);
    56   REALLOCATE (table[0].row, int, table[0].Nrow);
     56  REALLOCATE (table[0].row, off_t, table[0].Nrow);
    5757  for (i = 0; i < Nrow; i++) {
    5858    ALLOCATE (table[0].buffer[Nstart+i], char, MAX (1, Nx));
    … …  
    6464  Ny += Nrow;
    6565  header[0].Naxis[1] = Ny;
    66   gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     66  gfits_modify (header, "NAXIS2", "%lld", 1, Ny);
    6767
    68   table[0].size  = gfits_data_size (table[0].header);
    69   table[0].pad    = table[0].size - Nx*Ny;
     68  table[0].datasize = gfits_data_size (table[0].header);
     69  table[0].pad      = table[0].datasize - Nx*Ny;
    7070
    7171  return (TRUE);
    … …  
    7373
    7474/*********************** fits table column ****************************/
    75 int gfits_delete_rows (FTable *table, int Nstart, int Nrow) {
     75int gfits_delete_rows (FTable *table, off_t Nstart, off_t Nrow) {
    7676
    77   int Nx, Ny, N0, N1, N2;
    78   int nbytes;
     77  off_t Nx, Ny, N0, N1, N2;
     78  off_t nbytes;
    7979  Header *header;
    8080
    8181  header = table[0].header;
    8282
    83   gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    84   gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     83  gfits_scan (header, "NAXIS1", "%lld", 1, &Nx);
     84  gfits_scan (header, "NAXIS2", "%lld", 1, &Ny);
    8585 
    8686  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    9797  Ny -= Nrow;
    9898  header[0].Naxis[1] = Ny;
    99   gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     99  gfits_modify (header, "NAXIS2", "%lld", 1, Ny);
    100100
    101101  nbytes = gfits_data_size (header);
    102102  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    103   table[0].size = nbytes;
     103  table[0].datasize = nbytes;
    104104  return (TRUE);
    105105}

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_table_varlength.c

    r18264 r27295  
    44int gfits_varlength_column_define (FTable *ftable, VarLengthColumn *def, int column) {
    55
    6   int i, Nv, Nb;
     6  int i;
     7  int Nv, Nb;
    78  char *p1, *p2, *p3;
    89  char field[81];
    … …  
    3233  // now p1 must be 'P';
    3334  if (*p1 == 0) return (FALSE);
    34   if (*p1 != 'P') return (FALSE);
     35  if ((*p1 != 'P') && (*p1 != 'Q')) return (FALSE);
     36  def->mode = *p1;
    3537
    3638  // next value is the actual varlength column format
    … …  
    6163  }
    6264
    63   if (!gfits_scan (ftable->header, "THEAP", "%d", 1, &def->heap_start)) {
     65  // heap_start must be long long so file may be very large
     66  if (!gfits_scan (ftable->header, "THEAP", "%lld", 1, &def->heap_start)) {
    6467    def->heap_start = ftable->header->Naxis[0]*ftable->header->Naxis[1];
    6568  }
    … …  
    6871}
    6972
    70 void *gfits_varlength_column_pointer (FTable *ftable, VarLengthColumn *column, int row, int *length) {
     73// return the data and length for row 'row' of a variable length column
     74// is this capable of handling large files (value holding length and offset is an int)?
     75void *gfits_varlength_column_pointer (FTable *ftable, VarLengthColumn *column, off_t row, off_t *length) {
    7176
    7277  void *result;
    73   int offset, Nx, *ptr;
     78  off_t offset, Nx;
     79
     80  if ((column->mode != 'P') && (column->mode != 'Q')) abort();
    7481
    7582  // find the values for the specified row
    … …  
    8996# endif
    9097
    91   ptr = (int *) &ftable->buffer[row*Nx + column->Nstart];
    92   *length = ptr[0];
    93   offset = ptr[1];
     98  if (column->mode == 'P') {
     99    int *ptr;
     100    ptr = (int *) &ftable->buffer[row*Nx + column->Nstart];
     101    *length = ptr[0];
     102    offset = ptr[1];
     103  }
     104  if (column->mode == 'Q') {
     105    off_t *ptr;
     106    ptr = (off_t *) &ftable->buffer[row*Nx + column->Nstart];
     107    *length = ptr[0];
     108    offset = ptr[1];
     109  }
    94110
    95111  result = (void *) (ftable->buffer + column->heap_start + offset);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_write_T.c

    r15743 r27295  
    1313  if (f == (FILE *) NULL) return (FALSE);
    1414 
    15   status = fseek (f, 0, SEEK_END);  /* write table to end of file! */
     15  status = fseeko (f, 0LL, SEEK_END);  /* write table to end of file! */
    1616  status = gfits_fwrite_table (f, table);
    1717
    … …  
    2323int gfits_fwrite_table (FILE *f, FTable *table) {
    2424 
    25   int Nbytes;
     25  off_t Nbytes;
    2626 
    27   Nbytes = fwrite (table[0].buffer, sizeof(char), table[0].size, f);
     27  Nbytes = fwrite (table[0].buffer, sizeof(char), table[0].datasize, f);
    2828 
    29   if (Nbytes != table[0].size) return (FALSE);
     29  if (Nbytes != table[0].datasize) return (FALSE);
    3030  return (TRUE);
    3131}       
    … …  
    3434int gfits_fwrite_vtable (FILE *f, VTable *table) {
    3535 
    36   int i, Nx, Ny, Npad, offset, start;
    37   int Nbytes, *row, Nrow;
     36  off_t i, Nx, Ny, Npad, offset, start;
     37  off_t Nbytes, *row, Nrow;
    3838  char *pad;
    3939
    4040  Nrow = table[0].Nrow;
    4141  row = table[0].row;
    42   gfits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx);
    43   gfits_scan (table[0].header, "NAXIS2", "%d", 1, &Ny);
     42  gfits_scan (table[0].header, "NAXIS1", "%lld", 1, &Nx);
     43  gfits_scan (table[0].header, "NAXIS2", "%lld", 1, &Ny);
    4444
    4545  /* file pointer is at beginning of desired table data */
    46   start = ftell (f);
     46  start = ftello (f);
    4747 
    4848  for (i = 0; i < Nrow; i++) {
    4949    offset = start + Nx*row[i];
    50     fseek (f, offset, SEEK_SET);
     50    fseeko (f, offset, SEEK_SET);
    5151    Nbytes = fwrite (table[0].buffer[i], sizeof (char), Nx, f);
    5252    if (Nbytes != Nx) { return (FALSE); }
    5353  }
    5454 
    55   Npad = table[0].size - Nx*Ny;
     55  Npad = table[0].datasize - Nx*Ny;
    5656  ALLOCATE (pad, char, Npad);
    5757  bzero (pad, Npad);
    5858
    5959  offset = start + Nx*Ny;
    60   fseek (f, offset, SEEK_SET);
     60  fseeko (f, offset, SEEK_SET);
    6161  Nbytes = fwrite (pad, sizeof (char), Npad, f);
    6262  if (Nbytes != Npad) { return (FALSE); }
    … …  
    7171
    7272/*********************** fits read ftable data ***********************************/
    73 int gfits_fwrite_ftable_range (FILE *f, FTable *ftable, int start, int Nrows, int Ndisk, int Ntotal) {
     73int gfits_fwrite_ftable_range (FILE *f, FTable *ftable, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal) {
    7474
    75   int Nbytes, Nwrite, Nskip, Nx, Npad;
     75  off_t Nbytes, Nwrite, Nskip, Nx, Npad;
    7676  char *pad;
    7777
    … …  
    7979 
    8080  /* modify vtable to represent full disk table */
    81   gfits_modify (ftable[0].header, "NAXIS2", "%d", 1, Ntotal);
     81  gfits_modify (ftable[0].header, "NAXIS2", "%lld", 1, Ntotal);
    8282  ftable[0].header[0].Naxis[1] = Ntotal;
    8383
    8484  Nx = ftable[0].header[0].Naxis[0]; // final output table size on disk
    85   ftable[0].size = gfits_data_size (ftable[0].header);
     85  ftable[0].datasize = gfits_data_size (ftable[0].header);
    8686
    8787  Nskip = start * Nx;
    … …  
    9595
    9696  // cursor must be at start of the table (after table header)
    97   fseek (f, Nskip, SEEK_CUR);
     97  fseeko (f, Nskip, SEEK_CUR);
    9898  Nwrite = fwrite (ftable[0].buffer, sizeof (char), Nbytes, f);
    9999  if (Nwrite != Nbytes) {
    … …  
    102102
    103103  if (Ntotal >= Ndisk) {
    104     Npad = ftable[0].size - Nx*Ntotal;
     104    Npad = ftable[0].datasize - Nx*Ntotal;
    105105    ALLOCATE (pad, char, Npad);
    106106    bzero (pad, Npad);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libfits/table/F_write_TH.c

    r7054 r27295  
    1313  if (f == (FILE *) NULL) return (FALSE);
    1414 
    15   status = fseek (f, 0, SEEK_END);  /* write header to end of file! */
     15  status = fseeko (f, 0LL, SEEK_END);  /* write header to end of file! */
    1616  status = gfits_fwrite_Theader (f, header);
    1717
    … …  
    2323int gfits_fwrite_Theader (FILE *f, Header *header) {
    2424 
    25   int Nbytes;
     25  off_t Nbytes;
    2626 
    27   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].size, f);
     27  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    2828
    29   if (Nbytes != header[0].size) return (FALSE);
     29  if (Nbytes != header[0].datasize) return (FALSE);
    3030  return (TRUE);
    3131}       

  • branches/eam_branches/largefiles.20100314/Ohana/src/libohana/src/CommOps.c

    r26996 r27295  
    103103int SendMessageFixed (int device, int length, char *message) {
    104104
    105   int status;
    106105  int Nbytes, Nsent;
    107106  struct timespec request, remain;

  • branches/eam_branches/largefiles.20100314/Ohana/src/libohana/src/Fread.c

    r5851 r27295  
    11# include <ohana.h>
    22
    3 int   ByteSwap (char *ptr, int size, int nitems, char *type);
     3static int ByteSwap (char *ptr, off_t size, off_t nitems, char *type);
    44
    55# define BYTE_EXCHANGE(X,Y) tmp = byte[X]; byte[X] = byte[Y]; byte[Y] = tmp;
    … …  
    3030/* add other architectures here, ie dec, alpha, etc */
    3131
    32 int Fread (void *ptr, int size, int nitems, FILE *f, char *type) {
     32off_t Fread (void *ptr, off_t size, off_t nitems, FILE *f, char *type) {
    3333
    34   int valid, status;
     34  int valid;
     35  off_t status;
    3536
    3637  status = fread (ptr, size, nitems, f);
    … …  
    4243}
    4344
    44 int Fwrite (void *ptr, int size, int nitems, FILE *f, char *type) {
     45off_t Fwrite (void *ptr, off_t size, off_t nitems, FILE *f, char *type) {
    4546
    46   int valid, status;
     47  int valid;
     48  off_t status;
    4749
    4850  valid = ByteSwap (ptr, size, nitems, type);
    … …  
    5456}
    5557
    56 int ByteSwap (char *ptr, int size, int nitems, char *type) {
     58static int ByteSwap (char *ptr, off_t size, off_t nitems, char *type) {
    5759
    5860# ifdef BYTE_SWAP
    5961
    60   int i;
     62  off_t i;
    6163  unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, tmp;
    6264
    … …  
    116118  }
    117119
    118 # if (0) /** now in autocode **/
    119   if (!strcmp (type, "regimage")) {
    120     if (size != REGIMAGE_SIZE) {
    121       fprintf (stderr, "mismatch in type sizes (RegImage) %d vs %d\n", size, REGIMAGE_SIZE);
    122       return (FALSE);
    123     }
    124     byte = (unsigned char *)ptr;
    125     for (i = 0; i < nitems; i++, byte += REGIMAGE_SIZE) {
    126       SWAP_WORD (284); /* exptime */
    127       SWAP_WORD (288); /* airmass */
    128       SWAP_WORD (292); /* sky */     
    129       SWAP_WORD (296); /* bias */   
    130       SWAP_WORD (300); /* fwhm */   
    131       SWAP_WORD (304); /* telfocus */
    132       SWAP_WORD (308); /* xprobe */
    133       SWAP_WORD (312); /* yprobe */
    134       SWAP_WORD (316); /* zprobe */
    135       SWAP_WORD (320); /* dettemp */
    136       SWAP_WORD (324); /* teltemp[0] */
    137       SWAP_WORD (328); /* teltemp[1] */ 
    138       SWAP_WORD (332); /* teltemp[2] */
    139       SWAP_WORD (336); /* teltemp[3] */
    140       SWAP_WORD (340); /* rotangle */
    141       SWAP_WORD (344); /* ra */     
    142       SWAP_WORD (348); /* dec */     
    143       SWAP_WORD (352); /* obstime */
    144       SWAP_WORD (356); /* regtime */ 
    145     }
    146     return (TRUE);
    147   }
    148 
    149   if (!strcmp (type, "detreg")) {
    150     if (size != DETREG_SIZE) {
    151       fprintf (stderr, "mismatch in type sizes (DetReg) %d vs %d\n", size, DETREG_SIZE);
    152       return (FALSE);
    153     }
    154     byte = (unsigned char *)ptr;
    155     for (i = 0; i < nitems; i++, byte += DETREG_SIZE) {
    156       SWAP_WORD (0);   /* tstart */
    157       SWAP_WORD (4);   /* tstop */
    158       SWAP_WORD (8);   /* treg */
    159       SWAP_WORD (12);  /* exptime */
    160       SWAP_WORD (16);  /* type */
    161       SWAP_WORD (20);  /* filter */
    162       SWAP_WORD (24);  /* ccd */
    163       SWAP_WORD (28);  /* Nentry */
    164       SWAP_WORD (32);  /* Norder */
    165     }
    166     return (TRUE);
    167   }
    168 
    169   if (!strcmp (type, "photpars")) {
    170     if (size != PHOTPARS_SIZE) {
    171       fprintf (stderr, "mismatch in type sizes (PhotPars) %d vs %d\n", size, PHOTPARS_SIZE);
    172       return (FALSE);
    173     }
    174     byte = (unsigned char *)ptr;
    175     for (i = 0; i < nitems; i++, byte += PHOTPARS_SIZE) {
    176       SWAP_WORD (0);    /* ZP */
    177       SWAP_WORD (4);    /* ZPo */
    178       SWAP_WORD (8);    /* dZP */
    179       SWAP_WORD (12);   /* K */
    180       SWAP_WORD (16);   /* A */
    181       SWAP_WORD (20);   /* tstart */
    182       SWAP_WORD (24);   /* tstop */
    183       SWAP_BYTE (28);   /* c1 */
    184       SWAP_BYTE (30);   /* c2 */
    185       SWAP_BYTE (32);   /* photcode */
    186       SWAP_WORD (100);   /* Ntime */
    187       SWAP_WORD (104);   /* Nmeas */
    188     }
    189     return (TRUE);
    190   }
    191 
    192   if (!strcmp (type, "missing")) {
    193     if (size != MISSING_SIZE) {
    194       fprintf (stderr, "mismatch in type sizes (Missing) %d vs %d\n", size, MISSING_SIZE);
    195       return (FALSE);
    196     }
    197     byte0 = (unsigned char *)ptr;
    198     byte1 = (unsigned char *)ptr + 1;
    199     byte2 = (unsigned char *)ptr + 2;
    200     byte3 = (unsigned char *)ptr + 3;
    201     for (i = 0; i < nitems; i++, byte0 += 4, byte1 += 4, byte2 += 4, byte3 += 4) {
    202       tmp = *byte0;
    203       *byte0 = *byte3;
    204       *byte3 = tmp;
    205       tmp = *byte1;
    206       *byte1 = *byte2;
    207       *byte2 = tmp;
    208     }
    209     return (TRUE);
    210   }
    211 
    212   if (!strcmp (type, "secfilt")) {
    213     if (size != SECFILT_SIZE) {
    214       fprintf (stderr, "mismatch in type sizes (SecFilt) %d vs %d\n", size, SECFILT_SIZE);
    215       return (FALSE);
    216     }
    217     byte = (unsigned char *) ptr;
    218     for (i = 0; i < nitems; i++, byte += SECFILT_SIZE) {
    219       SWAP_BYTE (0);   /* M */
    220       SWAP_BYTE (2);   /* Xm */
    221       SWAP_BYTE (4);   /* dM */
    222     }
    223     return (TRUE);
    224   }
    225 
    226   if (!strcmp (type, "spectrum")) {
    227     if (size != SPECTRUM_SIZE) {
    228       fprintf (stderr, "mismatch in type sizes (Spectrum) %d vs %d\n", size, SPECTRUM_SIZE);
    229       return (FALSE);
    230     }
    231     byte = (unsigned char *)ptr;
    232     for (i = 0; i < nitems; i++, byte += SPECTRUM_SIZE) {
    233       SWAP_WORD (0);  /* ra */
    234       SWAP_WORD (4);  /* dec */
    235       SWAP_WORD (8);  /* exptime */
    236       SWAP_WORD (12); /* airmass */
    237       SWAP_WORD (16); /* Ws */
    238       SWAP_WORD (20); /* We */
    239       SWAP_WORD (24); /* dW */
    240       SWAP_WORD (28); /* Nspec */
    241       SWAP_WORD (32); /* obstime */
    242       SWAP_WORD (36); /* regtime */
    243     }
    244     return (TRUE);
    245   }
    246 
    247   if (!strcmp (type, "image")) {
    248     if (size != IMAGE_SIZE) {
    249       fprintf (stderr, "mismatch in type sizes (Image) %d vs %d\n", size, IMAGE_SIZE);
    250       return (FALSE);
    251     }
    252     byte = (unsigned char *)ptr;
    253     for (i = 0; i < nitems; i++, byte += IMAGE_SIZE) {
    254       SWAP_DBLE (0); /* coords.crval1 */
    255       SWAP_DBLE (8); /* coords.crval2 */
    256       for (j = 16; j < 104; j+=4) { /* coords.crpix, delt, pc_ij, polyterms[7][2] */
    257         SWAP_WORD (j);
    258       }
    259       SWAP_WORD (120); /* tzero */
    260       SWAP_WORD (124); /* nstar */
    261       for (j = 128; j < 146; j+=2) { /* sec z, NX, NY, apmifit, dapmifit, source, Mcal, dMcal, Xm */
    262         SWAP_BYTE (j);
    263       }
    264       SWAP_WORD (184); /* exptime */
    265       SWAP_WORD (210); /* order */
    266       /**** this (210) is an error! (don't fix, replaced with autocode) ****/
    267       for (j = 212; j < 240; j+=2) {
    268         SWAP_BYTE (j); /* Mx - Myyy */
    269       }
    270     }
    271     return (TRUE);
    272   }
    273 
    274 # if (PANSTARRS)
    275   if (!strcmp (type, "average")) {
    276     if (size != AVERAGE_SIZE) {
    277       fprintf (stderr, "mismatch in type sizes (Average) %d vs %d\n", size, AVERAGE_SIZE);
    278       return (FALSE);
    279     }
    280     byte = (unsigned char *)ptr;
    281     for (i = 0; i < nitems; i++, byte += AVERAGE_SIZE) {
    282       SWAP_DBLE (0);   /* R */
    283       SWAP_DBLE (8);   /* D */
    284       SWAP_BYTE (16);  /* M */
    285       SWAP_BYTE (18);  /* Nm */
    286       SWAP_BYTE (20);  /* Nn */
    287       SWAP_BYTE (22);  /* Xp */
    288       SWAP_BYTE (24);  /* Xm */
    289       SWAP_BYTE (26);  /* code */
    290       SWAP_WORD (28);  /* offset */
    291       SWAP_WORD (32);  /* missing */
    292       SWAP_BYTE (36);  /* dM */
    293       SWAP_BYTE (38);  /* Xg */
    294     }
    295     return (TRUE);
    296   }
    297   if (!strcmp (type, "measure")) {
    298     if (size != MEASURE_SIZE) {
    299       fprintf (stderr, "mismatch in type sizes (Measure) %d vs %d\n", size, MEASURE_SIZE);
    300       return (FALSE);
    301     }
    302     byte = (unsigned char *)ptr;
    303     for (i = 0; i < nitems; i++, byte += MEASURE_SIZE) {
    304       SWAP_BYTE (0);   /* dR */
    305       SWAP_BYTE (2);   /* dD */
    306       SWAP_BYTE (4);   /* M  */
    307       SWAP_BYTE (6);   /* Mcal */
    308       SWAP_BYTE (8);   /* Mgal */
    309       SWAP_BYTE (10);  /* Map  */
    310       SWAP_BYTE (12);  /* FWx */
    311       /* 14, 15, 16, 17 - char */
    312       SWAP_BYTE (18);  /* source */
    313       SWAP_WORD (20);  /* t */
    314       SWAP_WORD (24);  /* averef */
    315       SWAP_BYTE (28);  /* dt */
    316       SWAP_BYTE (30);  /* flags */
    317     }
    318     return (TRUE);
    319   }
    320 
    321 # endif /** PANSTARRS **/
    322 
    323 
    324 # if (ELIXIR)
    325   if (!strcmp (type, "average")) {
    326     if (size != AVERAGE_SIZE) {
    327       fprintf (stderr, "mismatch in type sizes (Average) %d vs %d\n", size, AVERAGE_SIZE);
    328       return (FALSE);
    329     }
    330     byte = (unsigned char *)ptr;
    331     for (i = 0; i < nitems; i++, byte += AVERAGE_SIZE) {
    332       SWAP_WORD (0);   /* R */
    333       SWAP_WORD (4);   /* D */
    334       SWAP_BYTE (8);   /* M */
    335       SWAP_BYTE (10);  /* Nm */
    336       SWAP_BYTE (12);  /* Nn */
    337       SWAP_BYTE (14);  /* Xp */
    338       SWAP_BYTE (16);  /* Xm */
    339       SWAP_BYTE (18);  /* code */
    340       SWAP_WORD (20);  /* offset */
    341       SWAP_WORD (24);  /* missing */
    342       SWAP_BYTE (28);  /* dM */
    343       SWAP_BYTE (30);  /* Xg */
    344     }
    345     return (TRUE);
    346   }
    347   if (!strcmp (type, "measure")) {
    348     if (size != MEASURE_SIZE) {
    349       fprintf (stderr, "mismatch in type sizes (Measure) %d vs %d\n", size, MEASURE_SIZE);
    350       return (FALSE);
    351     }
    352     byte = (unsigned char *)ptr;
    353     for (i = 0; i < nitems; i++, byte += MEASURE_SIZE) {
    354       SWAP_BYTE (0);   /* dR */
    355       SWAP_BYTE (2);   /* dD */
    356       SWAP_BYTE (4);   /* M  */
    357       SWAP_BYTE (6);   /* Mcal */
    358       SWAP_BYTE (8);   /* Mgal */
    359       SWAP_BYTE (10);  /* Map  */
    360       SWAP_BYTE (12);  /* FWx */
    361       /* 14, 15, 16, 17 - char */
    362       SWAP_BYTE (18);  /* source */
    363       SWAP_WORD (20);  /* t */
    364       SWAP_WORD (24);  /* averef */
    365       SWAP_BYTE (28);  /* dt */
    366       SWAP_BYTE (30);  /* flags */
    367     }
    368     return (TRUE);
    369   }
    370 
    371 # endif /** ELIXIR **/
    372 
    373 
    374 # if (LONEOS)
    375   if (!strcmp (type, "average")) {
    376     if (size != OLDAVERAGE_SIZE) {
    377       fprintf (stderr, "mismatch in type sizes (OldAverage) %d vs %d\n", size, OLDAVERAGE_SIZE);
    378       return (FALSE);
    379     }
    380     byte = (unsigned char *)ptr;
    381     for (i = 0; i < nitems; i++, byte += OLDAVERAGE_SIZE) {
    382       SWAP_WORD (0);   /* R */
    383       SWAP_WORD (4);   /* D */
    384       SWAP_BYTE (8);   /* M */
    385       SWAP_BYTE (10); /* Nm */
    386       SWAP_BYTE (12); /* Nn */
    387       SWAP_BYTE (14); /* Xp */
    388       SWAP_BYTE (16); /* Xm */
    389       SWAP_BYTE (18); /* code */
    390       SWAP_WORD (20); /* offset */
    391       SWAP_WORD (24); /* missing */
    392     }
    393     return (TRUE);
    394   }
    395   if (!strcmp (type, "measure")) {
    396     if (size != OLDMEASURE_SIZE) {
    397       fprintf (stderr, "mismatch in type sizes (OldMeasure) %d vs %d\n", size, OLDMEASURE_SIZE);
    398       return (FALSE);
    399     }
    400     byte = (unsigned char *)ptr;
    401     for (i = 0; i < nitems; i++, byte += OLDMEASURE_SIZE) {
    402       SWAP_BYTE (0);   /* dR */
    403       SWAP_BYTE (2);   /* dD */
    404       SWAP_BYTE (4);   /* M  */
    405       SWAP_BYTE (6);   /* Mcal */
    406       SWAP_BYTE (10);  /* source */
    407       SWAP_WORD (12);  /* t */
    408       SWAP_WORD (16);  /* average */
    409     }
    410     return (TRUE);
    411   }
    412 # endif /** LONEOS **/
    413 
    414 # if (0) /*** others ***/
    415   if (!strcmp (type, "oldsecfilt")) {
    416     if (size != OLDSECFILT_SIZE) {
    417       fprintf (stderr, "mismatch in type sizes (OldSecFilt) %d vs %d\n", size, OLDSECFILT_SIZE);
    418       return (FALSE);
    419     }
    420     byte = (unsigned char *) ptr;
    421     for (i = 0; i < nitems; i++, byte += OLDSECFILT_SIZE) {
    422       SWAP_BYTE (0);   /* M */
    423       SWAP_BYTE (2);   /* Xm */
    424     }
    425     return (TRUE);
    426   }
    427   if (!strcmp (type, "rufimage")) {
    428     if (size != RUFIMAGE_SIZE) {
    429       fprintf (stderr, "mismatch in type sizes (RufImage) %d vs %d\n", size, RUFIMAGE_SIZE);
    430       return (FALSE);
    431     }
    432     byte = (unsigned char *)ptr;
    433     for (i = 0; i < nitems; i++, byte += RUFIMAGE_SIZE) {
    434       SWAP_WORD (0);   /* sky */
    435       SWAP_WORD (4);   /* bias */
    436       SWAP_WORD (8);  /* fwhm */
    437       SWAP_WORD (12); /* exptime */
    438       SWAP_WORD (16); /* airmass */
    439       SWAP_WORD (20); /* obstime */
    440       SWAP_BYTE (24); /* ccdnum */
    441     }
    442     return (TRUE);
    443   }
    444   if (!strcmp (type, "olddetreg")) {
    445     if (size != OLDDETREG_SIZE) {
    446       fprintf (stderr, "mismatch in type sizes (DetReg) %d vs %d\n", size, OLDDETREG_SIZE);
    447       return (FALSE);
    448     }
    449     byte = (unsigned char *)ptr;
    450     for (i = 0; i < nitems; i++, byte += OLDDETREG_SIZE) {
    451       SWAP_WORD (0);   /* tstart */
    452       SWAP_WORD (4);   /* tstop */
    453       SWAP_WORD (8);   /* treg */
    454       SWAP_WORD (12);  /* sigma */
    455       SWAP_WORD (16);  /* clipsigma */
    456       SWAP_WORD (20);  /* type */
    457       SWAP_WORD (24);  /* filter */
    458       SWAP_WORD (28);  /* ccd */
    459     }
    460     return (TRUE);
    461   }
    462 # endif /** others **/
    463 # endif /** now in autocode **/
    464 
    465120  fprintf (stderr, "unknown type %s\n", type);
    466121  return (FALSE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/libohana/src/findexec.c

    r25757 r27295  
    391391
    392392/* fseek with timeout - 0.5 sec */
    393 int Fseek (FILE *f, long offset, int whence) {
     393int Fseek (FILE *f, off_t offset, int whence) {
    394394
    395395  int status, k;
    396396
    397   status = fseek (f, offset, whence);
     397  status = fseeko (f, offset, whence);
    398398  if (status == -1) {
    399     for (k = 0; (k < 10) && ((status = fseek (f, 0, SEEK_SET)) == -1); k++) usleep (50000);
     399    for (k = 0; (k < 10) && ((status = fseeko (f, 0, SEEK_SET)) == -1); k++) usleep (50000);
    400400    if (status == -1) {
    401       return (0);
    402     }
    403   }
    404   return (1);
    405 }
     401      return FALSE;
     402    }
     403  }
     404  return TRUE;
     405}

  • branches/eam_branches/largefiles.20100314/Ohana/src/libohana/src/glockfile.c

    r4717 r27295  
    117117  if (type == LCK_HARD) {
    118118    /* we've really got the lock, write BUSY to protect it */
    119     fseek (flock, 0, SEEK_SET);
     119    fseeko (flock, 0LL, SEEK_SET);
    120120    nbytes = fprintf (flock, "BUSY\n");
    121121
    … …  
    212212
    213213    /* set value to IDLE */
    214     fseek (flock, 0, SEEK_SET);
     214    fseeko (flock, 0LL, SEEK_SET);
    215215    nbytes = fprintf (flock, "IDLE\n");
    216216    if (nbytes != 5) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/lightcurve/src/fix_header.c

    r7080 r27295  
    77*/
    88
    9 void
    10   fix_header
    11   (Header     *header)
     9void fix_header (Header *header)
    1210{
    1311
    … …  
    1513  char *p1, *p2;
    1614
    17   Nbytes = 2880 * (int) (header[0].size / 2880 + 1);
     15  Nbytes = 2880 * (int) (header[0].datasize / 2880 + 1);
    1816  reallocate (header[0].buffer, char, Nbytes);
    19   bzero (&header[0].buffer[header[0].size], Nbytes - header[0].size - 1);
     17  bzero (&header[0].buffer[header[0].datasize], Nbytes - header[0].datasize - 1);
    2018
    2119  p1 = header[0].buffer - 1;
    … …  
    2422  while (p2 != NULL) {
    2523    if ((N = p2 - p1) != 80) {
    26       bcopy (p2, p1 + 80, header[0].size - (p2 - header[0].buffer));
     24      bcopy (p2, p1 + 80, header[0].datasize - (p2 - header[0].buffer));
    2725      for (i = 0; i < 80 - N; i++) {
    2826        *(p2 + i) = ' ';
    2927      }
    30       header[0].size += 80 - N;
     28      header[0].datasize += 80 - N;
    3129    }
    3230    p1 = strchr (p1 + 1, RETURN);
    … …  
    3432  }
    3533
    36   header[0].size = Nbytes;
     34  header[0].datasize = Nbytes;
    3735  p1 = gfits_header_field (header, "END", 1);
    3836  for (i = 3; i < 79; i++)
    … …  
    4038  *(p1 + 79) = RETURN;
    4139 
    42   Nbytes = header[0].size - (p1 - header[0].buffer) - 80;
     40  Nbytes = header[0].datasize - (p1 - header[0].buffer) - 80;
    4341 
    4442  for (i = 0; i < Nbytes; i++) {
    … …  
    4846  }
    4947
    50   Nbytes = header[0].size - (p1 - header[0].buffer) - 80;
     48  Nbytes = header[0].datasize - (p1 - header[0].buffer) - 80;
    5149  while (Nbytes >= 2880) {
    52     header[0].size -= 2880;
    53     Nbytes = header[0].size - (p1 - header[0].buffer) - 80;
     50    header[0].datasize -= 2880;
     51    Nbytes = header[0].datasize - (p1 - header[0].buffer) - 80;
    5452  }
    5553
    56   reallocate (header[0].buffer, char, header[0].size);
     54  reallocate (header[0].buffer, char, header[0].datasize);
    5755}
    5856

  • branches/eam_branches/largefiles.20100314/Ohana/src/markrock/src/find_bright_stars.c

    r16040 r27295  
    33void find_bright_stars (Catalog *catalog, CatStats *catstats) {
    44
    5   int i, j, n, m, first_j, Nave, Ngsc, Nmark;
     5  off_t i, j, n, m, first_j, Nave, Ngsc, Nmark;
    66  Catalog GSCdata;
    77  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    88  Coords *tcoords;
    99  double *X1, *Y1, *X2, *Y2;
    10   int *N1, *N2;
     10  off_t *N1, *N2;
    1111  char *mark;
    1212  double dX, dY, dR, MaxDist, MaxDist1, MaxRadius, radius, radius2;
    … …  
    2424  ALLOCATE (X1, double, Ngsc);
    2525  ALLOCATE (Y1, double, Ngsc);
    26   ALLOCATE (N1, int, Ngsc);
     26  ALLOCATE (N1, off_t, Ngsc);
    2727  ALLOCATE (mark, char, Nave);
    2828  bzero (mark, Nave);

  • branches/eam_branches/largefiles.20100314/Ohana/src/markrock/src/gcatstats.c

    r16040 r27295  
    66{
    77
    8   int i;
     8  off_t i;
    99  double RaCenter, DecCenter;
    1010  double MinRA, MaxRA, MinDEC, MaxDEC;
    1111  double *X1, *Y1;
    12   int *N1;
    1312  Coords tcoords;
    1413 
    … …  
    3130  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
    3231  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    33   ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
     32  ALLOCATE (catstats[0].N, off_t,   catalog[0].Naverage);
    3433
    3534  /* project onto rectilinear grid with 1 arcsec pixels, sort by X */

  • branches/eam_branches/largefiles.20100314/Ohana/src/markrock/src/wrocks.c

    r2490 r27295  
    1616  }
    1717  /* position to begining of file to write header */
    18   fseek (f, 0, SEEK_END);
     18  fseeko (f, 0, SEEK_END);
    1919
    2020  /* get statistics on rocks */

  • branches/eam_branches/largefiles.20100314/Ohana/src/markstar/src/find_bright_stars.c

    r16040 r27295  
    33void find_bright_stars (Catalog *catalog, CatStats *catstats) {
    44
    5   int i, j, n, m, first_j, Nave, Ngsc;
     5  off_t i, j, n, m, first_j, Nave, Ngsc;
    66  Catalog GSCdata;
    77  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    88  Coords *tcoords;
    99  double *X1, *Y1, *X2, *Y2;
    10   int *N1, *N2;
     10  off_t *N1, *N2;
    1111  char *mark;
    1212  double dX, dY, dR, MaxDist, MaxDist1, MaxRadius, radius, radius2;
    … …  
    2525  ALLOCATE (X1, double, Ngsc);
    2626  ALLOCATE (Y1, double, Ngsc);
    27   ALLOCATE (N1, int, Ngsc);
     27  ALLOCATE (N1, off_t, Ngsc);
    2828  ALLOCATE (mark, char, Nave);
    2929  bzero (mark, Nave);

  • branches/eam_branches/largefiles.20100314/Ohana/src/markstar/src/find_matches.c

    r16040 r27295  
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2;
     9  off_t *N1, *N2;
    1010  int Nstar, Nghost, Ng;
    1111  unsigned int flags;
    … …  
    2525  ALLOCATE (X1, double, Nghost);
    2626  ALLOCATE (Y1, double, Nghost);
    27   ALLOCATE (N1, int, Nghost);
     27  ALLOCATE (N1, off_t, Nghost);
    2828
    2929  /* project ghosts to the frame of the catalog */

  • branches/eam_branches/largefiles.20100314/Ohana/src/markstar/src/gcatstats.c

    r16040 r27295  
    33void gcatstats (Catalog *catalog, CatStats *catstats) {
    44
    5   int i;
     5  off_t i;
    66  double RaCenter, DecCenter;
    77  double MinRA, MaxRA, MinDEC, MaxDEC;
    88  double *X1, *Y1;
    9   int *N1;
    109  Coords tcoords;
    1110 
    … …  
    4140  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
    4241  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    43   ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
     42  ALLOCATE (catstats[0].N, off_t,  catalog[0].Naverage);
    4443
    4544  /* project onto rectilinear grid with 1 arcsec pixels, sort by X */

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/addastro.c

    r7080 r27295  
    66  /* USAGE: addastro (cmp) (ref) */
    77
    8   int i, j, nbytes, itmp, oldsize;
     8  off_t nbytes, oldsize;
     9  int i, j, itmp;
    910  double tmp;
    1011  Header header, refhead;
    … …  
    2223    exit (1);
    2324  }
    24   oldsize = header.size;
     25  oldsize = header.datasize;
    2526
    2627  if (!gfits_read_header (argv[2], &refhead)) {
    … …  
    7273    exit (1);
    7374  }
    74   nbytes = fwrite (header.buffer, 1, header.size, g);
    75   fseek (g, header.size, SEEK_SET);
     75  nbytes = fwrite (header.buffer, 1, header.datasize, g);
     76  fseeko (g, header.datasize, SEEK_SET);
    7677
    7778  /* read date from file */

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/applyscat.c

    r21537 r27295  
    1414  Matrix matrix;
    1515  Stars *stars;
    16   int Nstar, Nbytes, nbytes;
     16  int Nstar;
     17  off_t Nbytes, nbytes;
    1718  FILE *f;
    1819  char *buffer, line[10];
    … …  
    3738    exit (1);
    3839  }
    39   fseek (f, header.size, SEEK_SET);
     40  fseeko (f, header.datasize, SEEK_SET);
    4041
    4142  /* find expected number of stars */
    … …  
    110111    exit (1);
    111112  }
    112   fseek (f, header.size, SEEK_SET);
     113  fseeko (f, header.datasize, SEEK_SET);
    113114
    114115  /* load in data */

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/fakecmp.c

    r7080 r27295  
    44void main (int argc, char **argv) {
    55
    6   int i, j, N, status;
    7   int Nreserved, start_size;
     6  off_t start_size, status;
     7  int i, j, N;
     8  int Nreserved;
    89  char *p, keyword[16], line[256];
    910  FILE *f;
    … …  
    6970    exit (1);
    7071  }
    71   start_size = header.size;
     72  start_size = header.datasize;
    7273
    7374  /* run through the lines in the header data file */
    … …  
    9495    p = (char *) NULL;
    9596    Nreserved = strlen (reserved);
    96     for (i = 0; (i < header.size) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
     97    for (i = 0; (i < header.datasize) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
    9798      if (!strncmp (&header.buffer[i], reserved, Nreserved)) {
    9899        p = &header.buffer[i];
    … …  
    114115  */
    115116
    116   if (header.size != start_size) {
     117  if (header.datasize != start_size) {
    117118    fprintf (stderr, "header changed size: should not happen!\n");
    118119    exit (1);
    … …  
    125126  }
    126127
    127   fseek (f, 0, SEEK_SET);
    128   status = fwrite (header.buffer, 1, header.size, f);
    129   if (status != header.size) {
     128  fseeko (f, 0, SEEK_SET);
     129  status = fwrite (header.buffer, 1, header.datasize, f);
     130  if (status != header.datasize) {
    130131    fprintf (stderr, "failed to write data to image header\n");
    131132    exit (1);

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/fakestars.c

    r7080 r27295  
    5757    exit (1);
    5858  }
    59   fseek (f, header.size, SEEK_SET);
     59  fseeko (f, header.datasize, SEEK_SET);
    6060
    6161  /* find expected number of stars */
    … …  
    108108    exit (1);
    109109  }
    110   fseek (f, header.size, SEEK_SET);
     110  fseeko (f, header.datasize, SEEK_SET);
    111111
    112112  for (i = 0; i < Nstar; i++) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/fiximg.c

    r7080 r27295  
    3131  fprintf (stderr, "deleted %d comments\n", N);
    3232  p = gfits_header_field (&header, "END", 1);
    33   for (i = 3; i < header.size - (int) (p - header.buffer); i++) {
     33  for (i = 3; i < header.datasize - (int) (p - header.buffer); i++) {
    3434    p[i] = ' ';
    3535  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/fixsimple.c

    r7080 r27295  
    2626  fprintf (stderr, "deleted %d comments\n", N);
    2727  p = gfits_header_field (&header, "END", 1);
    28   for (i = 3; i < header.size - (int) (p - header.buffer); i++) {
     28  for (i = 3; i < header.datasize - (int) (p - header.buffer); i++) {
    2929    p[i] = ' ';
    3030  }
    … …  
    4747  }
    4848
    49   fseek (f, skip, SEEK_SET);
    50   status = fwrite (header.buffer, 1, header.size, f);
    51   if (status != header.size) {
     49  fseeko (f, skip, SEEK_SET);
     50  status = fwrite (header.buffer, 1, header.datasize, f);
     51  if (status != header.datasize) {
    5252    fprintf (stderr, "failed to write data to image header\n");
    5353    exit (1);

  • branches/eam_branches/largefiles.20100314/Ohana/src/misc/src/striphead.c

    r7080 r27295  
    5151    }
    5252   
    53     for (j = 79; j < header.size; j+= 80) {
     53    for (j = 79; j < header.datasize; j+= 80) {
    5454      header.buffer[j] = 10;
    5555    }

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/getusno.c

    r8499 r27295  
    1111StarData *getusno (CatStats *catstats, int *Nstars) {
    1212
    13   long int offset;
    14   int i, bin, first, last, nitems, Nitems, Nbins;
     13  off_t offset, nitems, Nitems;
     14  int i, bin, first, last, Nbins;
    1515  float hours[100];
    1616  int start[100], number[100], *buffer, *buf;
    … …  
    9191    /* advance file pointer to first slice */
    9292    offset = 3*sizeof(int)*(start[first] - 1);
    93     fseek (f, offset, SEEK_SET);
     93    fseeko (f, offset, SEEK_SET);
    9494    /* on each loop, load data from an RA slice of the catalog */
    9595    for (bin = first; bin < last; bin++) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/getusnob.c

    r8499 r27295  
    55StarData *getusnob (CatStats *catstats, int *Nstars) {
    66
    7   long int offset;
    8   int i, bin, first, last, nitems, Nitems, Nbins;
     7  off_t offset, nitems, Nitems;
     8  int i, bin, first, last, Nbins;
    99  float hours[100];
    1010  int start[100], number[100], *buffer, *buf;
    … …  
    7676    /* advance file pointer to first slice */
    7777    offset = NELEM*NBYTE*(start[first] - 1);
    78     fseek (f, offset, SEEK_SET);
     78    fseeko (f, offset, SEEK_SET);
    7979
    8080    /* sum the number of stars in data segment of interest */

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/match.c

    r16040 r27295  
    88  double dp, dq, radius, Radius;
    99  double *p, *q, *P, *Q;
    10   int *U, *u;
     10  off_t *U, *u;
    1111
    1212  /* requested radius is in arcsec ; internally radius is in pixels */
    … …  
    1717  ALLOCATE (P, double, Nrefcat);
    1818  ALLOCATE (Q, double, Nrefcat);
    19   ALLOCATE (U, int, Nrefcat);
     19  ALLOCATE (U, off_t, Nrefcat);
    2020  for (i = 0; i < Nrefcat; i++) {
    2121    U[i] = i;
    … …  
    3535    ALLOCATE (p, double, chip[i].Nstars);
    3636    ALLOCATE (q, double, chip[i].Nstars);
    37     ALLOCATE (u, int, chip[i].Nstars);
     37    ALLOCATE (u, off_t, chip[i].Nstars);
    3838    for (j = 0; j < chip[i].Nstars; j++) {
    3939      u[j] = j;

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/output.c

    r3466 r27295  
    4141  }
    4242
    43   fwrite (header[0].buffer, 1, header[0].size, f);
     43  fwrite (header[0].buffer, 1, header[0].datasize, f);
    4444  fclose (f);
    4545}

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/rfits.c

    r7080 r27295  
    1414    exit (1);
    1515  }
    16   fseek (f, mychip[0].header.size, SEEK_SET);
     16  fseeko (f, mychip[0].header.datasize, SEEK_SET);
    1717
    1818  /* init & load in table data */

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/rtext.c

    r7080 r27295  
    1212    return (FALSE);
    1313  }
    14   fseek (f, mychip[0].header.size, SEEK_SET);
     14  fseeko (f, mychip[0].header.datasize, SEEK_SET);
    1515
    1616  /* find expected number of stars */

  • branches/eam_branches/largefiles.20100314/Ohana/src/mosastro/src/wstars.c

    r3520 r27295  
    1616    }
    1717
    18     fwrite (data[0].header.buffer, 1, data[0].header.size, g);
     18    fwrite (data[0].header.buffer, 1, data[0].header.datasize, g);
    1919    fwrite (data[0].buffer, 1, data[0].Nbuffer, g);
    2020    fclose (g);
    … …  
    3434  }
    3535
    36   fwrite (header[0].buffer, 1, header[0].size, g);
     36  fwrite (header[0].buffer, 1, header[0].datasize, g);
    3737
    3838  for (i = 0; i < Nstars; i++) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/cmd.data/rd.c

    r20652 r27295  
    153153    buf[0].header.Naxes = 0;
    154154    ALLOCATE (buf[0].matrix.buffer, char, 1);
    155     buf[0].matrix.size = 0;
     155    buf[0].matrix.datasize = 0;
    156156    buf[0].bitpix = 16;
    157157    buf[0].bzero = 0;
    … …  
    222222  buf[0].unsign = buf[0].header.unsign;
    223223
    224   gprint (GP_LOG, "read %d bytes from %s into buffer %s\n",
    225            buf[0].header.size + buf[0].matrix.size, argv[2], argv[1]);
     224  gprint (GP_LOG, "read %lld bytes from %s into buffer %s\n",
     225           buf[0].header.datasize + buf[0].matrix.datasize, argv[2], argv[1]);
    226226
    227227  blank = 0xffff;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/cmd.data/rdseg.c

    r20652 r27295  
    6262  buf[0].bzero  = buf[0].header.bzero;     /* store the original values */
    6363  buf[0].unsign = buf[0].header.unsign;
    64   gprint (GP_LOG, "read %d bytes from %s into buffer %s\n",
    65            buf[0].header.size + buf[0].matrix.size, argv[2], argv[1]);
     64  gprint (GP_LOG, "read %d bytes from %s into buffer %s\n", buf[0].header.datasize + buf[0].matrix.datasize, argv[2], argv[1]);
    6665
    6766  gfits_scan (&buf[0].header, "BLANK", "%d", 1, &blank);

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/cmd.data/read_vectors.c

    r20936 r27295  
    5757    return (FALSE);
    5858  }
    59   fseek (f, 0, SEEK_SET);
     59  fseeko (f, 0LL, SEEK_SET);
    6060
    6161  Nvec = (argc - 1) / 2;
    … …  
    159159int read_table_vectors (int argc, char **argv, char *extname) {
    160160
    161   int i, j, k, N, Nbytes, Nextend, Ny, Binary, vecType;
     161  off_t Nbytes;
     162  int i, j, k, N, Nextend, Ny, Binary, vecType;
    162163  char type[16], ID[80], *CCDKeyword;
    163164  FTable table;
    … …  
    184185
    185186  if (f == NULL) ESCAPE ("file not found");
    186   fseek (f, 0, SEEK_SET);
     187  fseeko (f, 0LL, SEEK_SET);
    187188  table.header = &header;
    188189
    … …  
    193194    if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file");
    194195    Nbytes = gfits_data_size (&header);
    195     fseek (f, Nbytes, SEEK_CUR);
     196    fseeko (f, Nbytes, SEEK_CUR);
    196197    gfits_free_header (&header);
    197198
    … …  
    200201      Nbytes = gfits_data_size (&header);
    201202      /* skip the prior data buffers */
    202       fseek (f, Nbytes, SEEK_CUR);
     203      fseeko (f, Nbytes, SEEK_CUR);
    203204      gfits_free_header (&header);
    204205    }
    … …  
    215216
    216217    while (1) {
    217       if (!gfits_load_header (f, &header)) ESCAPE ("extensio not found in file");
     218      if (!gfits_load_header (f, &header)) ESCAPE ("extension not found in file");
    218219      Nbytes = gfits_data_size (&header);
    219220
    220221      if (!gfits_scan (&header, CCDKeyword, "%s", 1, ID)) {
    221         fseek (f, Nbytes, SEEK_CUR);
     222        fseeko (f, Nbytes, SEEK_CUR);
    222223        gfits_free_header (&header);
    223224        continue;
    224225      }
    225226      if (strcmp (ID, extname)) {
    226         fseek (f, Nbytes, SEEK_CUR);
     227        fseeko (f, Nbytes, SEEK_CUR);
    227228        gfits_free_header (&header);
    228229        continue;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/cmd.data/wd.c

    r20652 r27295  
    7575  /* save the (float) version, write out a temporary buffer */
    7676  temp_matrix = buf[0].matrix;
    77   ALLOCATE (temp_matrix.buffer, char, MAX(1, temp_matrix.size));
    78   memcpy (temp_matrix.buffer, buf[0].matrix.buffer, temp_matrix.size);
     77  ALLOCATE (temp_matrix.buffer, char, MAX(1, temp_matrix.datasize));
     78  memcpy (temp_matrix.buffer, buf[0].matrix.buffer, temp_matrix.datasize);
    7979  temp_header = buf[0].header;
    80   ALLOCATE (temp_header.buffer, char, MAX(1, temp_header.size));
    81   memcpy (temp_header.buffer, buf[0].header.buffer, temp_header.size);
     80  ALLOCATE (temp_header.buffer, char, MAX(1, temp_header.datasize));
     81  memcpy (temp_header.buffer, buf[0].header.buffer, temp_header.datasize);
    8282
    8383  if (temp_header.Naxes) {
    … …  
    9494    Header Xhead;
    9595    FILE *f;
     96    off_t nbytes;
    9697    int status, Nextend;
    9798
    … …  
    125126   
    126127    /* position to begining of file to write header */
    127     fseek (f, 0, SEEK_SET);
    128     status = fwrite (Xhead.buffer, 1, Xhead.size, f);
    129     if (status != Xhead.size) {
     128    fseeko (f, 0LL, SEEK_SET);
     129    nbytes = fwrite (Xhead.buffer, 1, Xhead.datasize, f);
     130    if (nbytes != Xhead.datasize) {
    130131      gprint (GP_ERR, "ERROR: failed writing data to image header\n");
    131132      status = FALSE;
    … …  
    144145
    145146    /* position to end of file to write new extend */
    146     fseek (f, 0, SEEK_END);
    147     status = fwrite (temp_header.buffer, 1, temp_header.size, f);
     147    fseeko (f, 0LL, SEEK_END);
     148    nbytes = fwrite (temp_header.buffer, 1, temp_header.datasize, f);
    148149    fclose (f);
    149     if (status != temp_header.size) {
     150    if (nbytes != temp_header.datasize) {
    150151      gprint (GP_ERR, "failed to write file\n");
    151152      status = FALSE;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/aregion.c

    r19823 r27295  
    4444    NLINES += NDecLines[i];
    4545  }
    46   fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     46  fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    4747     
    4848  done = FALSE;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/cmpload.c

    r13479 r27295  
    5656    return (FALSE);
    5757  }
    58   fseek (f, header.size, SEEK_SET);
     58  fseeko (f, header.datasize, SEEK_SET);
    5959
    6060  Noverlay = 0;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/cmpread.c

    r20936 r27295  
    66int cmpread (int argc, char **argv) {
    77 
    8   int i, field, Naxis, Nbytes, Nstars;
     8  off_t Nbytes;
     9  int i, field, Naxis, Nstars;
    910  double tR, tD;
    1011  float value;
    … …  
    6162    return (FALSE);
    6263  }
    63   fseek (f, header.size, SEEK_SET);
     64  fseeko (f, header.datasize, SEEK_SET);
    6465
    6566  /* find expected number of stars */
    … …  
    8485    gprint (GP_ERR, "reading from FITS cmp file %s\n", argv[2]);
    8586    Nbytes = gfits_data_size (&header);
    86     fseek (f, Nbytes, SEEK_CUR);
     87    fseeko (f, Nbytes, SEEK_CUR);
    8788    stars = cmpReadFits (f, &Nstars);
    8889  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/detrend.c

    r20936 r27295  
    133133    return (FALSE);
    134134  }
    135   fseek (f, header.size, SEEK_SET);
     135  fseeko (f, header.datasize, SEEK_SET);
    136136
    137137  /* load existing data from database */

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/elixir.c

    r7917 r27295  
    7373
    7474  /* write message to end of file */
    75   fseek (f, 0, SEEK_END);
     75  fseeko (f, 0LL, SEEK_END);
    7676  fprintf (f, "%s\n", message);
    7777

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/find_regions.c

    r19823 r27295  
    1313  double RA0, RA1, DEC0, DEC1;
    1414  int i, j, NBigDec;
    15   int NLINES, done, NREGIONS, nregion;
     15  int done, NREGIONS, nregion;
     16  off_t NLINES;
    1617 
    1718  VarConfig ("GSCFILE", "%s", filename);
    … …  
    9192    NLINES += NDecLines[i];
    9293  }
    93   fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     94  fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    9495 
    9596  /* should be in this section.  if not, there is a problem counting... */
    … …  
    140141        NLINES += NDecLines[i];
    141142      }
    142       fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     143      fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    143144      done = FALSE;
    144145      j = 12;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/gstar.c

    r23664 r27295  
    1111  double Mcat, Mrel;
    1212  double *RA, *DEC;
    13   int i, j, k, m, N, *N1, Nsecfilt, NPTS, QUIET, FULL_OUTPUT, INST;
    14   int Nstars, found, GetMeasures, Nlo, Nhi;
     13  off_t i, Nstars, *N1;
     14  int j, k, m, N, Nsecfilt, NPTS, QUIET, FULL_OUTPUT, INST;
     15  int found, GetMeasures, Nlo, Nhi;
    1516  int SaveVectors;
    1617  Vector *vec1, *vec2, *vec3, *vec4, *vec5, *vec6;
    … …  
    102103  ALLOCATE (RA, double, Nstars);
    103104  ALLOCATE (DEC, double, Nstars);
    104   ALLOCATE (N1, int, Nstars);
     105  ALLOCATE (N1, off_t, Nstars);
    105106
    106107  /* find star(s) in RA, DEC list -- use a dumb algorithm for now, improve later */

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/imbox.c

    r25757 r27295  
    11# include "dvoshell.h"
    22
     3// LARGEFILES: this function is currently limited to images with Nx,Ny each < 2^31
    34int imbox (int argc, char **argv) {
    45 
    5   int j, kapa, Nskip, status, InPic, flipped, N, haveNx, haveNy, Nx, Ny, SOLO_PHU, Npts, NPTS;
     6  off_t Nskip;
     7  int j, kapa, status, InPic, flipped, N, haveNx, haveNy, Nx, Ny, SOLO_PHU, Npts, NPTS;
    68  Vector Xvec, Yvec;
    79  double r, d, x[4], y[4], Rmin, Rmax, Rmid;
    … …  
    112114  skip:
    113115    Nskip = gfits_data_size (&header);
    114     fseek (f, Nskip, SEEK_CUR);
     116    fseeko (f, Nskip, SEEK_CUR);
    115117    gfits_free_header (&header);
    116118  }

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/imrough.c

    r20936 r27295  
    262262  if (!strcmp (line, "MDM Observatory")) {
    263263
    264     fseek (f, header.size, SEEK_SET);
     264    fseeko (f, header.datasize, SEEK_SET);
    265265   
    266266    /* load existing data from database */

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/imsearch.c

    r14590 r27295  
    77  Header header;
    88  RegImage *pimage;
    9   int i, Nimage, status, N, TimeSelect, SaveNames;
     9  off_t i, Nimage, status;
     10  int N, TimeSelect, SaveNames;
    1011  int ModeSelect, TypeSelect, CCDSelect, FilterSelect;
    1112  char *Filter, *obstime;
    … …  
    102103    return (FALSE);
    103104  }
    104   fseek (f, header.size, SEEK_SET);
     105  fseeko (f, header.datasize, SEEK_SET);
    105106
    106107  /* load existing data from database */
    107   gfits_scan (&header, "NIMAGES", "%d", 1, &Nimage);
     108  gfits_scan (&header, "NIMAGES", "%lld", 1, &Nimage);
    108109  ALLOCATE (pimage, RegImage, Nimage);
    109110  status = fread (pimage, sizeof(RegImage), Nimage, f);
    110111  fclose (f);
    111112  if (status != Nimage) {
    112     gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     113    gprint (GP_ERR, "ERROR: header and data in dB don't match (%lld vs %lld)\n", (long long) Nimage, (long long) status);
    113114    gfits_free_header (&header);
    114115    free (pimage);

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/lcurve.c

    r20936 r27295  
    77  double *RA, *DEC;
    88  int kapa, TimeFormat;
    9   int Nstars, found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
    10   int i, j, m, N, NPTS, *N1;
     9  int found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
     10  off_t i, Nstars, *N1;
     11  int j, m, N, NPTS;
    1112  time_t TimeReference;
    1213  struct tm *timeptr;
    … …  
    8889  ALLOCATE (RA, double, Nstars);
    8990  ALLOCATE (DEC, double, Nstars);
    90   ALLOCATE (N1, int, Nstars);
     91  ALLOCATE (N1, off_t, Nstars);
    9192
    9293  /* find star(s) in RA, DEC list -- use a dumb algorithm for now, improve later */

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/lightcurve.c

    r20936 r27295  
    55  double Ra, Dec, Radius, Radius2, r;
    66  double *RA, *DEC;
    7   int Nstars, found, PhotCodeSelect;
    8   int i, j, k, m, N, NPTS, Nsecfilt, RELPHOT, *N1, TimeFormat;
     7  off_t i, Nstars, *N1;
     8  int found, PhotCodeSelect;
     9  int j, k, m, N, NPTS, Nsecfilt, RELPHOT, TimeFormat;
    910  time_t TimeReference;
    1011
    … …  
    7172  ALLOCATE (RA, double, Nstars);
    7273  ALLOCATE (DEC, double, Nstars);
    73   ALLOCATE (N1, int, Nstars);
     74  ALLOCATE (N1, off_t, Nstars);
    7475
    7576  /* find star(s) in RA, DEC list -- use a dumb algorithm for now, improve later */

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/simage.c

    r20936 r27295  
    8989    return (FALSE);
    9090  }
    91   fseek (f, header.size, SEEK_SET);
     91  fseeko (f, header.datasize, SEEK_SET);
    9292
    9393  /* set up storage buffers */

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/dvo/subpix.c

    r19823 r27295  
    33int subpix (int argc, char **argv) {
    44 
    5   int i, j, I, Nlo, Nhi, Nentry, Nstars, Nimage, Nmeasure;
    6   int *index, *entry;
     5  int i, j, I, Nlo, Nhi, *entry, Nentry;
     6  off_t *index, Nstars, Nimage, Nmeasure;
    77  int Nmin, Nsub, NSUB, status;
    88  int TimeFormat;
    … …  
    5454  ALLOCATE (RA, double, Nstars);
    5555  ALLOCATE (DEC, double, Nstars);
    56   ALLOCATE (index, int, Nstars);
     56  ALLOCATE (index, off_t, Nstars);
    5757  for (i = 0; i < Nstars; i++) {
    5858    RA[i] = catalog.average[i].R;

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/lib.shell/BufferOps.c

    r17903 r27295  
    241241               i, buffers[i][0].name, buffers[i][0].file,
    242242               buffers[i][0].header.Naxis[0], buffers[i][0].header.Naxis[1],
    243                buffers[i][0].header.size + buffers[i][0].matrix.size, buffers[i][0].bitpix,
     243               buffers[i][0].header.datasize + buffers[i][0].matrix.datasize, buffers[i][0].bitpix,
    244244               buffers[i][0].unsign, buffers[i][0].bzero, buffers[i][0].bscale);
    245245    }
    … …  
    252252             i, buffers[i][0].name, buffers[i][0].file,
    253253             buffers[i][0].header.Naxis[0], buffers[i][0].header.Naxis[1],
    254              buffers[i][0].header.size + buffers[i][0].matrix.size);
    255   }
    256   return (TRUE);
    257 }
     254             buffers[i][0].header.datasize + buffers[i][0].matrix.datasize);
     255  }
     256  return (TRUE);
     257}

  • branches/eam_branches/largefiles.20100314/Ohana/src/opihi/lib.shell/stack_math.c

    r26891 r27295  
    11351135  /* copy all but the matrix */
    11361136
    1137   matrix2[0].unsign = matrix1[0].unsign;
    1138   matrix2[0].bitpix = matrix1[0].bitpix;
    1139   matrix2[0].size   = matrix1[0].size;
    1140   matrix2[0].bzero  = matrix1[0].bzero;
    1141   matrix2[0].bscale = matrix1[0].bscale;
    1142   matrix2[0].Naxes  = matrix1[0].Naxes;
    1143   for (i = 0; i < FT_MAX_NAXES; i++)
     1137  matrix2[0].unsign   = matrix1[0].unsign;
     1138  matrix2[0].bitpix   = matrix1[0].bitpix;
     1139  matrix2[0].datasize = matrix1[0].datasize;
     1140  matrix2[0].bzero    = matrix1[0].bzero;
     1141  matrix2[0].bscale   = matrix1[0].bscale;
     1142  matrix2[0].Naxes    = matrix1[0].Naxes;
     1143  for (i = 0; i < FT_MAX_NAXES; i++) {
    11441144    matrix2[0].Naxis[i] = matrix1[0].Naxis[i];
    1145 
     1145  }
    11461146
    11471147  return (TRUE);

  • branches/eam_branches/largefiles.20100314/Ohana/src/photdbc/src/join_stars.c

    r17284 r27295  
    33void join_stars (Catalog *catalog) {
    44
    5   int i, j, k, m, M, Ni, Nj, first_j;
    6   int Naves, Nmeas, Ncurr;
    7   int Naverage, Nmeasure, *found, *index;
     5  off_t i, j, k, m, M, Ni, Nj, first_j, Nfirst;
     6  off_t Naves, Nmeas, Ncurr;
     7  off_t Naverage, Nmeasure, *index;
    88  double *X, *Y, dX, dY, dR, RADIUS2;
    99  double Sr, Sd, Rmid, Dmid;
    10   int basecode, baseNsec, Nsecfilt, Nfirst;
     10  int basecode, baseNsec, Nsecfilt, *found;
    1111
    1212  Average *naverage, *average;
    … …  
    6161  ALLOCATE (X, double, Naverage);
    6262  ALLOCATE (Y, double, Naverage);
    63   ALLOCATE (index, int, Naverage);
     63  ALLOCATE (index, off_t, Naverage);
    6464  for (i = 0; i < Naverage; i++) {
    6565    index[i] = i;

  • branches/eam_branches/largefiles.20100314/Ohana/src/relphot/src/GridOps.c

    r21508 r27295  
    781781    theader.Naxis[0] = RELPHOT_GRID_X;
    782782    theader.Naxis[1] = RELPHOT_GRID_Y;
    783     gfits_modify (&theader, "NAXIS1", "%d", 1, RELPHOT_GRID_X);
    784     gfits_modify (&theader, "NAXIS2", "%d", 1, RELPHOT_GRID_Y);
     783    gfits_modify (&theader, "NAXIS1", "%lld", 1, RELPHOT_GRID_X);
     784    gfits_modify (&theader, "NAXIS2", "%lld", 1, RELPHOT_GRID_Y);
    785785    gfits_create_matrix  (&theader, &matrix);
    786786

  • branches/eam_branches/largefiles.20100314/Ohana/src/relphot/src/load_images.c

    r25757 r27295  
    4040
    4141  Image     *image;
    42   int        Nimage, Nx, i;
     42  off_t     Nimage, Nx, i;
    4343  VTable    *vtable;
    4444
    … …  
    4747  vtable = &db[0].vtable;
    4848
    49   gfits_scan (vtable[0].header, "NAXIS1", "%d", 1, &Nx);
     49  gfits_scan (vtable[0].header, "NAXIS1", "%lld", 1, &Nx);
    5050  for (i = 0; i < Nimage; i++) {
    5151    memcpy (vtable[0].buffer[i], &image[i], Nx);

  • branches/eam_branches/largefiles.20100314/Ohana/src/tools/src/ckfits.c

    r15487 r27295  
    44int main (int argc, char **argv) {
    55
    6   int i, Nbytes, nbytes, Ndata, Ntotal, nskip, status;
     6  off_t i, Nbytes, nbytes, Ndata, Ntotal, nskip;
     7  int status;
    78  Header header;
    89  FILE *f;
    … …  
    2627
    2728  nbytes = Ntotal - Ndata;
    28   nskip = Ndata + header.size;
     29  nskip = Ndata + header.datasize;
    2930
    3031  f = fopen (argv[1], "r");
    … …  
    3536
    3637  ALLOCATE (buffer, char, MAX (nbytes, 1));
    37   fseek (f, nskip, SEEK_SET);
     38  fseeko (f, nskip, SEEK_SET);
    3839  Nbytes = fread (buffer, 1, nbytes, f);
    3940  fclose (f);

  • branches/eam_branches/largefiles.20100314/Ohana/src/tools/src/fhead.c

    r12333 r27295  
    55
    66  int N, Extend, Nextend, status;
    7   int i, j, nbytes;
     7  int i, j;
     8  off_t nbytes;
    89  Header head;
    910  char *p;
    … …  
    2930    if (!status) continue;
    3031
    31     for (j = 79; j < head.size; j+= 80) {
     32    for (j = 79; j < head.datasize; j+= 80) {
    3233      head.buffer[j] = 10;
    3334    }

  • branches/eam_branches/largefiles.20100314/Ohana/src/tools/src/fields.c

    r24232 r27295  
    2222  Header header;
    2323  char filename[1000], *CCDKeyword, *Extname, extname[80];
    24   int N, Nbytes, Extnum, Nextend, status, GotFile, GotField, GotExtension;
    25 
     24  int N, Extnum, Nextend, status, GotFile, GotField, GotExtension;
     25  off_t Nbytes;
    2626  regex_t preg;
    2727
    … …  
    9797   
    9898        Nbytes = gfits_data_size (&header);
    99         fseek (f, Nbytes, SEEK_CUR);
     99        fseeko (f, Nbytes, SEEK_CUR);
    100100        Nextend ++;
    101101

  • branches/eam_branches/largefiles.20100314/Ohana/src/tools/src/fits_insert.c

    r21046 r27295  
    77int main (int argc, char **argv) {
    88
    9   int i, N, status, EXTNUM, Nbytes, skip, Delete, DeleteStart, DeleteStop;
    10   int Nreserved, start_size;
     9  off_t i, skip, Nbytes, start_size;
     10  int N, status, EXTNUM, Delete, DeleteStart, DeleteStop;
     11  int Nreserved;
    1112  char *p, keyword[16], line[256];
    1213  FILE *f;
    … …  
    6263      exit (1);
    6364  }
    64   start_size = header.size;
    65   skip = Nbytes - header.size;
     65  start_size = header.datasize;
     66  skip = Nbytes - header.datasize;
    6667
    6768  /* open header data file */
    … …  
    116117    /* check that the line does not already exist */
    117118    p = (char *) NULL;
    118     for (i = 0; (i < header.size) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
     119    for (i = 0; (i < header.datasize) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
    119120      if (!strncmp (&header.buffer[i], line, 80)) {
    120121        p = &header.buffer[i];
    … …  
    126127    p = (char *) NULL;
    127128    Nreserved = strlen (reserved);
    128     for (i = 0; (i < header.size) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
     129    for (i = 0; (i < header.datasize) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
    129130      if (!strncmp (&header.buffer[i], "END     ", 8)) break;
    130131      if (!strncmp (&header.buffer[i], reserved, Nreserved)) {
    … …  
    142143        exit (1);
    143144      }
    144       if (p - header.buffer + 80 == header.size) {
     145      if (p - header.buffer + 80 == header.datasize) {
    145146        fprintf (stderr, "no free space in block, can't insert keyword\n");
    146147        exit (1);
    … …  
    161162  */
    162163
    163   if (header.size != start_size) {
     164  if (header.datasize != start_size) {
    164165    fprintf (stderr, "header changed size: should not happen!\n");
    165166    exit (1);
    … …  
    172173  }
    173174
    174   fseek (f, skip, SEEK_SET);
    175   status = fwrite (header.buffer, 1, header.size, f);
    176   if (status != header.size) {
     175  fseeko (f, skip, SEEK_SET);
     176  status = fwrite (header.buffer, 1, header.datasize, f);
     177  if (status != header.datasize) {
    177178    fprintf (stderr, "failed to write data to image header\n");
    178179    exit (1);

  • branches/eam_branches/largefiles.20100314/Ohana/src/tools/src/ftable.c

    r26384 r27295  
    88void list_extnames (char *file);
    99void print_layout (Header *header);
    10 int   ByteSwap (char *ptr, int size, int nitems, char *type);
    1110int Binary;
    1211
    1312int main (int argc, char **argv) {
    1413
    15   int i, N, Nx, Ny, Nbytes, Nread;
    16   int Nextend, Column, Row, ListExtname, Layout;
     14  off_t i, Nx, Ny, Nbytes, Nread, Row;
     15  int N, Nextend, Column, ListExtname, Layout;
    1716  char *Extname, *Colname, *line, ttype[80];
    1817  FTable table;
    … …  
    9493    exit (1);
    9594  }
    96   table.size = Nbytes;
    97 
    98   gfits_scan (table.header, "NAXIS1",  "%d", 1, &Nx);
    99   gfits_scan (table.header, "NAXIS2",  "%d", 1, &Ny);
     95  table.datasize = Nbytes;
     96
     97  gfits_scan (table.header, "NAXIS1",  "%lld", 1, &Nx);
     98  gfits_scan (table.header, "NAXIS2",  "%lld", 1, &Ny);
    10099
    101100  /* print a column */
    … …  
    122121char *print_table_row (char *row, Header *header) {
    123122 
    124   int i, j, Nx, Nfields, Nbytes, Nvals, Oout, Oin;
     123  off_t Nx;
     124  int i, j, Nfields, Nbytes, Nvals, Oout, Oin;
    125125  char field[16], type[16], format[16], *line;
    126126
    127   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
     127  gfits_scan (header, "NAXIS1",  "%lld", 1, &Nx);
    128128  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    129129
    … …  
    160160
    161161  FILE *f;
    162   int i, Naxis, Nelem, Ncomp, extend, Nbytes, status;
     162  off_t Nbytes, Nelem;
     163  int i, Naxis, Ncomp, extend, status;
    163164  char extname[82], exttype[82], axisname[32];
    164165  Header header;
    … …  
    169170    exit (1);
    170171  }
    171 
    172   /*
    173      if (!gfits_fread_header (f, &header)) {
    174      fprintf (stderr, "can't read header from %s\n", file);
    175      exit (1);
    176      }
    177      Nbytes = gfits_data_size (&header);
    178      fseek (f, Nbytes, SEEK_CUR);
    179   */
    180172
    181173  fprintf (stdout, "%-30s %-15s NAXIS NAXIS(i)...\n", "extname", "datatype");
    … …  
    217209    for (i = 0; i < Naxis; i++) {
    218210      sprintf (axisname, "NAXIS%d", i+1);
    219       status = gfits_scan (&header, axisname,  "%d", 1, &Nelem);
     211      status = gfits_scan (&header, axisname,  "%lld", 1, &Nelem);
    220212      if (!status) {
    221213        fprintf (stderr, "missing %s\n", axisname);
    … …  
    235227
    236228    Nbytes = gfits_data_size (&header);
    237     fseek (f, Nbytes, SEEK_CUR);
     229    fseeko (f, Nbytes, SEEK_CUR);
    238230
    239231    Ncomp ++;
    … …  
    245237FILE *load_extension (char *file, int Nextend, char *Extname, Header *header) {
    246238
    247   int i, extend, Nbytes;
     239  off_t Nbytes;
     240  int i, extend;
    248241  char extname[82];
    249242  FILE *f;
    … …  
    271264  /* skip first data array */
    272265  Nbytes = gfits_data_size (header);
    273   fseek (f, Nbytes, SEEK_CUR);
     266  fseeko (f, Nbytes, SEEK_CUR);
    274267
    275268  /* search for extension of interest */
    … …  
    281274
    282275    Nbytes = gfits_data_size (header);
    283     fseek (f, Nbytes, SEEK_CUR);
     276    fseeko (f, Nbytes, SEEK_CUR);
    284277    gfits_free_header (header);
    285278  }
    … …  
    292285void print_column (FTable *table, int Column, char *Colname) {
    293286 
    294   int i, j, Nfields, Nstart, Nv, Nb, Nx, Ny;
     287  off_t Nx, Ny;
     288  int i, j, Nfields, Nstart, Nv, Nb;
    295289  Header *header;
    296290  char format[16], field[16], type[16], *line, *data;
    … …  
    300294
    301295  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    302   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    303   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     296  gfits_scan (header, "NAXIS1",  "%lld", 1, &Nx);
     297  gfits_scan (header, "NAXIS2",  "%lld", 1, &Ny);
    304298
    305299  if (Colname != (char *) NULL) {

  • branches/eam_branches/largefiles.20100314/Ohana/src/tools/src/mefhead.c

    r15487 r27295  
    55
    66  struct stat filestat;
    7   int NEXTEND, Nextend, Nmatrix, status;
     7  int NEXTEND, Nextend, status;
     8  off_t Nmatrix;
    89  Header header;
    910  FILE *f, *g;
    … …  
    4344  /* skip matrix */
    4445  Nmatrix = gfits_data_size (&header);
    45   fseek (g, Nmatrix, SEEK_CUR);
     46  fseeko (g, Nmatrix, SEEK_CUR);
    4647
    4748  /* write PHU */
    … …  
    6566    /* skip matrix */
    6667    Nmatrix = gfits_data_size (&header);
    67     fseek (g, Nmatrix, SEEK_CUR);
     68    fseeko (g, Nmatrix, SEEK_CUR);
    6869   
    6970    /* write header */
Note: See TracChangeset for help on using the changeset viewer.