IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 24, 2010, 11:22:25 AM (16 years ago)
Author:
eugene
Message:

large update merging in changes for Ohana to support large files

Location:
trunk/Ohana
Files:
39 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana

  • trunk/Ohana/src/libfits/header/F_H_field.c

    r21059 r27435  
    66
    77  char *buf;
    8   int i, Nwant, Nfound;
     8  off_t i;
     9  int Nwant, Nfound;
    910  char keyword[10];
     11
     12  if (header[0].buffer == NULL) return NULL;
    1013
    1114  /* create a blank-padded keyword with exactly 8 characters */
    … …  
    1922    /* find the Nth entry */
    2023    Nfound = 0;
    21     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     24    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    2225      if (!strncmp (keyword, buf, 8)) {
    2326        Nfound ++;
    … …  
    3033    /* count the entries */
    3134    Nfound = 0;
    32     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     35    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    3336      if (!strncmp (keyword, buf, 8)) {
    3437        Nfound ++;
    … …  
    4144    /* find the Nwant entry */
    4245    Nfound = 0;
    43     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     46    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    4447      if (!strncmp (keyword, buf, 8)) {
    4548        Nfound ++;
    … …  
    5053  }
    5154
    52   return ((char *) NULL);
     55  return NULL;
    5356
    5457/*
    … …  
    6669
    6770  char *buf, *ptr;
    68   int i, Nwant, Nfound, Nfield;
     71  off_t i;
     72  int Nwant, Nfound, Nfield;
     73
     74  if (header[0].buffer == NULL) return NULL;
    6975
    7076  Nfield = strlen (field);
    … …  
    7682  if (N > 0) {
    7783    Nfound = 0;
    78     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     84    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    7985      // have we found a HIERARCH entry?
    8086      if (strncmp ("HIERARCH", buf, 8)) continue;
    … …  
    9096    /* count the entries */
    9197    Nfound = 0;
    92     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     98    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    9399      if (strncmp ("HIERARCH", buf, 8)) continue;
    94100      ptr = buf + 9; // start of following keyword
    … …  
    102108    /* find the Nwant entry */
    103109    Nfound = 0;
    104     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     110    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    105111      if (strncmp ("HIERARCH", buf, 8)) continue;
    106112      ptr = buf + 9; // start of following keyword
    … …  
    111117  }
    112118
    113   return ((char *) NULL);
     119  return NULL;
    114120
    115121/*
    … …  
    122128
    123129/*********************** fits header field ****************************/
    124 char *gfits_header_lineno (Header *header, int N) {
     130char *gfits_header_lineno (Header *header, off_t N) {
    125131
    126132  char *buf;
    127133
    128   if (N*80 >= header[0].size) return NULL;
     134  if (N*80 >= header[0].datasize) return NULL;
    129135
    130136  buf = &header[0].buffer[N*80];

  • trunk/Ohana/src/libfits/header/F_copy_H.c

    r17903 r27435  
    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);

  • trunk/Ohana/src/libfits/header/F_create_H.c

    r15487 r27435  
    99  char axis[10];
    1010 
    11   header[0].size = NBYTES;
     11  header[0].datasize = NBYTES;
    1212
    1313  ALLOCATE (header[0].buffer, char, NBYTES);
    … …  
    1717  strncpy (header[0].buffer, "END", 3);
    1818
    19   gfits_modify (header, "SIMPLE", "%t", 1, header[0].simple);
     19  gfits_modify_alt (header, "SIMPLE", "%t", 1, header[0].simple);
    2020  gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
    2121  gfits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
    … …  
    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, (long long) header[0].Naxis[i]);
    2626  }
    2727
    … …  
    3030  gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    3131  gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
    32   gfits_modify (header, "EXTEND", "%t",  1, header[0].extend);
     32  gfits_modify_alt (header, "EXTEND", "%t",  1, header[0].extend);
    3333  return (TRUE);
    3434

  • trunk/Ohana/src/libfits/header/F_delete.c

    r7054 r27435  
    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);

  • trunk/Ohana/src/libfits/header/F_modify.c

    r21059 r27435  
    22# include <gfitsio.h>
    33
     4// this is only valid for the regular and non-boolean fields
    45int gfits_modify (Header *header, char *field, char *mode, int N,...) {
    56 
    … …  
    89
    910  char comment[82], string[82], data[82];
    10   char *p, *qs, *qe;
     11  char *p, *qe;
    1112  va_list argp;
    1213 
    … …  
    2930   
    3031    /* 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);
     32    if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     33      header[0].datasize += FT_RECORD_SIZE;
     34      REALLOCATE (header[0].buffer, char, header[0].datasize);
    3435      p = gfits_header_field (header, "END", 1);
    3536      if (p == NULL) return (FALSE);
    … …  
    5051
    5152  /* 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);
     53  if (!strcmp (mode, "%d"))   snprintf (string, 81, "%-8s= %20d / %-s ",    field, va_arg (argp, int),                comment);
     54  if (!strcmp (mode, "%ld"))  snprintf (string, 81, "%-8s= %20ld / %-s ",   field, va_arg (argp, long),               comment);
     55  if (!strcmp (mode, "%lld")) snprintf (string, 81, "%-8s= %20lld / %-s ",  field, va_arg (argp, long long),          comment);
     56  if (!strcmp (mode, "%Ld"))  snprintf (string, 81, "%-8s= %20lld / %-s ",  field, va_arg (argp, long long),          comment);
     57  if (!strcmp (mode, "%u"))   snprintf (string, 81, "%-8s= %20u / %-s ",    field, va_arg (argp, unsigned),           comment);
     58  if (!strcmp (mode, "%lu"))  snprintf (string, 81, "%-8s= %20lu / %-s ",   field, va_arg (argp, unsigned long),      comment);
     59  if (!strcmp (mode, "%llu")) snprintf (string, 81, "%-8s= %20llu / %-s ",  field, va_arg (argp, unsigned long long), comment);
     60  if (!strcmp (mode, "%Lu"))  snprintf (string, 81, "%-8s= %20llu / %-s ",  field, va_arg (argp, unsigned long long), comment);
     61  if (!strcmp (mode, "%hd"))  snprintf (string, 81, "%-8s= %20d / %-s ",    field, va_arg (argp, int),                comment);
     62  if (!strcmp (mode, "%f"))   snprintf (string, 81, "%-8s= %20.10f / %-s ", field, va_arg (argp, double),             comment);
     63  if (!strcmp (mode, "%lf"))  snprintf (string, 81, "%-8s= %20.10f / %-s ", field, va_arg (argp, double),             comment);
     64  if (!strcmp (mode, "%e"))   snprintf (string, 81, "%-8s= %20.10E / %-s ", field, va_arg (argp, double),             comment);
     65  if (!strcmp (mode, "%le"))  snprintf (string, 81, "%-8s= %20.10E / %-s ", field, va_arg (argp, double),             comment);
     66  if (!strcmp (mode, "%g"))   snprintf (string, 81, "%-8s= %20.10G / %-s ", field, va_arg (argp, double),             comment);
     67  if (!strcmp (mode, "%lg"))  snprintf (string, 81, "%-8s= %20.10G / %-s ", field, va_arg (argp, double),             comment);
     68
     69  /* string value.  Quotes must be at least 18 chars apart */
     70  if (!strcmp (mode, "%s")) {
     71    strncpy (data, va_arg (argp, char *), 68);
     72    snprintf (string, 81, "%-8s= '%-18s' / %-s ", field, data, comment);
     73  }
     74
     75  strncpy (p, string, 80);
     76  va_end (argp);
     77  return (TRUE);
     78
     79}
     80
     81// alternate version for the special types (boolean, comments, COMMENT)
     82int gfits_modify_alt (Header *header, char *field, char *mode, int N,...) {
     83 
     84  /* this function expects one more argument, the value to be written */
     85  /* this function is extremely similar to gfits_print, except it allows for changing an existing field. */
     86
     87  char comment[82], string[82], data[82];
     88  char *p, *qs, *qe;
     89  va_list argp;
     90 
     91  va_start (argp, N);
     92  bzero (data, 82);
     93  bzero (string, 82);
     94  bzero (comment, 82);
     95
     96  if (mode[0] != '%') {
     97    fprintf (stderr, "gfits_print: weird mode:  %s\n", mode);
     98    return (FALSE);
     99  }
     100
     101  /* find location of desired entry */
     102  p = gfits_header_field (header, field, N);
     103  if (p == NULL)  {
     104    /* new entry, find the END of the header */
     105    p = gfits_header_field (header, "END", 1);
     106    if (p == NULL) return (FALSE);
     107   
     108    /* is there enough space for 1 more line? */
     109    if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     110      header[0].datasize += FT_RECORD_SIZE;
     111      REALLOCATE (header[0].buffer, char, header[0].datasize);
     112      p = gfits_header_field (header, "END", 1);
     113      if (p == NULL) return (FALSE);
     114      memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE);
     115    }
     116   
     117    /* push END line back 1 */
     118    memmove ((p + FT_LINE_LENGTH), p, FT_LINE_LENGTH);
     119    memset (p, ' ', FT_LINE_LENGTH);
     120  } else {
     121    /* old entry, save the comment region (is this skipping a character for non-strings?) */
     122    qe = gfits_keyword_end (p);
     123    qe += 3;
     124    qe = MIN (p + 80, qe);
     125    strncpy (comment, qe, p + 80 - qe);
     126  }
     127  gfits_pad_ending (comment, ' ', 82);  /* comment must contain spaces to the end */
    62128
    63129  /* write the boolean mode */
    … …  
    67133    else
    68134      snprintf (string, 81, "%-8s= %18s F / %-s ", field, " ", comment);
    69   }
    70 
    71   /* string value.  Quotes must be at least 18 chars apart */
    72   if (!strcmp (mode, "%s")) {
    73     strncpy (data, va_arg (argp, char *), 68);
    74     snprintf (string, 81, "%-8s= '%-18s' / %-s ", field, data, comment);
    75135  }
    76136

  • trunk/Ohana/src/libfits/header/F_print.c

    r7054 r27435  
    22# include <gfitsio.h>
    33
     4// this only prints the regular and non-boolean fields
    45int gfits_print (Header *header, char *field, char *mode, int N,...) {
     6 
     7  /* this function expects one more argument, the value to be written */
     8
     9  static char blank[] = " ";
     10  char string[82], line[80];
     11  char *p;
     12  va_list argp; 
     13
     14  va_start (argp, N);
     15 
     16  if (mode[0] != '%') {
     17    fprintf (stderr, "gfits_print: weird mode:  %s\n", mode);
     18    return (FALSE);
     19  }
     20
     21  /* this is supposed to create a new field, not modify an old one.  */
     22  p = gfits_header_field (header, field, N);
     23  if (p != NULL) return (FALSE);
     24
     25  /* find the END of the header */
     26  p = gfits_header_field (header, "END", 1);
     27  if (p == NULL) return (FALSE);
     28
     29  /* is there enough space for 1 more line? */
     30  if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     31    header[0].datasize += FT_RECORD_SIZE;
     32    REALLOCATE (header[0].buffer, char, header[0].datasize);
     33    /* re-find the "END" marker, in case new memory block is used */
     34    p = gfits_header_field (header, "END", 1);
     35    if (p == NULL) return (FALSE);
     36    memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE);
     37  }
     38
     39  /* push END line back 1 */
     40  memmove ((p + FT_LINE_LENGTH), p, FT_LINE_LENGTH);
     41  memset (p, ' ', FT_LINE_LENGTH);
     42
     43  /* write the new FITS card, setting the comment to be blank */
     44  /* in these lines, the value field will expand as needed, forcing out the comment
     45     the total line is limited by snprintf to only 80 chars + EOL */
     46
     47  /* write the numeric modes */
     48  if (!strcmp (mode, "%d"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),                blank); }
     49  if (!strcmp (mode, "%ld")) { snprintf (string, 81, "%-8s= %20ld / %46s ",   field, va_arg (argp, long),               blank); }
     50  if (!strcmp (mode, "%lld")){ snprintf (string, 81, "%-8s= %20lld / %46s ",  field, va_arg (argp, long long),          blank); }
     51  if (!strcmp (mode, "%Ld")) { snprintf (string, 81, "%-8s= %20lld / %46s ",  field, va_arg (argp, long long),          blank); }
     52  if (!strcmp (mode, "%u"))  { snprintf (string, 81, "%-8s= %20u / %46s ",    field, va_arg (argp, unsigned),           blank); }
     53  if (!strcmp (mode, "%lu")) { snprintf (string, 81, "%-8s= %20lu / %46s ",   field, va_arg (argp, unsigned long),      blank); }
     54  if (!strcmp (mode, "%llu")){ snprintf (string, 81, "%-8s= %20llu / %46s ",  field, va_arg (argp, unsigned long long), blank); }
     55  if (!strcmp (mode, "%Lu")) { snprintf (string, 81, "%-8s= %20llu / %46s ",  field, va_arg (argp, unsigned long long), blank); }
     56  if (!strcmp (mode, "%hd")) { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),                blank); }
     57  if (!strcmp (mode, "%f"))  { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),             blank); }
     58  if (!strcmp (mode, "%lf")) { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),             blank); }
     59  if (!strcmp (mode, "%e"))  { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),             blank); }
     60  if (!strcmp (mode, "%le")) { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),             blank); }
     61  if (!strcmp (mode, "%g"))  { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),             blank); }
     62  if (!strcmp (mode, "%lg")) { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),             blank); }
     63
     64  /* string value.  Quotes must be at least 18 chars apart.  Longer lines will this should be fixed to allow arbitrary string lengths, up to 69 chars */
     65  if (!strcmp (mode, "%s")) {
     66    strcpy (line, va_arg (argp, char *));
     67    line[68] = 0;
     68    snprintf (string, 81, "%-8s= '%-18s' / %46s ", field, line, blank);
     69  }
     70
     71  strncpy (p, string, 80);
     72 
     73  va_end (argp);
     74  return (TRUE);
     75
     76}
     77
     78// alternate version for the special types (boolean, comments, COMMENT)
     79int gfits_print_alt (Header *header, char *field, char *mode, int N,...) {
    580 
    681  /* this function expects one more argument, the value to be written */
    … …  
    27102
    28103  /* 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);
     104  if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     105    header[0].datasize += FT_RECORD_SIZE;
     106    REALLOCATE (header[0].buffer, char, header[0].datasize);
    32107    /* re-find the "END" marker, in case new memory block is used */
    33108    p = gfits_header_field (header, "END", 1);
    … …  
    40115  memset (p, ' ', FT_LINE_LENGTH);
    41116
    42   /* write the new FITS card, setting the comment to be blank */
    43   /* in these lines, the value field will expand as needed, forcing out the comment
    44      the total line is limited by snprintf to only 80 chars + EOL */
    45 
    46   /* 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); }
    57 
    58117  /* write the boolean mode */
    59118  if (!strcmp (mode, "%t")) {
    … …  
    63122    else
    64123      snprintf (string, 81, "%-8s= %18s F / %46s ", field, blank, blank);
    65   }
    66 
    67   /* string value.  Quotes must be at least 18 chars apart.  Longer lines will this should be fixed to allow arbitrary string lengths, up to 69 chars */
    68   if (!strcmp (mode, "%s")) {
    69     strcpy (line, va_arg (argp, char *));
    70     line[68] = 0;
    71     snprintf (string, 81, "%-8s= '%-18s' / %46s ", field, line, blank);
    72124  }
    73125

  • trunk/Ohana/src/libfits/header/F_read_H.c

    r15904 r27435  
    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) {
    … …  
    6060    header[0].Naxis[i] = 0;
    6161
    62   gfits_scan (header,  "SIMPLE", "%t",   1, &header[0].simple);
     62  gfits_scan_alt (header,  "SIMPLE", "%t",   1, &header[0].simple);
    6363  gfits_scan (header,  "BITPIX", "%d",   1, &header[0].bitpix);
    6464  gfits_scan (header,  "NAXIS",  "%d",   1, &header[0].Naxes);
    6565                                                           
    66   gfits_scan (header,  "EXTEND", "%t",   1, &header[0].extend);
    67   gfits_scan (header,  "UNSIGN", "%t",   1, &header[0].unsign);
     66  gfits_scan_alt (header,  "EXTEND", "%t",   1, &header[0].extend);
     67  gfits_scan_alt (header,  "UNSIGN", "%t",   1, &header[0].unsign);
    6868  gfits_scan (header,  "BSCALE", "%lf",  1, &header[0].bscale);
    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, (long long *) &header[0].Naxis[0]);
     72  gfits_scan (header,  "NAXIS2", "%lld", 1, (long long *) &header[0].Naxis[1]);
     73  gfits_scan (header,  "NAXIS3", "%lld", 1, (long long *) &header[0].Naxis[2]);
     74  gfits_scan (header,  "NAXIS4", "%lld", 1, (long long *) &header[0].Naxis[3]);
     75  gfits_scan (header,  "NAXIS5", "%lld", 1, (long long *) &header[0].Naxis[4]);
     76  gfits_scan (header,  "NAXIS6", "%lld", 1, (long long *) &header[0].Naxis[5]);
     77  gfits_scan (header,  "NAXIS7", "%lld", 1, (long long *) &header[0].Naxis[6]);
     78  gfits_scan (header,  "NAXIS8", "%lld", 1, (long long *) &header[0].Naxis[7]);
     79  gfits_scan (header,  "NAXIS9", "%lld", 1, (long long *) &header[0].Naxis[8]);
     80  gfits_scan (header, "NAXIS10", "%lld", 1, (long long *) &header[0].Naxis[9]);
    8181
    8282  if (!gfits_scan (header, "PCOUNT",  "%d", 1, &header[0].pcount)) {

  • trunk/Ohana/src/libfits/header/F_read_XH.c

    r19250 r27435  
    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}       

  • trunk/Ohana/src/libfits/header/F_scan.c

    r21059 r27435  
    22# include <gfitsio.h>
    33
     4// this only scans the regular and non-boolean fields
    45int gfits_scan (Header *header, char *field, char *mode, int N,...) {
    56
    … …  
    1314}
    1415 
     16// alternate version for the special types (boolean, comments, COMMENT)
     17int gfits_scan_alt (Header *header, char *field, char *mode, int N,...) {
     18
     19  int status;
     20  va_list argp;
     21 
     22  va_start (argp, N);
     23  status = gfits_vscan_alt (header, field, mode, N, argp);
     24  va_end (argp);
     25  return (status);
     26}
     27 
     28// this only scans the regular and non-boolean fields
    1529int gfits_vscan (Header *header, char *field, char *mode, int N, va_list argp) {
    1630
    1731  char *p, *q, *s, tmp[81];
    1832  int Nchar, status;
    19   double value;
     33  long long value;
     34  double fvalue;
    2035 
    2136  /* find the correct line with field */
    … …  
    2641  }
    2742
     43  /* all others require '=' in column 8 */
     44  if (p[8] != '=') return (FALSE);
     45
     46  /* extract data into char array (exclude containing ' chars) */
     47  if (!strcmp (mode, "%s")) {
     48    s = gfits_keyword_start (p); /* points at first char (not ') */
     49    q = gfits_keyword_end (p); /* points at following space or ' */
     50
     51    Nchar = MAX (0, (q - s));
     52    bzero (tmp, 81);
     53    memcpy (tmp, s, Nchar);
     54    stripwhite (tmp);
     55    strcpy (va_arg (argp, char *), tmp);
     56    return (TRUE);
     57  }
     58 
     59  /* remaining options are numerical data */
     60  /* need to interpret 1.0d5 as 1.0e5 */
     61  s = gfits_keyword_start (p); /* points at first char (not ') */
     62  q = gfits_keyword_end (p); /* points at following space or ' */
     63
     64  if (!strcmp (mode, "%f") || !strcmp (mode, "%lf")) {
     65    fvalue = strtod (s, &q);
     66    if ((*q == 'd') || (*q == 'D'))
     67      fvalue *= pow (10.0, atof (q + 1));
     68
     69    if (!strcmp (mode, "%f"))   { *va_arg (argp, float *)  = fvalue; return (TRUE); }
     70    if (!strcmp (mode, "%lf"))  { *va_arg (argp, double *) = fvalue; return (TRUE); }
     71  }
     72
     73  value = strtoll (s, &q, 0);
     74  if ((*q == 'd') || (*q == 'D')) value *= pow (10.0, atof (q + 1));
     75
     76  if (!strcmp (mode, "%d"))   { *va_arg (argp, int *)                = value; return (TRUE); }
     77  if (!strcmp (mode, "%ld"))  { *va_arg (argp, long *)               = value; return (TRUE); }
     78  if (!strcmp (mode, "%lld")) { *va_arg (argp, long long *)          = value; return (TRUE); }
     79  if (!strcmp (mode, "%Ld"))  { *va_arg (argp, long long *)          = value; return (TRUE); }
     80  if (!strcmp (mode, "%u"))   { *va_arg (argp, unsigned *)           = value; return (TRUE); }
     81  if (!strcmp (mode, "%lu"))  { *va_arg (argp, unsigned long *)      = value; return (TRUE); }
     82  if (!strcmp (mode, "%llu")) { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     83  if (!strcmp (mode, "%Lu"))  { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     84  if (!strcmp (mode, "%hd"))  { *va_arg (argp, short *)              = value; return (TRUE); }
     85
     86  /* no valid mode found */
     87  return (FALSE);
     88}
     89
     90// alternate version for the special types (boolean, comments, COMMENT)
     91int gfits_vscan_alt (Header *header, char *field, char *mode, int N, va_list argp) {
     92
     93  char *p, *q, *s, tmp[81];
     94  int Nchar, status;
     95
     96  /* find the correct line with field */
     97  p = gfits_header_field (header, field, N);
     98  if (p == NULL) {
     99    status = gfits_vscan_hierarch (header, field, mode, N, argp);
     100    return (status);
     101  }
     102
    28103  /* non-data entry (COMMENT, HISTORY) */
    29104  if (!strcmp (mode, "%S")) {
    … …  
    47122  }
    48123
    49   /* extract data into char array (exclude containing ' chars) */
    50   if (!strcmp (mode, "%s")) {
    51     s = gfits_keyword_start (p); /* points at first char (not ') */
    52     q = gfits_keyword_end (p); /* points at following space or ' */
    53 
    54     Nchar = MAX (0, (q - s));
    55     bzero (tmp, 81);
    56     memcpy (tmp, s, Nchar);
    57     stripwhite (tmp);
    58     strcpy (va_arg (argp, char *), tmp);
    59     return (TRUE);
    60   }
    61  
    62124  /* boolean data, requires int target */
    63125  if (!strcmp (mode, "%t")) {
    … …  
    73135  }
    74136
    75   /* remaining options are numerical data */
    76   /* need to interpret 1.0d5 as 1.0e5 */
    77   s = gfits_keyword_start (p); /* points at first char (not ') */
    78   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); }
    89 
    90137  /* no valid mode found */
    91138  return (FALSE);
    … …  
    97144  char *p, *q, *s, tmp[81];
    98145  int Nchar, Nfield;
    99   double value;
     146  long long value;
     147  double fvalue;
    100148 
    101149  /* find the correct line with field */
    … …  
    156204  s = gfits_hierarch_keyword_start (p, field); /* points at first char (not ') */
    157205  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); }
     206
     207  if (!strcmp (mode, "%f") || !strcmp (mode, "%lf")) {
     208    fvalue = strtod (s, &q);
     209    if ((*q == 'd') || (*q == 'D'))
     210      fvalue *= pow (10.0, atof (q + 1));
     211
     212    if (!strcmp (mode, "%f"))   { *va_arg (argp, float *)  = fvalue; return (TRUE); }
     213    if (!strcmp (mode, "%lf"))  { *va_arg (argp, double *) = fvalue; return (TRUE); }
     214  }
     215
     216  value = strtoll (s, &q, 0);
     217  if ((*q == 'd') || (*q == 'D')) value *= pow (10.0, atof (q + 1));
     218
     219  if (!strcmp (mode, "%d"))   { *va_arg (argp, int *)                = value; return (TRUE); }
     220  if (!strcmp (mode, "%ld"))  { *va_arg (argp, long *)               = value; return (TRUE); }
     221  if (!strcmp (mode, "%lld")) { *va_arg (argp, long long *)          = value; return (TRUE); }
     222  if (!strcmp (mode, "%Ld"))  { *va_arg (argp, long long *)          = value; return (TRUE); }
     223  if (!strcmp (mode, "%u"))   { *va_arg (argp, unsigned *)           = value; return (TRUE); }
     224  if (!strcmp (mode, "%lu"))  { *va_arg (argp, unsigned long *)      = value; return (TRUE); }
     225  if (!strcmp (mode, "%llu")) { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     226  if (!strcmp (mode, "%Lu"))  { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     227  if (!strcmp (mode, "%hd"))  { *va_arg (argp, short *)              = value; return (TRUE); }
    168228
    169229  /* no valid mode found */

  • trunk/Ohana/src/libfits/header/F_write_H.c

    r7054 r27435  
    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  }

  • trunk/Ohana/src/libfits/include/gfitsio.h

    r21059 r27435  
    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));
    … …  
    118119int     gfits_init_header              PROTO((Header *header));
    119120int     gfits_load_header              PROTO((FILE *f, Header *header));
    120 int     gfits_modify                   PROTO((Header *header, char *field, char *mode, int N,...));
    121 int     gfits_print                    PROTO((Header *header, char *field, char *mode, int N,...));
     121int     gfits_modify                   PROTO((Header *header, char *field, char *mode, int N,...)) OHANA_FORMAT(printf, 3, 5);
     122int     gfits_print                    PROTO((Header *header, char *field, char *mode, int N,...)) OHANA_FORMAT(printf, 3, 5);
     123int     gfits_modify_alt               PROTO((Header *header, char *field, char *mode, int N,...));
     124int     gfits_print_alt                PROTO((Header *header, char *field, char *mode, int N,...));
    122125int     gfits_read_Xheader             PROTO((char *filename, Header *header, int N));
    123126int     gfits_read_header              PROTO((char *filename, Header *header));
    124127int     gfits_save_header              PROTO((FILE *f, Header *header));
    125 int     gfits_scan                     PROTO((Header *header, char *field, char *mode, int N,...));
     128int     gfits_scan                     PROTO((Header *header, char *field, char *mode, int N,...)) OHANA_FORMAT(scanf, 3, 5);
     129int     gfits_scan_alt                 PROTO((Header *header, char *field, char *mode, int N,...));
    126130int     gfits_set_unsign_mode          PROTO((int mode));
    127131int     gfits_stripwhite               PROTO((char *string));
    128132int     gfits_vscan                    PROTO((Header *header, char *field, char *mode, int N, va_list argp));
     133int     gfits_vscan_alt                PROTO((Header *header, char *field, char *mode, int N, va_list argp));
    129134int     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));
     135off_t   gfits_data_size                PROTO((Header *header));
     136off_t   gfits_data_min_size            PROTO((Header *header));
    132137int     gfits_extended_to_primary      PROTO((Header *header, int simple, char *comment));
    133138int     gfits_primary_to_extended      PROTO((Header *header, char *exttype, char *comment));
    … …  
    143148/******************************* Matrix functions *************/
    144149
    145 void    gfits_add_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     150void    gfits_add_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y, double value));
    146151int     gfits_convert_format           PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int inBlank, int outUnsign));
    147152int     gfits_copy_matrix              PROTO((Matrix *in, Matrix *out));
    … …  
    152157void    gfits_free_matrix              PROTO((Matrix *matrix));
    153158int     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));
     159double  gfits_get_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y));
     160void    gfits_insert_matrix            PROTO((Matrix *matrix, Matrix *array, off_t x, off_t y));
    156161int     gfits_load_matrix              PROTO((FILE *f, Matrix *matrix, Header *header));
    157162int     gfits_multiply_matrix          PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
    158163int     gfits_read_matrix              PROTO((char *filename, Matrix *matrix));     
    159164int     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));
     165int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, off_t Nskip, off_t Npix));
     166void    gfits_set_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y, double value));
    162167int     gfits_write_matrix             PROTO((char *filename, Matrix *matrix));
    163168int     gfits_uncompress_image         PROTO((Header *header, Matrix *matrix, FTable *ftable));
    … …  
    166171int     gfits_byteswap_zdata           PROTO((char *zdata, int Nzdata, int bitpix));
    167172int     gfits_extension_is_compressed  PROTO((Header *header));
    168 int     gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
     173off_t   gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
    169174int     gfits_uncompressed_data_pixsize PROTO((char *cmptype, int out_bitpix, char **optname, char **optvalue, int Noptions));
    170175int     gfits_vartable_heap_pixsize    PROTO((char format));
    … …  
    173178
    174179char   *gfits_table_print              PROTO((FTable *ftable,...));
    175 int     gfits_add_rows                 PROTO((FTable *ftable, char *data, int Nrow, int Nbytes));
     180int     gfits_add_rows                 PROTO((FTable *ftable, char *data, off_t Nrow, off_t Nbytes));
    176181int     gfits_bintable_format          PROTO((char *format, char *type, int *Nval, int *Nbytes));
    177182int     gfits_create_table             PROTO((Header *header, FTable *ftable));
    … …  
    181186int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
    182187int     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));
     188int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, off_t start, off_t Nrows));
     189int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, off_t Nrow, off_t *row));
     190int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, off_t start, off_t Nrows));
    186191int     gfits_free_table               PROTO((FTable *ftable));
    187192int     gfits_free_vtable              PROTO((VTable *vtable));
    188193int     gfits_fwrite_table             PROTO((FILE *f, FTable *table));
    189194int     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));
     195int     gfits_fwrite_ftable_range      PROTO((FILE *f, FTable *table, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal));
    191196int     gfits_get_bintable_column      PROTO((Header *header, FTable *table, char *label, void **data));
    192197int     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));
     198void   *gfits_get_bintable_column_data PROTO((Header *header, FTable *table, char *label, char *type, off_t *Nrow, int *Ncol));
    194199int     gfits_get_table_column         PROTO((Header *header, FTable *table, char *label, void **data));
    195200int     gfits_get_table_column_type    PROTO((Header *header, char *label, char *type));
    196201int     gfits_read_ftable              PROTO((char *filename, FTable *table, char *extname));
    197202int     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));
    200 int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...));
     203int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, off_t Nrow));
     204int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, off_t Nrow));
     205int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...)) OHANA_FORMAT(printf, 3, 4);
    201206int     gfits_table_format             PROTO((char *format, char *type, int *Nval, int *Nbytes));
    202207int     gfits_table_scale_data         PROTO((FTable *ftable));
    203208int     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));
     209int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, off_t start, off_t Nkeep));
     210int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, off_t Nrow, off_t Nbytes));
     211int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, off_t *row, off_t Nrow));
    207212int     gfits_write_table              PROTO((char *filename, FTable *ftable));
    208213
    … …  
    215220
    216221int     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));
     222void   *gfits_varlength_column_pointer PROTO((FTable *ftable, VarLengthColumn *column, off_t row, off_t *length));
    218223
    219224#endif /* FITSIO */

  • trunk/Ohana/src/libfits/matrix/F_add_M.c

    r7054 r27435  
    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  }

  • trunk/Ohana/src/libfits/matrix/F_add_M_value.c

    r7054 r27435  
    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

  • trunk/Ohana/src/libfits/matrix/F_compress_M.c

    r23724 r27435  
    2424    gfits_delete (header, ZNAME, 1); }
    2525
     26# define MOD_KEYWORD_ALT(ZNAME,NAME,TYPE,IN,OUT) { \
     27    if (gfits_scan_alt (header, ZNAME, TYPE, 1, IN)) { \
     28      gfits_modify_alt (header, NAME, TYPE, 1, OUT); \
     29    } \
     30    gfits_delete (header, ZNAME, 1); }
     31
    2632# define MOD_KEYWORD_REQUIRED(ZNAME,NAME,TYPE,IN,OUT) { \
    2733  if (!gfits_scan (header, ZNAME, TYPE, 1, IN)) ESCAPE; \
    … …  
    3137int gfits_uncompress_image (Header *header, Matrix *matrix, FTable *ftable) {
    3238
    33   int i, j, status, zimage, zcol, Nzrows, Nout, Nzdata, max_tile_size;
     39  off_t Nzdata, Nzrows, zcol;
     40  int i, j, status, zimage, Nout, max_tile_size;
    3441  char cmptype[80];
    3542  char zaxis[10], naxis[10], key[10], word[81], exttype[81], checksum[81], datasum[81];
    … …  
    5158
    5259  // is ZIMAGE present?
    53   status = gfits_scan (ftable->header, "ZIMAGE", "%t", 1, &zimage);
     60  status = gfits_scan_alt (ftable->header, "ZIMAGE", "%t", 1, &zimage);
    5461  if (!status || !zimage) ESCAPE;
    5562
    … …  
    7077    snprintf (zaxis, 10, "ZNAXIS%d", i + 1);
    7178    snprintf (naxis, 10, "NAXIS%d", i + 1);
    72     MOD_KEYWORD_REQUIRED (zaxis,  naxis,  "%d", &header->Naxis[i], header->Naxis[i]);
     79    MOD_KEYWORD_REQUIRED (zaxis,  naxis,  "%lld", (long long *) &header->Naxis[i], (long long) header->Naxis[i]);
    7380  }   
    7481
    … …  
    118125  int have_ztension;
    119126
    120   have_zsimple  = gfits_scan (header, "ZSIMPLE", "%t", 1, &zsimple);
     127  have_zsimple  = gfits_scan_alt (header, "ZSIMPLE", "%t", 1, &zsimple);
    121128  have_ztension = gfits_scan (header, "ZTENSION", "%s", 1, exttype);
    122129
    … …  
    130137    gfits_extended_to_primary (header, header->simple, "Image data");
    131138
    132     MOD_KEYWORD ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
    133     MOD_KEYWORD ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
     139    MOD_KEYWORD_ALT ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
     140    MOD_KEYWORD_ALT ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
    134141  }
    135142
    … …  
    140147    gfits_extended_to_primary (header, header->simple, "Image data");
    141148
    142     MOD_KEYWORD ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
    143     MOD_KEYWORD ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
     149    MOD_KEYWORD_ALT ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
     150    MOD_KEYWORD_ALT ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
    144151  }
    145152
    … …  
    175182
    176183  zscale = 1;
    177   gfits_scan (header, "ZSCALE", "%lf", 1, &zscale);
     184  gfits_scan (header, "ZSCALE", "%f", 1, &zscale);
    178185
    179186  zblank = 32767;
    … …  
    184191
    185192  zzero = 0;
    186   gfits_scan (header, "ZZERO", "%lf", 1, &zzero);
     193  gfits_scan (header, "ZZERO", "%f", 1, &zzero);
    187194
    188195  // find the COMPRESSED_DATA column (format should be 1PB, 1PI, 1PJ)
    … …  
    196203  if (!gfits_varlength_column_define (ftable, &zdef, zcol)) ESCAPE;
    197204  gfits_delete (header, "TFIELDS", 1);
    198   snprintf (key, 10, "TTYPE%d", zcol);
     205  snprintf (key, 10, "TTYPE%lld", (long long) zcol);
    199206  gfits_delete (header, key, 1);
    200   snprintf (key, 10, "TFORM%d", zcol);
     207  snprintf (key, 10, "TFORM%lld", (long long) zcol);
    201208  gfits_delete (header, key, 1);
    202209
    … …  
    236243  ALLOCATE (out, char, odata_pixsize*max_tile_size);
    237244
     245  off_t row;
     246
    238247  // uncompress the data
    239248  Nzrows = ftable->header->Naxis[1];
    240   for (i = 0; i < Nzrows; i++) {
     249  for (row = 0; row < Nzrows; row++) {
    241250
    242251    // expected output size for this tile
    243252    Nout = gfits_tile_size (matrix, otile, ztile);
    244253
    245     zdata = gfits_varlength_column_pointer (ftable, &zdef, i, &Nzdata);
     254    zdata = gfits_varlength_column_pointer (ftable, &zdef, row, &Nzdata);
    246255    if (!zdata) return (FALSE);
    247256
    … …  
    254263
    255264    // gfits_uncompress_data uncompresses from zdata to the temporary output buffer which must be allocated
     265    // XXX the tile must not be > 2GB
    256266    if (!gfits_uncompress_data ((char *)zdata, Nzdata, cmptype, optname, optvalue, Noptions, out, &Nout, odata_pixsize)) return (FALSE);
    257267
    … …  
    284294
    285295// true sizes of this tile (in pixels)
    286 int gfits_tile_size (Matrix *matrix, int *otile, int *ztile) {
    287 
    288   int i, Npixels, Ndimen;
     296off_t gfits_tile_size (Matrix *matrix, int *otile, int *ztile) {
     297
     298  off_t i, Npixels, Ndimen;
    289299
    290300  Npixels = 1;
    … …  
    470480    has_extension = gfits_scan (header, "XTENSION", "%s", 1, extension);
    471481    has_extname = gfits_scan (header, "EXTNAME", "%s", 1, extname);
    472     has_zimage  = gfits_scan (header, "ZIMAGE", "%t", 1, &zimage);
     482    has_zimage  = gfits_scan_alt (header, "ZIMAGE", "%t", 1, &zimage);
    473483
    474484    if (has_extension && !strcmp (extension, "IMAGE")) return (FALSE);
    … …  
    486496    int ztension, zimage;
    487497
    488     has_zimage   = gfits_scan (header, "ZIMAGE",   "%t", 1, &zimage);
    489     has_ztension = gfits_scan (header, "ZTENSION", "%t", 1, &ztension);
     498    has_zimage   = gfits_scan_alt (header, "ZIMAGE",   "%t", 1, &zimage);
     499    has_ztension = gfits_scan_alt (header, "ZTENSION", "%t", 1, &ztension);
    490500
    491501    if (has_zimage && zimage) return (TRUE);

  • trunk/Ohana/src/libfits/matrix/F_convert_format.c

    r20652 r27435  
    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);
    115115  gfits_modify (header, "BZERO",  "%lf", 1, outZero);
    116   gfits_modify (header, "UNSIGN", "%t", 1, outUnsign);
     116  gfits_modify_alt (header, "UNSIGN", "%t", 1, outUnsign);
    117117
    118118  Npixels          = header[0].Naxis[0]*header[0].Naxis[1];
    … …  
    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  }

  • trunk/Ohana/src/libfits/matrix/F_copy_M.c

    r17903 r27435  
    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);

  • trunk/Ohana/src/libfits/matrix/F_create_M.c

    r17903 r27435  
    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

  • trunk/Ohana/src/libfits/matrix/F_get_M_value.c

    r15487 r27435  
    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) {

  • trunk/Ohana/src/libfits/matrix/F_insert_M.c

    r15487 r27435  
    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  }

  • trunk/Ohana/src/libfits/matrix/F_load_M.c

    r16139 r27435  
    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  }

  • trunk/Ohana/src/libfits/matrix/F_matrix.c

    r15751 r27435  
    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);

  • trunk/Ohana/src/libfits/matrix/F_read_M.c

    r7054 r27435  
    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);

  • trunk/Ohana/src/libfits/matrix/F_read_portion.c

    r16139 r27435  
    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  }

  • trunk/Ohana/src/libfits/matrix/F_read_segment.c

    r16139 r27435  
    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  }

  • trunk/Ohana/src/libfits/matrix/F_set_M_value.c

    r15487 r27435  
    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

  • trunk/Ohana/src/libfits/matrix/F_write_M.c

    r16139 r27435  
    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;

  • trunk/Ohana/src/libfits/table/F_create_T.c

    r15487 r27435  
    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);

  • trunk/Ohana/src/libfits/table/F_create_TH.c

    r15487 r27435  
    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, (long long) header[0].Naxis[i]);
    3030  }
    3131 

  • trunk/Ohana/src/libfits/table/F_define_column.c

    r26384 r27435  
    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, (long long *) &Naxis1);
    1516  Nfields ++;
    1617  Naxis1 += Nbytes*Nval;
    … …  
    1819  sprintf (field, "TTYPE%d", Nfields);
    1920  gfits_modify (header, field, "%s", 1, label);
    20   gfits_modify (header, field, "%C", 1, comment);
     21  gfits_modify_alt (header, field, "%C", 1, comment);
    2122  sprintf (field, "TUNIT%d", Nfields);
    2223  gfits_modify (header, field, "%s", 1, unit);
    … …  
    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, (long long) 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, (long long *) &Naxis1);
    5456  Nstart = Naxis1 + 1;
    5557  Nfields ++;
    … …  
    5860  sprintf (field, "TTYPE%d", Nfields);
    5961  gfits_modify (header, field, "%s", 1, label);
    60   gfits_modify (header, field, "%C", 1, comment);
     62  gfits_modify_alt (header, field, "%C", 1, comment);
    6163  sprintf (field, "TUNIT%d", Nfields);
    6264  gfits_modify (header, field, "%s", 1, unit);
    … …  
    6870
    6971  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
    70   gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     72  gfits_modify (header, "NAXIS1",  "%lld", 1, (long long) Naxis1);
    7173  header[0].Naxis[0] = Naxis1;
    7274

  • trunk/Ohana/src/libfits/table/F_get_column.c

    r26384 r27435  
    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, (long long *) &Nx);
     54  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &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, (long long *) &Nx);
     190  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &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, (long long *) &Nx);
     339  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    337340
    338341  /* scan columns to find insert point */

  • trunk/Ohana/src/libfits/table/F_read_T.c

    r15751 r27435  
    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, (long long) 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, (long long *) &Nx);
     188    gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &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);

  • trunk/Ohana/src/libfits/table/F_read_TH.c

    r15743 r27435  
    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, (long long *) &Theader[0].Naxis[0]);
     73  gfits_scan (Theader,  "NAXIS2", "%lld", 1, (long long *) &Theader[0].Naxis[1]);
     74  gfits_scan (Theader,  "NAXIS3", "%lld", 1, (long long *) &Theader[0].Naxis[2]);
     75  gfits_scan (Theader,  "NAXIS4", "%lld", 1, (long long *) &Theader[0].Naxis[3]);
     76  gfits_scan (Theader,  "NAXIS5", "%lld", 1, (long long *) &Theader[0].Naxis[4]);
     77  gfits_scan (Theader,  "NAXIS6", "%lld", 1, (long long *) &Theader[0].Naxis[5]);
     78  gfits_scan (Theader,  "NAXIS7", "%lld", 1, (long long *) &Theader[0].Naxis[6]);
     79  gfits_scan (Theader,  "NAXIS8", "%lld", 1, (long long *) &Theader[0].Naxis[7]);
     80  gfits_scan (Theader,  "NAXIS9", "%lld", 1, (long long *) &Theader[0].Naxis[8]);
     81  gfits_scan (Theader, "NAXIS10", "%lld", 1, (long long *) &Theader[0].Naxis[9]);
    8082
    8183  return (TRUE);

  • trunk/Ohana/src/libfits/table/F_set_column.c

    r16139 r27435  
    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, (long long *) &Nx);
     52  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &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, (long long) 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, (long long *) &Nx);
     184  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &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, (long long) 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);

  • trunk/Ohana/src/libfits/table/F_table_format.c

    r26384 r27435  
    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, (long long *) &Nx);
     133  gfits_scan (ftable[0].header, "NAXIS2", "%lld", 1, (long long *) &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, (long long *) &Nx);
     161  gfits_scan (ftable[0].header, "NAXIS2", "%lld", 1, (long long *) &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, (long long *) &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, (long long *) &Nx);
     239  gfits_scan (ftable[0].header, "NAXIS2",  "%lld", 1, (long long *) &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, (long long *) &Nx);
     323  gfits_scan (ftable[0].header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    319324  gfits_scan (ftable[0].header, "TFIELDS", "%d", 1, &Nfields);
    320325

  • trunk/Ohana/src/libfits/table/F_table_row.c

    r15487 r27435  
    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, (long long *) &Nx);
     14  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &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, (long long) 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, (long long *) &Nx);
     46  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &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, (long long) 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, (long long *) &Nx);
     84  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &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, (long long) 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}

  • trunk/Ohana/src/libfits/table/F_table_varlength.c

    r18264 r27435  
    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, (long long *) &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);

  • trunk/Ohana/src/libfits/table/F_write_T.c

    r15743 r27435  
    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, (long long *) &Nx);
     43  gfits_scan (table[0].header, "NAXIS2", "%lld", 1, (long long *) &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, (long long) 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);

  • trunk/Ohana/src/libfits/table/F_write_TH.c

    r7054 r27435  
    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}       
Note: See TracChangeset for help on using the changeset viewer.