IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 25, 2015, 10:41:05 PM (11 years ago)
Author:
eugene
Message:

merge changes from branches/eam_branches/ipp-20150616

Location:
trunk/Ohana/src/libfits
Files:
20 edited

Legend:

Unmodified
Added
Removed

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

    r27435 r38553  
    55int gfits_write_header (char *filename, Header *header) {
    66
    7   FILE *f;
    8   off_t Nbytes;
    9   int status;
    10  
    11   status = TRUE;
     7  FILE *f = fopen (filename, "w");
     8  if (!f) return (FALSE);
    129
    13   f = fopen (filename, "w");
    14   if (f == (FILE *) NULL) return (FALSE);
    15 
    16   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    17 
    18   if (Nbytes != header[0].datasize) {
    19     status = FALSE;
    20   }
    21 
     10  int status = gfits_fwrite_header (f, header);
    2211  fclose (f);
    2312
    … …  
    2918
    3019  off_t Nbytes;
    31   int status;
    32  
    33   status = TRUE;
     20
     21# ifdef OHANA_MEMORY 
     22  { // check memory before writing:
     23    // memblock of supplied pointer
     24    OhanaMemblock *myBlock = (OhanaMemblock *) header[0].buffer - 1;
     25    myAssert (myBlock->startblock == OHANA_MEMMAGIC, "bad memory");
     26    myAssert (myBlock->endblock == OHANA_MEMMAGIC, "bad memory");
     27    myAssert (myBlock->size >= header[0].datasize, "overflow");
     28  }
     29# endif
    3430
    3531  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    36 
    37   if (Nbytes != header[0].datasize) {
    38     status = FALSE;
     32  if (Nbytes != header[0].datasize) {
     33    perror ("fwrite: ");
     34    return FALSE;
    3935  }
    40 
    41   return (status);
     36  return TRUE;
    4237}       
    4338
    4439
    4540int gfits_fwrite_header (FILE *f, Header *header) {
    46 
    47   int status;
    48   status = gfits_save_header (f, header);
     41  int status = gfits_save_header (f, header);
    4942  return (status);
    5043}

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

    r38441 r38553  
    9999
    100100typedef struct {
    101   char ttype[16];             // TTYPE field of original table
    102   char ttype_cmt[80];         // comment associated with TTYPE
    103   char tunit[16];             // TUNIT field of original table
    104   char tunit_cmt[80];         // comment associated with TUNIT
    105   char tformat[16];           // TFORM field of original table
    106   char tformat_cmt[80];       // comment associated with TFORM
    107   char zctype[80];            // compression type for this field
     101  char ttype[256];            // TTYPE field of original table
     102  char ttype_cmt[256];        // comment associated with TTYPE
     103  char tunit[256];            // TUNIT field of original table
     104  char tunit_cmt[256];        // comment associated with TUNIT
     105  char tformat[256];          // TFORM field of original table
     106  char tformat_cmt[256];      // comment associated with TFORM
     107  char zctype[256];           // compression type for this field
    108108  VarLengthColumn zdef;       // description of the output variable length column
    109109
    110   char datatype[80];          // named data type associated with ttype (eg, 18J -> int, 18D -> double)
     110  char datatype[256];         // named data type associated with ttype (eg, 18J -> int, 18D -> double)
    111111  int Nvalues;                // number of values per row (eg 18J -> 18 int values)
    112112  int pixsize;                // number of bytes per value of this row (eg, 18J -> 4 bytes)

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

    r33648 r38553  
    3535  else
    3636    nbytes = FT_RECORD_SIZE * ((off_t) (matrix[0].datasize / FT_RECORD_SIZE));
     37
     38  // fprintf (stderr, "write matrix: %d bytes (%d datasize)\n", (int) nbytes, (int) matrix[0].datasize);
     39  if (nbytes == 0) return TRUE;
    3740
    3841# define DOSWAP(A,B) { char tmp = A; A = B; B = tmp; }

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

    r38471 r38553  
    5757  char *raw = NULL;
    5858  char *zdata = NULL;
     59  TableField *fields = NULL;
    5960
    6061  Header *srcheader = srctable->header;
    … …  
    100101  gettimeofday (&startTimer, (void *) NULL);
    101102
    102   TableField *fields = NULL;
    103103  ALLOCATE_ZERO (fields, TableField, Nfields);
    104104  for (i = 0; i < Nfields; i++) {
    … …  
    351351  gfits_dump_cmp_table (tgttable, "cmp");
    352352
    353   free (raw);
    354   free (zdata);
     353  FREE (raw);
     354  FREE (zdata);
     355  FREE (fields);
    355356  return (TRUE);
    356357
    … …  
    358359  FREE (raw);
    359360  FREE (zdata);
     361  FREE (fields);
    360362  return FALSE;
    361363}

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

    r28241 r38553  
    1111 
    1212  int i;
    13   char axis[10];
     13  char axis[128];
    1414 
    1515  header[0].datasize = NBYTES;
    1616
     17  myAssert (!header->buffer, "failed to init header or free buffer?");
    1718  ALLOCATE (header[0].buffer, char, NBYTES);
    1819 
    … …  
    2627 
    2728  for (i = 0; i < header[0].Naxes; i++) {
    28     sprintf (axis, "NAXIS%d", i + 1);
     29    snprintf (axis, 64, "NAXIS%d", i + 1);
    2930    gfits_modify (header,  axis, OFF_T_FMT, 1,  header[0].Naxis[i]);
    3031  }

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

    r38441 r38553  
    1111  off_t Naxis1;
    1212  int Nfields, Nbytes, Nval;
    13   char type[16], field[16];
     13  char type[64], field[64];
    1414 
    1515  if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
    … …  
    2121  Naxis1 += Nbytes*Nval;
    2222
    23   sprintf (field, "TTYPE%d", Nfields);
     23  snprintf (field, 64, "TTYPE%d", Nfields);
    2424  gfits_modify (header, field, "%s", 1, label);
    2525  gfits_modify_alt (header, field, "%C", 1, comment);
    26   sprintf (field, "TUNIT%d", Nfields);
     26  snprintf (field, 64, "TUNIT%d", Nfields);
    2727  gfits_modify (header, field, "%s", 1, unit);
    28   sprintf (field, "TFORM%d", Nfields);
     28  snprintf (field, 64, "TFORM%d", Nfields);
    2929  gfits_modify (header, field, "%s", 1, format);
    3030
    3131  // add scaling parameters unless they amount to a noop
    3232  if ((bscale != 1.0) || (bzero != 0.0)) {
    33       sprintf (field, "TSCAL%d", Nfields);
     33      snprintf (field, 64, "TSCAL%d", Nfields);
    3434      gfits_modify (header, field, "%lf", 1, bscale);
    35       sprintf (field, "TZERO%d", Nfields);
     35      snprintf (field, 64, "TZERO%d", Nfields);
    3636      gfits_modify (header, field, "%lf", 1, bzero);
    3737  }
    … …  
    5454  off_t Naxis1;
    5555  int Nfields, Nbytes, Nval;
    56   char type[16], field[16];
     56  char type[64], field[64];
    5757 
    5858  if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
    … …  
    6464  Naxis1 += Nbytes*Nval;
    6565
    66   sprintf (field, "TTYPE%d", Nfields);
     66  snprintf (field, 64, "TTYPE%d", Nfields);
    6767  gfits_modify (header, field, "%s", 1, label);
    6868  if (comment) {
    … …  
    7070  }
    7171  if (unit) {
    72     sprintf (field, "TUNIT%d", Nfields);
     72    snprintf (field, 64, "TUNIT%d", Nfields);
    7373    gfits_modify (header, field, "%s", 1, unit);
    7474  }
    75   sprintf (field, "TFORM%d", Nfields);
     75  snprintf (field, 64, "TFORM%d", Nfields);
    7676  gfits_modify (header, field, "%s", 1, format);
    7777
    7878  // add scaling parameters unless they amount to a noop
    7979  if ((bscale != 1.0) || (bzero != 0.0)) {
    80       sprintf (field, "TSCAL%d", Nfields);
     80      snprintf (field, 64, "TSCAL%d", Nfields);
    8181      gfits_modify (header, field, "%lf", 1, bscale);
    82       sprintf (field, "TZERO%d", Nfields);
     82      snprintf (field, 64, "TZERO%d", Nfields);
    8383      gfits_modify (header, field, "%lf", 1, bzero);
    8484  }
    … …  
    9797  off_t Naxis1;
    9898  int Nstart, Nfields, Nbytes, Nval;
    99   char type[16], field[16], cformat[16];
     99  char type[64], field[64], cformat[64];
    100100
    101101  strcpy (cformat, format);
    … …  
    109109  Naxis1 += Nbytes*Nval;
    110110
    111   sprintf (field, "TTYPE%d", Nfields);
     111  snprintf (field, 64, "TTYPE%d", Nfields);
    112112  gfits_modify (header, field, "%s", 1, label);
    113113  gfits_modify_alt (header, field, "%C", 1, comment);
    114   sprintf (field, "TUNIT%d", Nfields);
     114  snprintf (field, 64, "TUNIT%d", Nfields);
    115115  gfits_modify (header, field, "%s", 1, unit);
    116   sprintf (field, "TFORM%d", Nfields);
     116  snprintf (field, 64, "TFORM%d", Nfields);
    117117  gfits_modify (header, field, "%s", 1, format);
    118118
    119   sprintf (field, "TBCOL%d", Nfields);
     119  snprintf (field, 64, "TBCOL%d", Nfields);
    120120  gfits_modify (header, field, "%d", 1, Nstart);
    121121

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

    r7054 r38553  
    99{
    1010 
    11   char Tform[100], field[100], tmp[100];
     11  char Tform[256], field[256], tmp[256];
    1212  int  start, Nchar, i, N;
    1313 
    … …  
    2222  /* should I count fields from 0 or from 1? */
    2323 
    24   sprintf (field, "TBCOL%d\0", X);
     24  snprintf (field, 256, "TBCOL%d\0", X);
    2525  gfits_scan (&table[0].header, field, "%d", &start, 1);
    2626  start --;
    27   sprintf (field, "TFORM%d\0", X);
     27  snprintf (field, 256, "TFORM%d\0", X);
    2828  gfits_scan (&table[0].header, field, "%s", Tform, 1);
    2929  Nchar = atof (&Tform[1]);

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

    r7054 r38553  
    1010{
    1111 
    12   char Tform[100], field[100];
     12  char Tform[256], field[256];
    1313  int  start, Nchar, byte;
    1414  char tmp[1000];
    … …  
    1616  /* no error checking, all sorts of problems! */
    1717 
    18   sprintf (field, "TBCOL%d\0", X);
     18  snprintf (field, 256, "TBCOL%d\0", X);
    1919  gfits_scan (&table[0].header, field, "%d", &start, 1);
    2020  start --;
    2121 
    22   sprintf (field, "TFORM%d\0", X);
     22  snprintf (field, 256, "TFORM%d\0", X);
    2323  gfits_scan (&table[0].header, field, "%s", Tform, 1);
    2424  Nchar = atof (&Tform[1]);
     25  myAssert (Nchar < 999, "overflow");
    2526 
    2627  byte = Y*table[0].Naxis[0] + start;

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

    r38441 r38553  
    2525  off_t Nx, Ny;
    2626  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    27   char tlabel[80], field[80], format[80], tmpline[16];
     27  char tlabel[256], field[256], format[256], tmpline[64];
    2828  char *Pin, *Pout, *array;
    2929  double Bscale, Bzero;
    … …  
    3636  if (!gfits_scan (header, "TFIELDS", "%d", 1, &Nfields)) return (NULL);
    3737  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
    38     sprintf (field, "TTYPE%d", i);
     38    snprintf (field, 256, "TTYPE%d", i);
    3939    gfits_scan (header, field, "%s", 1, tlabel);
    4040  }
    … …  
    4646
    4747  /* interpret format */
    48   sprintf (field, "TSCAL%d", N);
     48  snprintf (field, 256, "TSCAL%d", N);
    4949  gfits_scan (header, field, "%lf", 1, &Bscale);
    50   sprintf (field, "TZERO%d", N);
     50  snprintf (field, 256, "TZERO%d", N);
    5151  gfits_scan (header, field, "%lf", 1, &Bzero);
    52   sprintf (field, "TFORM%d", N);
     52  snprintf (field, 256, "TFORM%d", N);
    5353  gfits_scan (header, field, "%s", 1, format);
    5454
    … …  
    6262  Nstart = 0;
    6363  for (i = 1; i < N; i++) {
    64     sprintf (field, "TFORM%d", i);
     64    snprintf (field, 256, "TFORM%d", i);
    6565    gfits_scan (header, field, "%s", 1, format);
    6666    gfits_bintable_format (format, tmpline, &Nv, &Nb);
    … …  
    145145
    146146  int Nbytes;
    147   char field[80], format[80];
     147  char field[256], format[256];
    148148
    149149  assert (N > 0);
    150150
    151   sprintf (field, "TFORM%d", N);
     151  snprintf (field, 256, "TFORM%d", N);
    152152  if (!gfits_scan (header, field, "%s", 1, format)) return FALSE;
    153153  if (!gfits_bintable_format (format, type, Nval, &Nbytes)) return (FALSE);
    … …  
    159159
    160160  int i, N, Nfields;
    161   char tlabel[80], field[80];
     161  char tlabel[256], field[256];
    162162
    163163  if (label == (char *) NULL) return (FALSE);
    … …  
    168168  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    169169  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
    170     sprintf (field, "TTYPE%d", i);
     170    snprintf (field, 256, "TTYPE%d", i);
    171171    gfits_scan (header, field, "%s", 1, tlabel);
    172172  }
    … …  
    181181int gfits_get_bintable_column_raw (Header *header, FTable *table, char *label, void **data, char nativeOrder) {
    182182
    183   char type[16];
     183  char type[64];
    184184  off_t Nrow;
    185185  int Ncol;
    … …  
    195195int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) {
    196196
    197   char type[16];
     197  char type[64];
    198198  off_t Nrow;
    199199  int Ncol;
    … …  
    229229
    230230  int i, N, Nfields, Nval, Nbytes;
    231   char tlabel[80], field[80], format[80];
     231  char tlabel[256], field[256], format[256];
    232232
    233233  if (label == (char *) NULL) return (FALSE);
    … …  
    238238  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    239239  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
    240     sprintf (field, "TTYPE%d", i);
     240    snprintf (field, 256, "TTYPE%d", i);
    241241    gfits_scan (header, field, "%s", 1, tlabel);
    242242  }
    … …  
    245245
    246246  /* interpret format */
    247   sprintf (field, "TFORM%d", N);
     247  snprintf (field, 256, "TFORM%d", N);
    248248  gfits_scan (header, field, "%s", 1, format);
    249249
    … …  
    257257  off_t Nx, Ny;
    258258  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    259   char tlabel[80], field[80], format[80], cformat[80], type[16], tmp[16];
     259  char tlabel[256], field[256], format[256], cformat[256], type[64], tmp[64];
    260260  char *array, *Pin, *Pout, *line;
    261261
    … …  
    268268  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    269269  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
    270     sprintf (field, "TTYPE%d", i);
     270    snprintf (field, 256, "TTYPE%d", i);
    271271    gfits_scan (header, field, "%s", 1, tlabel);
    272272  }
    … …  
    275275
    276276  /* interpret format */
    277   sprintf (field, "TFORM%d", N);
     277  snprintf (field, 256, "TFORM%d", N);
    278278  gfits_scan (header, field, "%s", 1, format);
    279279
    … …  
    288288  Nstart = 0;
    289289  for (i = 1; i < N; i++) {
    290     sprintf (field, "TFORM%d", i);
     290    snprintf (field, 256, "TFORM%d", i);
    291291    gfits_scan (header, field, "%s", 1, format);
    292292    gfits_table_format (format, tmp, &Nv, &Nb);

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

    r38441 r38553  
    3030  int i, N, Nfields;
    3131  int Nval, Nbytes, Nstart, Nv, Nb;
    32   char tlabel[80], field[80], format[80], type[16], tmpline[16];
     32  char tlabel[256], field[256], format[256], type[64], tmpline[64];
    3333  char *Pin, *Pout, *array;
    3434  double Bscale, Bzero;
    … …  
    4141  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    4242  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
    43     sprintf (field, "TTYPE%d", i);
     43    snprintf (field, 256, "TTYPE%d", i);
    4444    gfits_scan (header, field, "%s", 1, tlabel);
    4545  }
    … …  
    4848
    4949  /* interpret format */
    50   sprintf (field, "TSCAL%d", N);
     50  snprintf (field, 256, "TSCAL%d", N);
    5151  if (!gfits_scan (header, field, "%lf", 1, &Bscale)) {
    5252    Bscale = 1.0;
    5353  }
    54   sprintf (field, "TZERO%d", N);
     54  snprintf (field, 256, "TZERO%d", N);
    5555  if (!gfits_scan (header, field, "%lf", 1, &Bzero)) {
    5656    Bzero = 0.0;
    5757  }
    58   sprintf (field, "TFORM%d", N);
     58  snprintf (field, 256, "TFORM%d", N);
    5959  gfits_scan (header, field, "%s", 1, format);
    6060
    … …  
    7575  Nstart = 0;
    7676  for (i = 1; i < N; i++) {
    77     sprintf (field, "TFORM%d", i);
     77    snprintf (field, 256, "TFORM%d", i);
    7878    gfits_scan (header, field, "%s", 1, format);
    7979    gfits_bintable_format (format, tmpline, &Nv, &Nb);
    … …  
    190190  int i, N, Nfields;
    191191  int Nval, NbytesOut, Nstart, Nv, Nb;
    192   char tlabel[80], field[80], format[80], outtype[16], tmpline[16];
     192  char tlabel[256], field[256], format[256], outtype[64], tmpline[64];
    193193  char *Pin, *Pout, *array;
    194194  double Bscale, Bzero;
    … …  
    201201  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    202202  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
    203     sprintf (field, "TTYPE%d", i);
     203    snprintf (field, 256, "TTYPE%d", i);
    204204    gfits_scan (header, field, "%s", 1, tlabel);
    205205  }
    … …  
    208208
    209209  /* interpret format */
    210   sprintf (field, "TSCAL%d", N);
     210  snprintf (field, 256, "TSCAL%d", N);
    211211  if (!gfits_scan (header, field, "%lf", 1, &Bscale)) {
    212212    Bscale = 1.0;
    213213  }
    214   sprintf (field, "TZERO%d", N);
     214  snprintf (field, 256, "TZERO%d", N);
    215215  if (!gfits_scan (header, field, "%lf", 1, &Bzero)) {
    216216    Bzero = 0.0;
    217217  }
    218   sprintf (field, "TFORM%d", N);
     218  snprintf (field, 256, "TFORM%d", N);
    219219  gfits_scan (header, field, "%s", 1, format);
    220220
    … …  
    233233  Nstart = 0;
    234234  for (i = 1; i < N; i++) {
    235     sprintf (field, "TFORM%d", i);
     235    snprintf (field, 256, "TFORM%d", i);
    236236    gfits_scan (header, field, "%s", 1, format);
    237237    gfits_bintable_format (format, tmpline, &Nv, &Nb);
    … …  
    780780  off_t Nx, Ny;
    781781  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    782   char tlabel[80], field[80], format[80], cformat[80], type[16], tmp[16];
     782  char tlabel[256], field[256], format[256], cformat[256], type[64], tmp[64];
    783783  char *array, *Pin, *Pout, *line;
    784784
    … …  
    790790  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    791791  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    792     sprintf (field, "TTYPE%d", i);
     792    snprintf (field, 256, "TTYPE%d", i);
    793793    gfits_scan (header, field, "%s", 1, tlabel);
    794794  }
    … …  
    797797
    798798  /* interpret format */
    799   sprintf (field, "TFORM%d", N);
     799  snprintf (field, 256, "TFORM%d", N);
    800800  gfits_scan (header, field, "%s", 1, format);
    801801
    … …  
    815815  Nstart = 0;
    816816  for (i = 1; i < N; i++) {
    817     sprintf (field, "TFORM%d", i);
     817    snprintf (field, 256, "TFORM%d", i);
    818818    gfits_scan (header, field, "%s", 1, format);
    819819    gfits_table_format (format, tmp, &Nv, &Nb);

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

    r7054 r38553  
    66/* we expect one more field: the pointer to the array we read in */
    77
    8   char string[80], this_field[80], form[80], temp[80];
     8  char string[256], this_field[256], form[256], temp[256];
    99  int i, j, N, start, end, width, M;
    1010  va_list argp;
    … …  
    1818  /* find the correct field */
    1919  for (i = 0; i < table[0].Nfields; i++) {
    20     sprintf (string, "TTYPE%d\0", i+1);
     20    snprintf (string, 256, "TTYPE%d\0", i+1);
    2121    gfits_scan (&table[0].header, string, "%s", 1, this_field);
    2222    if (!strcmp (field, this_field)) {
    … …  
    3232  N = i + 1;
    3333
    34   sprintf (string, "TBCOL%d\0", N);
     34  snprintf (string, 256, "TBCOL%d\0", N);
    3535  gfits_scan (&table[0].header, string, "%d", 1, &start);
    36   sprintf (string, "TFORM%d\0", N);
     36  snprintf (string, 256, "TFORM%d\0", N);
    3737  gfits_scan (&table[0].header, string, "%s", 1, form);
    3838  /* we could use some error checking from the FITS table form, but
    … …  
    4242    end = table[0].Naxis[0];
    4343  } else {
    44     sprintf (string, "TBCOL%d\0", N+1);
     44    snprintf (string, 256, "TBCOL%d\0", N+1);
    4545    gfits_scan (&table[0].header, string, "%d", 1, &end);
    4646  }

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

    r38441 r38553  
    113113  if (!*Nbytes) { return (FALSE); }
    114114 
     115  // XXXX : check usage:
     116  myAbort ("need to check length");
    115117  sprintf (format, "%%-%s%c", Size, Type);
    116118
    … …  
    191193  off_t Nx, off;
    192194  int i, Nchar, Nval, Nbytes, Nfields;
    193   char *line, format[64], field[16], type[16];
     195  char *line, format[64], field[64], type[64];
    194196  va_list argp;
    195197 
    … …  
    204206  for (i = 1; i <= Nfields; i++) {
    205207
    206     sprintf (field, "TFORM%d", i);
     208    snprintf (field, 64, "TFORM%d", i);
    207209    gfits_scan (table[0].header, field, "%s", 1, format);       /* get field format */
    208210    gfits_table_format (format, type, &Nval, &Nbytes); /* convert to c-style */
    … …  
    232234  int i, j, n, Nfields;
    233235  int Nchar, Nval, Nbytes, status;
    234   char format[64], field[16], type[16];
     236  char format[64], field[64], type[64];
    235237  double tzero, tscale;
    236238  char *tmpChar;
    … …  
    246248
    247249  for (i = 1; i <= Nfields; i++) {
    248     sprintf (field, "TFORM%d", i);
     250    snprintf (field, 64, "TFORM%d", i);
    249251    gfits_scan (ftable[0].header, field, "%s", 1, format);       /* get field format */
    250252    gfits_bintable_format (format, type, &Nval, &Nbytes); /* convert to c-style */
    251253    Nchar = Nval * Nbytes;
    252254
    253     sprintf (field, "TZERO%d", i);
     255    snprintf (field, 64, "TZERO%d", i);
    254256    status = gfits_scan (ftable[0].header, field, "%lf", 1, &tzero);       /* get field format */
    255257    if (!status) {
    … …  
    258260    }
    259261
    260     sprintf (field, "TSCAL%d", i);
     262    snprintf (field, 64, "TSCAL%d", i);
    261263    status = gfits_scan (ftable[0].header, field, "%lf", 1, &tscale);       /* get field format */
    262264    if (!status) {
    … …  
    325327  int i, j, n, Nfields;
    326328  int Nchar, Nval, Nbytes, status;
    327   char format[64], field[16], type[16];
     329  char format[64], field[64], type[64];
    328330  double tzero, tscale;
    329331  char *tmpChar;
    … …  
    339341
    340342  for (i = 1; i <= Nfields; i++) {
    341     sprintf (field, "TFORM%d", i);
     343    snprintf (field, 64, "TFORM%d", i);
    342344    gfits_scan (ftable[0].header, field, "%s", 1, format);       /* get field format */
    343345    gfits_bintable_format (format, type, &Nval, &Nbytes); /* convert to c-style */
    344346    Nchar = Nval * Nbytes;
    345347
    346     sprintf (field, "TZERO%d", i);
     348    snprintf (field, 64, "TZERO%d", i);
    347349    status = gfits_scan (ftable[0].header, field, "%lf", 1, &tzero);       /* get field format */
    348350    if (!status) {
    … …  
    351353    }
    352354
    353     sprintf (field, "TSCAL%d", i);
     355    snprintf (field, 64, "TSCAL%d", i);
    354356    status = gfits_scan (ftable[0].header, field, "%lf", 1, &tscale);       /* get field format */
    355357    if (!status) {

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

    r38441 r38553  
    88  int Nv, Nb;
    99  char *p1, *p2, *p3;
    10   char field[81];
    11   char format[81];
    12   char tmpline[81];
     10  char field[256];
     11  char format[256];
     12  char tmpline[256];
    1313
    1414  // grab the value of TFORMn for this column
    … …  
    6161  def->offset = 0;
    6262  for (i = 1; i < column; i++) {
    63     sprintf (field, "TFORM%d", i);
     63    snprintf (field, 256, "TFORM%d", i);
    6464    gfits_scan (ftable->header, field, "%s", 1, format);
    6565    gfits_bintable_format (format, tmpline, &Nv, &Nb);

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

    r38471 r38553  
    7878  int i;
    7979
    80   char keyword[81];
     80  char keyword[256];
    8181
    8282  char *raw = NULL;
    8383  char *zdata = NULL;
     84  TableField *fields = NULL;
    8485
    8586  Header *srcheader = srctable->header;
    … …  
    111112  int offset = 0;
    112113
    113   TableField *fields = NULL;
    114114  ALLOCATE (fields, TableField, Nfields);
    115115  for (i = 0; i < Nfields; i++) {
    … …  
    336336  free (raw);
    337337  free (zdata);
     338  free (fields);
    338339  return (TRUE);
    339340
    … …  
    341342  FREE (raw);
    342343  FREE (zdata);
     344  FREE (fields);
    343345  return FALSE;
    344346}

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

    r38441 r38553  
    55int gfits_write_table (char *filename, FTable *table) {
    66 
    7   FILE *f;
    8   int status;
    9  
    10   status = TRUE;
    11  
    12   f = fopen (filename, "a+");
     7  FILE *f = fopen (filename, "a+");
    138  if (f == (FILE *) NULL) return (FALSE);
    149 
    15   status = fseeko (f, 0LL, SEEK_END);  /* write table to end of file! */
     10  int status = fseeko (f, 0LL, SEEK_END);  /* write table to end of file! */
    1611  if (status) { perror ("fseeko: "); return (FALSE);  }
    1712  status = gfits_fwrite_table (f, table);
    … …  
    2520 
    2621  off_t Nbytes;
    27  
     22
     23# ifdef OHANA_MEMORY 
     24  { // check memory before writing:
     25    // memblock of supplied pointer
     26    OhanaMemblock *myBlock = (OhanaMemblock *) table[0].buffer - 1;
     27    myAssert (myBlock->startblock == OHANA_MEMMAGIC, "bad memory");
     28    myAssert (myBlock->endblock == OHANA_MEMMAGIC, "bad memory");
     29    myAssert (myBlock->size >= table[0].datasize, "overflow");
     30  }
     31# endif
     32
    2833  Nbytes = fwrite (table[0].buffer, sizeof(char), table[0].datasize, f);
    29   if (Nbytes != table[0].datasize) { perror ("fwrite: "); return (FALSE);  }
     34  if (Nbytes != table[0].datasize) {
     35    perror ("fwrite: ");
     36    return (FALSE); 
     37  }
    3038  return (TRUE);
    3139}       

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

    r38441 r38553  
    55int gfits_write_Theader (char *filename, Header *header) {
    66 
    7   FILE *f;
    8   int status;
     7  FILE *f = fopen (filename, "a+");
     8  if (!f) return (FALSE);
    99 
    10   status = TRUE;
    11  
    12   f = fopen (filename, "a+");
    13   if (f == (FILE *) NULL) return (FALSE);
    14  
    15   status = fseeko (f, 0LL, SEEK_END);  /* write header to end of file! */
     10  int status = fseeko (f, 0LL, SEEK_END);  /* write header to end of file! */
    1611  if (status) { perror ("fseeko: "); return (FALSE);  }
    1712  status = gfits_fwrite_Theader (f, header);
    … …  
    2621  off_t Nbytes;
    2722 
     23# ifdef OHANA_MEMORY 
     24  {
     25    // memblock of supplied pointer
     26    OhanaMemblock *myBlock = (OhanaMemblock *) header[0].buffer - 1;
     27    myAssert (myBlock->startblock == OHANA_MEMMAGIC, "bad memory");
     28    myAssert (myBlock->endblock == OHANA_MEMMAGIC, "bad memory");
     29    myAssert (myBlock->size >= header[0].datasize, "overflow");
     30  }
     31# endif
     32
    2833  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    29   if (Nbytes != header[0].datasize) { perror ("fwrite: "); return (FALSE);  }
     34  if (Nbytes != header[0].datasize) {
     35    perror ("fwrite: ");
     36    return (FALSE); 
     37  }
    3038
    3139  return (TRUE);

  • trunk/Ohana/src/libfits/test

    • Property svn:ignore

      •  

        old new  
        22ricetest
        33tablecomp
         4tcomptiming
        45test.cmp.fits
        56test.fpk.fits

  • trunk/Ohana/src/libfits/test/imagecomp.c

    r38427 r38553  
    1111int bitpix[] = {8, 16, 32, -32, -64, 0};
    1212
    13 //char *cmptype[] = {"GZIP_1", NULL};
    14 //int bitpix[] = {16, 0};
     13// char *cmptype[] = {"NONE", NULL};
     14// int bitpix[] = {16, 0};
    1515
    1616static int NX = 10;
    … …  
    3131      test_compress_fulltile (bitpix[j], cmptype[i]);
    3232      test_compress_fullrange (bitpix[j], cmptype[i]);
     33      ok (ohana_memcheck (TRUE), "no memory corruption");
    3334    }
    3435  }
    … …  
    4243      test_compress_fulltile (bitpix[j], cmptype[i]);
    4344      test_compress_fullrange (bitpix[j], cmptype[i]);
     45      ok (ohana_memcheck (TRUE), "no memory corruption");
    4446    }
    4547  }
    … …  
    5355      test_compress_fulltile (bitpix[j], cmptype[i]);
    5456      test_compress_fullrange (bitpix[j], cmptype[i]);
     57      ok (ohana_memcheck (TRUE), "no memory corruption");
    5558    }
    5659  }

  • trunk/Ohana/src/libfits/test/tablecomp.c

    r38418 r38553  
    2727    test_compress_fullrange (cmptype[i]);
    2828    test_compress_empty (cmptype[i]);
    29     ok (ohana_memcheck_func (TRUE), "no memory corruption");
     29    ok (ohana_memcheck (TRUE), "no memory corruption");
    3030  }
    3131

  • trunk/Ohana/src/libfits/test/tcomptiming.c

    r38429 r38553  
    2929    gfits_uncompress_timing();
    3030  }
    31   ok (ohana_memcheck_func (TRUE), "no memory corruption");
     31  ok (ohana_memcheck (TRUE), "no memory corruption");
    3232
    3333  return exit_status();
Note: See TracChangeset for help on using the changeset viewer.