Index: /trunk/Ohana/src/libfits/doc/ChangeLog.txt =================================================================== --- /trunk/Ohana/src/libfits/doc/ChangeLog.txt (revision 7053) +++ /trunk/Ohana/src/libfits/doc/ChangeLog.txt (revision 7054) @@ -1,2 +1,8 @@ + +- libfits 1.6 + * in order to allow compliation with cfitsio programs, I have changed the + entire namespace to 'gfits' from 'fits' (actually, only fits_copy_header + was conflicting, but it is better to have a sufficiently different namespace). + All ohana programs need to migrate to the new version of libfits. - libfits 1.5 Index: /trunk/Ohana/src/libfits/doc/sample.c =================================================================== --- /trunk/Ohana/src/libfits/doc/sample.c (revision 7053) +++ /trunk/Ohana/src/libfits/doc/sample.c (revision 7054) @@ -25,49 +25,49 @@ /* create primary header */ - fits_init_header (&header); header.extend = TRUE; - fits_create_header (&header); - fits_create_matrix (&header, &matrix); - fits_print (&header, "NEXTEND", "%d", 1, 2); + gfits_init_header (&header); header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + gfits_print (&header, "NEXTEND", "%d", 1, 2); /* define bintable header & layout */ - fits_create_table_header (&theader1, "BINTABLE", "ZERO_POINTS"); + gfits_create_table_header (&theader1, "BINTABLE", "ZERO_POINTS"); - fits_define_bintable_column (&theader1, "E", "ZP_OBS", "measured zero point", "mag", 1.0, 0.0); - fits_define_bintable_column (&theader1, "E", "ZP_REF", "measured zero point", "mag", 1.0, 0.0); - fits_define_bintable_column (&theader1, "J", "TIME", "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0); - fits_define_bintable_column (&theader1, "8A", "TCHAR", "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0); + gfits_define_bintable_column (&theader1, "E", "ZP_OBS", "measured zero point", "mag", 1.0, 0.0); + gfits_define_bintable_column (&theader1, "E", "ZP_REF", "measured zero point", "mag", 1.0, 0.0); + gfits_define_bintable_column (&theader1, "J", "TIME", "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0); + gfits_define_bintable_column (&theader1, "8A", "TCHAR", "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0); /* create table, add data values */ - fits_create_table (&theader1, &table1); + gfits_create_table (&theader1, &table1); /* set table column based on array, extend NAXIS2 as needed/appropriate */ - fits_set_bintable_column (&theader1, &table1, "ZP_OBS", zpobs, Nrow); - fits_set_bintable_column (&theader1, &table1, "ZP_REF", zpref, Nrow); - fits_set_bintable_column (&theader1, &table1, "TIME", time, Nrow); - fits_set_bintable_column (&theader1, &table1, "TCHAR", tchar, Nrow); + gfits_set_bintable_column (&theader1, &table1, "ZP_OBS", zpobs, Nrow); + gfits_set_bintable_column (&theader1, &table1, "ZP_REF", zpref, Nrow); + gfits_set_bintable_column (&theader1, &table1, "TIME", time, Nrow); + gfits_set_bintable_column (&theader1, &table1, "TCHAR", tchar, Nrow); /* define ASCII table header */ - fits_create_table_header (&theader2, "TABLE", "ASCII_PTS"); + gfits_create_table_header (&theader2, "TABLE", "ASCII_PTS"); - fits_define_table_column (&theader2, "F5.2", "ZP_OBS", "measured zero point", "mag"); - fits_define_table_column (&theader2, "F5.2", "ZP_REF", "measured zero point", "mag"); - fits_define_table_column (&theader2, "I8", "TIME", "time of data", "seconds"); - fits_define_table_column (&theader2, "A8", "TCHAR", "time of data", "YYYYMMDD"); + gfits_define_table_column (&theader2, "F5.2", "ZP_OBS", "measured zero point", "mag"); + gfits_define_table_column (&theader2, "F5.2", "ZP_REF", "measured zero point", "mag"); + gfits_define_table_column (&theader2, "I8", "TIME", "time of data", "seconds"); + gfits_define_table_column (&theader2, "A8", "TCHAR", "time of data", "YYYYMMDD"); /* create table, add data values */ - fits_create_table (&theader2, &table2); + gfits_create_table (&theader2, &table2); - fits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow); - fits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow); - fits_set_table_column (&theader2, &table2, "TIME", time, Nrow); - fits_set_table_column (&theader2, &table2, "TCHAR", tchar, Nrow); + gfits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow); + gfits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow); + gfits_set_table_column (&theader2, &table2, "TIME", time, Nrow); + gfits_set_table_column (&theader2, &table2, "TCHAR", tchar, Nrow); /* write header, matrix, table1, table2 */ - fits_write_header (filename, &header); - fits_write_matrix (filename, &matrix); - fits_write_Theader (filename, &theader1); - fits_write_table (filename, &table1); - fits_write_Theader (filename, &theader2); - fits_write_table (filename, &table2); + gfits_write_header (filename, &header); + gfits_write_matrix (filename, &matrix); + gfits_write_Theader (filename, &theader1); + gfits_write_table (filename, &table1); + gfits_write_Theader (filename, &theader2); + gfits_write_table (filename, &table2); } Index: /trunk/Ohana/src/libfits/doc/sample2.c =================================================================== --- /trunk/Ohana/src/libfits/doc/sample2.c (revision 7053) +++ /trunk/Ohana/src/libfits/doc/sample2.c (revision 7054) @@ -19,15 +19,15 @@ strcpy (filename, "test.fits"); - fits_read_header (filename, &header); - fits_read_matrix (filename, &matrix); - fits_read_ftable (filename, &table1, "ZERO_POINTS"); - fits_read_ftable (filename, &table2, "ASCII_PTS"); + gfits_read_header (filename, &header); + gfits_read_matrix (filename, &matrix); + gfits_read_ftable (filename, &table1, "ZERO_POINTS"); + gfits_read_ftable (filename, &table2, "ASCII_PTS"); /* set table column based on array, extend NAXIS2 as needed/appropriate */ - fits_get_bintable_column (&theader1, &table1, "ZP_OBS", &zpobs); - fits_get_bintable_column (&theader1, &table1, "ZP_REF", &zpref); - fits_get_bintable_column (&theader1, &table1, "TIME", &time); - fits_get_bintable_column (&theader1, &table1, "TCHAR", &tchar); - fits_scan (&theader1, "NAXIS2", "%d", 1, &Nrow); + gfits_get_bintable_column (&theader1, &table1, "ZP_OBS", &zpobs); + gfits_get_bintable_column (&theader1, &table1, "ZP_REF", &zpref); + gfits_get_bintable_column (&theader1, &table1, "TIME", &time); + gfits_get_bintable_column (&theader1, &table1, "TCHAR", &tchar); + gfits_scan (&theader1, "NAXIS2", "%d", 1, &Nrow); for (i = 0; i < Nrow; i++) { @@ -38,9 +38,9 @@ /* set table column based on array, extend NAXIS2 as needed/appropriate */ - fits_get_table_column (&theader2, &table2, "ZP_OBS", &zpobs); - fits_get_table_column (&theader2, &table2, "ZP_REF", &zpref); - fits_get_table_column (&theader2, &table2, "TIME", &time); - fits_get_table_column (&theader2, &table2, "TCHAR", &tchar); - fits_scan (&theader2, "NAXIS2", "%d", 1, &Nrow); + gfits_get_table_column (&theader2, &table2, "ZP_OBS", &zpobs); + gfits_get_table_column (&theader2, &table2, "ZP_REF", &zpref); + gfits_get_table_column (&theader2, &table2, "TIME", &time); + gfits_get_table_column (&theader2, &table2, "TCHAR", &tchar); + gfits_scan (&theader2, "NAXIS2", "%d", 1, &Nrow); for (i = 0; i < Nrow; i++) { @@ -54,7 +54,7 @@ /* - fits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow); - fits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow); - fits_set_table_column (&theader2, &table2, "TIME", time, Nrow); - fits_set_table_column (&theader2, &table2, "TCHAR", tchar, Nrow); + gfits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow); + gfits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow); + gfits_set_table_column (&theader2, &table2, "TIME", time, Nrow); + gfits_set_table_column (&theader2, &table2, "TCHAR", tchar, Nrow); */ Index: /trunk/Ohana/src/libfits/header/F_H_field.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_H_field.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_H_field.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits header field ****************************/ -char *fits_header_field (Header *header, char *field, int N) { +char *gfits_header_field (Header *header, char *field, int N) { char *buf; Index: /trunk/Ohana/src/libfits/header/F_create_H.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_create_H.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_create_H.c (revision 7054) @@ -4,5 +4,5 @@ /******************** fits create header ***********************************/ -int fits_create_header (Header *header) { +int gfits_create_header (Header *header) { int i; @@ -17,19 +17,19 @@ strncpy (header[0].buffer, "END", 3); - fits_modify (header, "SIMPLE", "%t", 1, header[0].simple); - fits_modify (header, "BITPIX", "%d", 1, header[0].bitpix); - fits_modify (header, "NAXIS", "%d", 1, header[0].Naxes); + gfits_modify (header, "SIMPLE", "%t", 1, header[0].simple); + gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix); + gfits_modify (header, "NAXIS", "%d", 1, header[0].Naxes); for (i = 0; i < header[0].Naxes; i++) { sprintf (axis, "NAXIS%d", i + 1); - fits_modify (header, axis, "%d", 1, header[0].Naxis[i]); + gfits_modify (header, axis, "%d", 1, header[0].Naxis[i]); } /* PCOUNT & GCOUNT are not implemented, but they are required to be here */ - fits_modify (header, "PCOUNT", "%d", 1, 0); - fits_modify (header, "GCOUNT", "%d", 1, 1); - fits_modify (header, "BSCALE", "%lf", 1, header[0].bscale); - fits_modify (header, "BZERO", "%lf", 1, header[0].bzero); - fits_modify (header, "EXTEND", "%t", 1, header[0].extend); + gfits_modify (header, "PCOUNT", "%d", 1, 0); + gfits_modify (header, "GCOUNT", "%d", 1, 1); + gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale); + gfits_modify (header, "BZERO", "%lf", 1, header[0].bzero); + gfits_modify (header, "EXTEND", "%t", 1, header[0].extend); return (TRUE); Index: /trunk/Ohana/src/libfits/header/F_delete.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_delete.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_delete.c (revision 7054) @@ -3,13 +3,13 @@ /*********************** fits delete ****************************/ -int fits_delete (Header *header, char *field, int N) { +int gfits_delete (Header *header, char *field, int N) { int i, Nbytes; char *p1, *p2; - p1 = fits_header_field (header, field, N); + p1 = gfits_header_field (header, field, N); if (p1 == NULL) return (TRUE); - p2 = fits_header_field (header, "END", 1); + p2 = gfits_header_field (header, "END", 1); if (p2 == NULL) return (FALSE); @@ -21,5 +21,5 @@ *(p2 + i) = ' '; - p2 = fits_header_field (header, "END", 1); + p2 = gfits_header_field (header, "END", 1); if (header[0].size - (p2 - header[0].buffer + FT_LINE_LENGTH) > FT_RECORD_SIZE) { header[0].size -= FT_RECORD_SIZE; Index: /trunk/Ohana/src/libfits/header/F_free_H.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_free_H.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_free_H.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits free header ***********************************/ -void fits_free_header (Header *header) { +void gfits_free_header (Header *header) { if (header[0].buffer == (char *) NULL) return; Index: /trunk/Ohana/src/libfits/header/F_init_H.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_init_H.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_init_H.c (revision 7054) @@ -4,5 +4,5 @@ /*********************** fits read header ***********************************/ -int fits_init_header (Header *header) { +int gfits_init_header (Header *header) { int i; Index: /trunk/Ohana/src/libfits/header/F_insert_array.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_insert_array.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_insert_array.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits insert array ***********************************/ -void fits_insert_matrix (matrix, array, x, y) +void gfits_insert_matrix (matrix, array, x, y) Matrix *matrix, *array; int x, y; Index: /trunk/Ohana/src/libfits/header/F_modify.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_modify.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_modify.c (revision 7054) @@ -2,12 +2,12 @@ # include -char *fits_keyword_start (char *line); -char *fits_keyword_end (char *line); +char *gfits_keyword_start (char *line); +char *gfits_keyword_end (char *line); void pad_ending (char *line, char value, int Nbyte); -int fits_modify (Header *header, char *field, char *mode, int N,...) { +int gfits_modify (Header *header, char *field, char *mode, int N,...) { /* this function expects one more argument, the value to be written */ - /* this function is extremely similar to fits_print, except it allows for changing an existing field. */ + /* this function is extremely similar to gfits_print, except it allows for changing an existing field. */ char comment[82], string[82], data[82]; @@ -21,13 +21,13 @@ if (mode[0] != '%') { - fprintf (stderr, "fits_print: weird mode: %s\n", mode); + fprintf (stderr, "gfits_print: weird mode: %s\n", mode); return (FALSE); } /* find location of desired entry */ - p = fits_header_field (header, field, N); + p = gfits_header_field (header, field, N); if (p == NULL) { /* new entry, find the END of the header */ - p = fits_header_field (header, "END", 1); + p = gfits_header_field (header, "END", 1); if (p == NULL) return (FALSE); @@ -36,5 +36,5 @@ header[0].size += FT_RECORD_SIZE; REALLOCATE (header[0].buffer, char, header[0].size); - p = fits_header_field (header, "END", 1); + p = gfits_header_field (header, "END", 1); if (p == NULL) return (FALSE); memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE); @@ -46,5 +46,5 @@ } else { /* old entry, save the comment region (is this skipping a character for non-strings?) */ - qe = fits_keyword_end (p); + qe = gfits_keyword_end (p); qe += 3; qe = MIN (p + 80, qe); @@ -87,6 +87,6 @@ /* just a comment associated with a value. this is assumes a fixed format position for the comment */ if (!strcmp (mode, "%C")) { - qe = fits_keyword_end (p); - qs = fits_keyword_start (p); + qe = gfits_keyword_end (p); + qs = gfits_keyword_start (p); /* keep ' on ends, if there */ @@ -108,5 +108,5 @@ /* given a FITS card line, return pointer to the start of the data area */ -char *fits_keyword_start (char *line) { +char *gfits_keyword_start (char *line) { char *c; @@ -127,5 +127,5 @@ /* given a FITS card line, return pointer to the end of the data area */ -char *fits_keyword_end (char *line) { +char *gfits_keyword_end (char *line) { int done; Index: /trunk/Ohana/src/libfits/header/F_print.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_print.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_print.c (revision 7054) @@ -2,5 +2,5 @@ # include -int fits_print (Header *header, char *field, char *mode, int N,...) { +int gfits_print (Header *header, char *field, char *mode, int N,...) { /* this function expects one more argument, the value to be written */ @@ -14,14 +14,14 @@ if (mode[0] != '%') { - fprintf (stderr, "fits_print: weird mode: %s\n", mode); + fprintf (stderr, "gfits_print: weird mode: %s\n", mode); return (FALSE); } /* this is supposed to create a new field, not modify an old one. */ - p = fits_header_field (header, field, N); + p = gfits_header_field (header, field, N); if (p != NULL) return (FALSE); /* find the END of the header */ - p = fits_header_field (header, "END", 1); + p = gfits_header_field (header, "END", 1); if (p == NULL) return (FALSE); @@ -31,5 +31,5 @@ REALLOCATE (header[0].buffer, char, header[0].size); /* re-find the "END" marker, in case new memory block is used */ - p = fits_header_field (header, "END", 1); + p = gfits_header_field (header, "END", 1); if (p == NULL) return (FALSE); memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE); @@ -90,5 +90,5 @@ */ - /* can't write the comment in fits_print - use fits_modify */ + /* can't write the comment in gfits_print - use gfits_modify */ if (!strcmp (mode, "%C")) return (FALSE); Index: /trunk/Ohana/src/libfits/header/F_read_H.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_read_H.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_read_H.c (revision 7054) @@ -4,5 +4,5 @@ /*********************** fits read header ***********************************/ -int fits_read_header (char *filename, Header *header) { +int gfits_read_header (char *filename, Header *header) { FILE *f; @@ -13,5 +13,5 @@ return (FALSE); } - if (!fits_load_header (f, header)) { + if (!gfits_load_header (f, header)) { fclose (f); return (FALSE); @@ -22,5 +22,5 @@ } -int fits_load_header (FILE *f, Header *header) { +int gfits_load_header (FILE *f, Header *header) { int i, done, Nbytes, t1, t2; @@ -46,5 +46,5 @@ } - p = fits_header_field (header, "END", 1); + p = gfits_header_field (header, "END", 1); if (p != NULL) done = TRUE; @@ -57,23 +57,23 @@ header[0].Naxis[i] = 0; - fits_scan (header, "SIMPLE", "%t", 1, &header[0].simple); - fits_scan (header, "BITPIX", "%d", 1, &header[0].bitpix); - fits_scan (header, "NAXIS", "%d", 1, &header[0].Naxes); + gfits_scan (header, "SIMPLE", "%t", 1, &header[0].simple); + gfits_scan (header, "BITPIX", "%d", 1, &header[0].bitpix); + gfits_scan (header, "NAXIS", "%d", 1, &header[0].Naxes); - fits_scan (header, "EXTEND", "%t", 1, &header[0].extend); - fits_scan (header, "UNSIGN", "%t", 1, &header[0].unsign); - fits_scan (header, "BSCALE", "%lf", 1, &header[0].bscale); - fits_scan (header, "BZERO", "%lf", 1, &header[0].bzero); + gfits_scan (header, "EXTEND", "%t", 1, &header[0].extend); + gfits_scan (header, "UNSIGN", "%t", 1, &header[0].unsign); + gfits_scan (header, "BSCALE", "%lf", 1, &header[0].bscale); + gfits_scan (header, "BZERO", "%lf", 1, &header[0].bzero); - fits_scan (header, "NAXIS1", "%d", 1, &header[0].Naxis[0]); - fits_scan (header, "NAXIS2", "%d", 1, &header[0].Naxis[1]); - fits_scan (header, "NAXIS3", "%d", 1, &header[0].Naxis[2]); - fits_scan (header, "NAXIS4", "%d", 1, &header[0].Naxis[3]); - fits_scan (header, "NAXIS5", "%d", 1, &header[0].Naxis[4]); - fits_scan (header, "NAXIS6", "%d", 1, &header[0].Naxis[5]); - fits_scan (header, "NAXIS7", "%d", 1, &header[0].Naxis[6]); - fits_scan (header, "NAXIS8", "%d", 1, &header[0].Naxis[7]); - fits_scan (header, "NAXIS9", "%d", 1, &header[0].Naxis[8]); - fits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]); + gfits_scan (header, "NAXIS1", "%d", 1, &header[0].Naxis[0]); + gfits_scan (header, "NAXIS2", "%d", 1, &header[0].Naxis[1]); + gfits_scan (header, "NAXIS3", "%d", 1, &header[0].Naxis[2]); + gfits_scan (header, "NAXIS4", "%d", 1, &header[0].Naxis[3]); + gfits_scan (header, "NAXIS5", "%d", 1, &header[0].Naxis[4]); + gfits_scan (header, "NAXIS6", "%d", 1, &header[0].Naxis[5]); + gfits_scan (header, "NAXIS7", "%d", 1, &header[0].Naxis[6]); + gfits_scan (header, "NAXIS8", "%d", 1, &header[0].Naxis[7]); + gfits_scan (header, "NAXIS9", "%d", 1, &header[0].Naxis[8]); + gfits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]); return (TRUE); @@ -81,9 +81,9 @@ } -int fits_fread_header (FILE *f, Header *header) { +int gfits_fread_header (FILE *f, Header *header) { int status; - status = fits_load_header (f, header); + status = gfits_load_header (f, header); return (status); } Index: /trunk/Ohana/src/libfits/header/F_read_XH.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_read_XH.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_read_XH.c (revision 7054) @@ -4,5 +4,5 @@ /*********************** fits read header ***********************************/ -int fits_read_Xheader (char *filename, Header *header, int N) { +int gfits_read_Xheader (char *filename, Header *header, int N) { /* read header for extension number N */ @@ -21,18 +21,18 @@ for (j = -1; j < N; j++) { /* load data for this header */ - if (!fits_load_header (f, &theader)) { + if (!gfits_load_header (f, &theader)) { fclose (f); return (FALSE); } - Nmatrix = fits_matrix_size (&theader); + Nmatrix = gfits_matrix_size (&theader); /* skip to next header */ fseek (f, Nmatrix, SEEK_CUR); Nskip += (Nmatrix + theader.size); - fits_free_header (&theader); + gfits_free_header (&theader); } - if (!fits_load_header (f, header)) { + if (!gfits_load_header (f, header)) { fclose (f); return (FALSE); Index: /trunk/Ohana/src/libfits/header/F_scan.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_scan.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_scan.c (revision 7054) @@ -2,8 +2,8 @@ # include -char *fits_keyword_start (char *line); -char *fits_keyword_end (char *line); +char *gfits_keyword_start (char *line); +char *gfits_keyword_end (char *line); -int fits_scan (Header *header, char *field, char *mode, int N,...) { +int gfits_scan (Header *header, char *field, char *mode, int N,...) { int status; @@ -11,10 +11,10 @@ va_start (argp, N); - status = fits_vscan (header, field, mode, N, argp); + status = gfits_vscan (header, field, mode, N, argp); va_end (argp); return (status); } -int fits_vscan (Header *header, char *field, char *mode, int N, va_list argp) { +int gfits_vscan (Header *header, char *field, char *mode, int N, va_list argp) { char *p, *q, *s, tmp[81]; @@ -23,5 +23,5 @@ /* find the correct line with field */ - p = fits_header_field (header, field, N); + p = gfits_header_field (header, field, N); if (p == NULL) return (FALSE); @@ -37,10 +37,10 @@ /* comment from data line */ if (!strcmp (mode, "%C")) { - q = fits_keyword_end (p) + 3; + q = gfits_keyword_end (p) + 3; q = MIN (p + 80, q); bzero (tmp, 81); Nchar = MIN (80, p + 80 - q); memcpy (tmp, q, Nchar); - fits_stripwhite (tmp); + gfits_stripwhite (tmp); strcpy (va_arg (argp, char *), tmp); return (TRUE); @@ -49,11 +49,11 @@ /* extract data into char array (exclude containing ' chars) */ if (!strcmp (mode, "%s")) { - s = fits_keyword_start (p); /* points at first char (not ') */ - q = fits_keyword_end (p); /* points at following space or ' */ + s = gfits_keyword_start (p); /* points at first char (not ') */ + q = gfits_keyword_end (p); /* points at following space or ' */ Nchar = MAX (0, (q - s)); bzero (tmp, 81); memcpy (tmp, s, Nchar); - fits_stripwhite (tmp); + gfits_stripwhite (tmp); strcpy (va_arg (argp, char *), tmp); return (TRUE); @@ -62,5 +62,5 @@ /* boolean data, requires int target */ if (!strcmp (mode, "%t")) { - s = fits_keyword_start (p); + s = gfits_keyword_start (p); if (*s == 'T') { *va_arg (argp, int *) = TRUE; @@ -75,6 +75,6 @@ /* remaining options are numerical data */ /* need to interpret 1.0d5 as 1.0e5 */ - s = fits_keyword_start (p); /* points at first char (not ') */ - q = fits_keyword_end (p); /* points at following space or ' */ + s = gfits_keyword_start (p); /* points at first char (not ') */ + q = gfits_keyword_end (p); /* points at following space or ' */ value = strtod (s, &q); if ((*q == 'd') || (*q == 'D')) @@ -100,5 +100,5 @@ /* Strip whitespace from the start and end of STRING. */ -int fits_stripwhite (char *string) { +int gfits_stripwhite (char *string) { int i; Index: /trunk/Ohana/src/libfits/header/F_write_H.c =================================================================== --- /trunk/Ohana/src/libfits/header/F_write_H.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/F_write_H.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits write header ***********************************/ -int fits_write_header (char *filename, Header *header) { +int gfits_write_header (char *filename, Header *header) { FILE *f; @@ -25,5 +25,5 @@ /*********************** fits write header ***********************************/ -int fits_save_header (FILE *f, Header *header) { +int gfits_save_header (FILE *f, Header *header) { int Nbytes, status; @@ -41,8 +41,8 @@ -int fits_fwrite_header (FILE *f, Header *header) { +int gfits_fwrite_header (FILE *f, Header *header) { int status; - status = fits_save_header (f, header); + status = gfits_save_header (f, header); return (status); } Index: /trunk/Ohana/src/libfits/header/version.c =================================================================== --- /trunk/Ohana/src/libfits/header/version.c (revision 7053) +++ /trunk/Ohana/src/libfits/header/version.c (revision 7054) @@ -3,5 +3,5 @@ static char *name = "$Name: not supported by cvs2svn $"; -char *fits_version () { +char *gfits_version () { return (name); } Index: /trunk/Ohana/src/libfits/include/gfitsio.h =================================================================== --- /trunk/Ohana/src/libfits/include/gfitsio.h (revision 7053) +++ /trunk/Ohana/src/libfits/include/gfitsio.h (revision 7054) @@ -86,98 +86,98 @@ # endif -char *fits_version PROTO(()); +char *gfits_version PROTO(()); /******************************* Header functions *************/ -int fits_read_header PROTO((char *, Header *)); +int gfits_read_header PROTO((char *, Header *)); // int fits_copy_header PROTO((Header *, Header *)); int gfits_copy_header PROTO((Header *, Header *)); -void fits_free_header PROTO((Header *)); -int fits_write_header PROTO((char *, Header *)); -int fits_create_header PROTO((Header *)); -int fits_delete PROTO((Header *, char *, int)); -char *fits_header_field PROTO((Header *, char *, int)); -int fits_read_Xheader PROTO((char *filename, Header *header, int N)); -int fits_load_header PROTO((FILE *f, Header *header)); +void gfits_free_header PROTO((Header *)); +int gfits_write_header PROTO((char *, Header *)); +int gfits_create_header PROTO((Header *)); +int gfits_delete PROTO((Header *, char *, int)); +char *gfits_header_field PROTO((Header *, char *, int)); +int gfits_read_Xheader PROTO((char *filename, Header *header, int N)); +int gfits_load_header PROTO((FILE *f, Header *header)); -int fits_fread_header PROTO((FILE *, Header *)); -int fits_fread_Theader PROTO((FILE *, Header *)); -int fits_fread_ftable PROTO((FILE *, FTable *, char *)); -int fits_fread_vtable_range PROTO((FILE *f, VTable *table, int start, int Nrows)); -int fits_fread_vtable PROTO((FILE *f, VTable *table, char *extname, int Nrow, int *row)); -int fits_fread_ftable_data PROTO((FILE *f, FTable *table)); -int fits_fwrite_header PROTO((FILE *, Header *)); -int fits_fwrite_Theader PROTO((FILE *, Header *)); -int fits_fwrite_matrix PROTO((FILE *, Matrix *)); -int fits_fwrite_table PROTO((FILE *, FTable *)); -int fits_fwrite_vtable PROTO((FILE *, VTable *)); +int gfits_fread_header PROTO((FILE *, Header *)); +int gfits_fread_Theader PROTO((FILE *, Header *)); +int gfits_fread_ftable PROTO((FILE *, FTable *, char *)); +int gfits_fread_vtable_range PROTO((FILE *f, VTable *table, int start, int Nrows)); +int gfits_fread_vtable PROTO((FILE *f, VTable *table, char *extname, int Nrow, int *row)); +int gfits_fread_ftable_data PROTO((FILE *f, FTable *table)); +int gfits_fwrite_header PROTO((FILE *, Header *)); +int gfits_fwrite_Theader PROTO((FILE *, Header *)); +int gfits_fwrite_matrix PROTO((FILE *, Matrix *)); +int gfits_fwrite_table PROTO((FILE *, FTable *)); +int gfits_fwrite_vtable PROTO((FILE *, VTable *)); -int fits_matrix_size PROTO ((Header *)); -int fits_init_header PROTO ((Header *)); -int fits_create_table_header PROTO ((Header *, char *, char *)); -int fits_vtable_from_ftable PROTO ((FTable *ftable, VTable *vtable, int *row, int Nrow)); -int fits_table_to_vtable PROTO ((FTable *ftable, VTable *vtable, int start, int Nkeep)); -int fits_create_table PROTO ((Header *, FTable *)); -int fits_vadd_rows PROTO ((VTable *, char *, int, int)); -int fits_add_rows PROTO ((FTable *, char *, int, int)); -char *fits_table_print PROTO ((FTable *,...)); +int gfits_matrix_size PROTO ((Header *)); +int gfits_init_header PROTO ((Header *)); +int gfits_create_table_header PROTO ((Header *, char *, char *)); +int gfits_vtable_from_ftable PROTO ((FTable *ftable, VTable *vtable, int *row, int Nrow)); +int gfits_table_to_vtable PROTO ((FTable *ftable, VTable *vtable, int start, int Nkeep)); +int gfits_create_table PROTO ((Header *, FTable *)); +int gfits_vadd_rows PROTO ((VTable *, char *, int, int)); +int gfits_add_rows PROTO ((FTable *, char *, int, int)); +char *gfits_table_print PROTO ((FTable *,...)); /******************************* Matrix functions *************/ -int fits_read_matrix PROTO((char *, Matrix *)); -int fits_read_portion PROTO((char *filename, Matrix *matrix, int Nskip, int Npix)); -void fits_free_matrix PROTO((Matrix *)); -int fits_copy_matrix PROTO((Matrix *, Matrix *)); -int fits_write_matrix PROTO((char *,Matrix *)); -int fits_create_matrix PROTO((Header *, Matrix *)); -double fits_get_matrix_value PROTO((Matrix *, int, int)); -void fits_set_matrix_value PROTO((Matrix *, int, int, double)); -void fits_add_matrix_value PROTO((Matrix *, int, int, double)); -int fits_multiply_matrix PROTO((Matrix *, Matrix *, Matrix *)); -int fits_divide_matrix PROTO((Matrix *, Matrix *, Matrix *)); -void fits_insert_array PROTO((Matrix *, Matrix *, int, int)); -int fits_load_matrix PROTO((FILE *f, Matrix *matrix, Header *header)); -int fits_fread_matrix PROTO((FILE *f, Matrix *matrix, Header *header)); -int fits_read_segment PROTO((char *filename, Matrix *matrix, char *region)); -int fits_convert_format PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign)); +int gfits_read_matrix PROTO((char *, Matrix *)); +int gfits_read_portion PROTO((char *filename, Matrix *matrix, int Nskip, int Npix)); +void gfits_free_matrix PROTO((Matrix *)); +int gfits_copy_matrix PROTO((Matrix *, Matrix *)); +int gfits_write_matrix PROTO((char *,Matrix *)); +int gfits_create_matrix PROTO((Header *, Matrix *)); +double gfits_get_matrix_value PROTO((Matrix *, int, int)); +void gfits_set_matrix_value PROTO((Matrix *, int, int, double)); +void gfits_add_matrix_value PROTO((Matrix *, int, int, double)); +int gfits_multiply_matrix PROTO((Matrix *, Matrix *, Matrix *)); +int gfits_divide_matrix PROTO((Matrix *, Matrix *, Matrix *)); +void gfits_insert_array PROTO((Matrix *, Matrix *, int, int)); +int gfits_load_matrix PROTO((FILE *f, Matrix *matrix, Header *header)); +int gfits_fread_matrix PROTO((FILE *f, Matrix *matrix, Header *header)); +int gfits_read_segment PROTO((char *filename, Matrix *matrix, char *region)); +int gfits_convert_format PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign)); /******************************* Table functions *************/ -int fits_load_Theader PROTO((FILE *f, Header *Theader)); -int fits_read_Theader PROTO((char *, Header *)); -int fits_read_table PROTO((char *, FTable *)); -int fits_read_table PROTO((char *, FTable *)); -int fits_write_Theader PROTO((char *, Header *header)); -int fits_write_table PROTO((char *, FTable *)); -int fits_fwrite_table PROTO((FILE *f, FTable *table)); -int fits_fwrite_vtable PROTO((FILE *f, VTable *table)); +int gfits_load_Theader PROTO((FILE *f, Header *Theader)); +int gfits_read_Theader PROTO((char *, Header *)); +int gfits_read_table PROTO((char *, FTable *)); +int gfits_read_table PROTO((char *, FTable *)); +int gfits_write_Theader PROTO((char *, Header *header)); +int gfits_write_table PROTO((char *, FTable *)); +int gfits_fwrite_table PROTO((FILE *f, FTable *table)); +int gfits_fwrite_vtable PROTO((FILE *f, VTable *table)); -int fits_bintable_format PROTO((char *, char *, int *, int *)); -int fits_table_format PROTO((char *, char *, int *, int *)); -int fits_save_header PROTO((FILE *, Header *header)); -int fits_set_bintable_column PROTO((Header *header, FTable *table, char *, void *, int)); -int fits_set_table_column PROTO((Header *header, FTable *table, char *, void *, int)); -int fits_define_bintable_column PROTO((Header *header, char *, char *, char *, char *, double, double)); -int fits_define_table_column PROTO((Header *header, char *, char *, char *, char *)); -int fits_read_ftable PROTO((char *filename, FTable *table, char *extname)); +int gfits_bintable_format PROTO((char *, char *, int *, int *)); +int gfits_table_format PROTO((char *, char *, int *, int *)); +int gfits_save_header PROTO((FILE *, Header *header)); +int gfits_set_bintable_column PROTO((Header *header, FTable *table, char *, void *, int)); +int gfits_set_table_column PROTO((Header *header, FTable *table, char *, void *, int)); +int gfits_define_bintable_column PROTO((Header *header, char *, char *, char *, char *, double, double)); +int gfits_define_table_column PROTO((Header *header, char *, char *, char *, char *)); +int gfits_read_ftable PROTO((char *filename, FTable *table, char *extname)); -int fits_free_table PROTO((FTable *table)); -int fits_free_vtable PROTO((VTable *table)); -int fits_create_Theader PROTO((Header *header, char *type)); +int gfits_free_table PROTO((FTable *table)); +int gfits_free_vtable PROTO((VTable *table)); +int gfits_create_Theader PROTO((Header *header, char *type)); /* prototyping demanded for these four -- could be a problem on non-ANSI comp comp */ -int fits_scan PROTO((Header *, char *, char *, int,...)); -int fits_print PROTO((Header *, char *, char *, int,...)); -int fits_modify PROTO((Header *, char *, char *, int,...)); -int fits_table_column PROTO((FTable *, char *, char *,...)); -int fits_table_column PROTO((FTable *table, char *, char *,...)); +int gfits_scan PROTO((Header *, char *, char *, int,...)); +int gfits_print PROTO((Header *, char *, char *, int,...)); +int gfits_modify PROTO((Header *, char *, char *, int,...)); +int gfits_table_column PROTO((FTable *, char *, char *,...)); +int gfits_table_column PROTO((FTable *table, char *, char *,...)); -char *fits_keyword_end PROTO((char *line)); -int fits_vscan PROTO((Header *header, char *field, char *mode, int N, va_list argp)); -int fits_scan PROTO((Header *header, char *field, char *mode, int N,...)); -int fits_stripwhite PROTO((char *string)); -int fits_matrix_size PROTO((Header *header)); +char *gfits_keyword_end PROTO((char *line)); +int gfits_vscan PROTO((Header *header, char *field, char *mode, int N, va_list argp)); +int gfits_scan PROTO((Header *header, char *field, char *mode, int N,...)); +int gfits_stripwhite PROTO((char *string)); +int gfits_matrix_size PROTO((Header *header)); -int fits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval)); -int fits_get_bintable_column PROTO((Header *header, FTable *table, char *label, void **data)); -int fits_get_table_column_type PROTO((Header *header, char *label, char *type)); -int fits_get_table_column PROTO((Header *header, FTable *table, char *label, void **data)); +int gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval)); +int gfits_get_bintable_column PROTO((Header *header, FTable *table, char *label, void **data)); +int gfits_get_table_column_type PROTO((Header *header, char *label, char *type)); +int gfits_get_table_column PROTO((Header *header, FTable *table, char *label, void **data)); #endif /* FITSIO */ Index: /trunk/Ohana/src/libfits/matrix/F_add_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_add_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_add_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits insert array ***********************************/ -void fits_add_matrix (matrix, array, x, y) +void gfits_add_matrix (matrix, array, x, y) Matrix *matrix, *array; int x, y; @@ -23,7 +23,7 @@ for (i = 0; i < array[0].Naxis[0]; i++) { for (j = 0; j < array[0].Naxis[1]; j++) { - V = fits_get_matrix_value (array, i, j); - V += fits_get_matrix_value (matrix, x + i, y + j); - fits_set_matrix_value (matrix, x + i, y + j, V); + V = gfits_get_matrix_value (array, i, j); + V += gfits_get_matrix_value (matrix, x + i, y + j); + gfits_set_matrix_value (matrix, x + i, y + j, V); } } Index: /trunk/Ohana/src/libfits/matrix/F_add_M_value.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_add_M_value.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_add_M_value.c (revision 7054) @@ -3,5 +3,5 @@ /***************** fits add matrix value ***********************************/ -void fits_add_matrix_value (matrix, x, y, Value) +void gfits_add_matrix_value (matrix, x, y, Value) Matrix *matrix; int x, y; @@ -11,7 +11,7 @@ double value; - value = fits_get_matrix_value (matrix, x, y); + value = gfits_get_matrix_value (matrix, x, y); value += Value; - fits_set_matrix_value (matrix, x, y, value); + gfits_set_matrix_value (matrix, x, y, value); } Index: /trunk/Ohana/src/libfits/matrix/F_convert_format.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_convert_format.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_convert_format.c (revision 7054) @@ -29,5 +29,5 @@ /*********************** fits convert format ***********************************/ -int fits_convert_format (Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign) { +int gfits_convert_format (Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign) { unsigned long i, nbytes, Npixels; @@ -49,9 +49,9 @@ matrix[0].bzero = header[0].bzero = outZero; matrix[0].unsign = header[0].unsign = outUnsign; - matrix[0].size = fits_matrix_size (header); - fits_modify (header, "BITPIX", "%d", 1, outBitpix); - fits_modify (header, "BSCALE", "%lf", 1, outScale); - fits_modify (header, "BZERO", "%lf", 1, outZero); - fits_modify (header, "UNSIGN", "%t", 1, outUnsign); + matrix[0].size = gfits_matrix_size (header); + gfits_modify (header, "BITPIX", "%d", 1, outBitpix); + gfits_modify (header, "BSCALE", "%lf", 1, outScale); + gfits_modify (header, "BZERO", "%lf", 1, outZero); + gfits_modify (header, "UNSIGN", "%t", 1, outUnsign); Npixels = header[0].Naxis[0]*header[0].Naxis[1]; Index: /trunk/Ohana/src/libfits/matrix/F_copy_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_copy_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_copy_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits copy header ***********************************/ -int fits_copy_matrix (Matrix *matrix1, Matrix *matrix2) { +int gfits_copy_matrix (Matrix *matrix1, Matrix *matrix2) { int i; Index: /trunk/Ohana/src/libfits/matrix/F_create_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_create_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_create_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits create matrix *******************************/ -int fits_create_matrix (header, matrix) +int gfits_create_matrix (header, matrix) Header *header; Matrix *matrix; @@ -18,5 +18,5 @@ matrix[0].Naxis[i] = header[0].Naxis[i]; - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1)); bzero (matrix[0].buffer, Nbytes); Index: /trunk/Ohana/src/libfits/matrix/F_divide_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_divide_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_divide_M.c (revision 7054) @@ -3,5 +3,5 @@ /********************* fits divide matrix ***********************************/ -int fits_divide_matrix (Matrix *M1, Matrix *M2, Matrix *M3) { +int gfits_divide_matrix (Matrix *M1, Matrix *M2, Matrix *M3) { int i,j; @@ -14,11 +14,11 @@ for (i = 0; i < M1[0].Naxis[0]; i++) { for (j = 0; j < M1[0].Naxis[1]; j++) { - value = fits_get_matrix_value (M1, i, j); - val2 = fits_get_matrix_value (M2, i, j); + value = gfits_get_matrix_value (M1, i, j); + val2 = gfits_get_matrix_value (M2, i, j); if (val2 != 0) value = value / val2; else value = 0.0; - fits_set_matrix_value (M3, i, j, value); + gfits_set_matrix_value (M3, i, j, value); } } Index: /trunk/Ohana/src/libfits/matrix/F_free_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_free_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_free_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits free matrix ***********************************/ -void fits_free_matrix (Matrix *matrix) { +void gfits_free_matrix (Matrix *matrix) { if (matrix[0].buffer == (char *) NULL) return; Index: /trunk/Ohana/src/libfits/matrix/F_get_M_value.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_get_M_value.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_get_M_value.c (revision 7054) @@ -3,5 +3,5 @@ /***************** fits get matrix value ***********************************/ -double fits_get_matrix_value (matrix, x, y) +double gfits_get_matrix_value (matrix, x, y) Matrix *matrix; int x, y; Index: /trunk/Ohana/src/libfits/matrix/F_insert_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_insert_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_insert_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits insert array ***********************************/ -void fits_insert_matrix (Matrix *matrix, Matrix *array, int x, int y) { +void gfits_insert_matrix (Matrix *matrix, Matrix *array, int x, int y) { /* there is no check here to match BITPIX, BZERO, or BSCALE */ Index: /trunk/Ohana/src/libfits/matrix/F_load_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_load_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_load_M.c (revision 7054) @@ -2,14 +2,14 @@ # include -int fits_fread_matrix (FILE *f, Matrix *matrix, Header *header) { +int gfits_fread_matrix (FILE *f, Matrix *matrix, Header *header) { int status; - status = fits_load_matrix (f, matrix, header); + status = gfits_load_matrix (f, matrix, header); return (status); } /*********************** fits read matrix ***********************************/ -int fits_load_matrix (FILE *f, Matrix *matrix, Header *header) { +int gfits_load_matrix (FILE *f, Matrix *matrix, Header *header) { int i, nbytes, Nbytes; @@ -25,5 +25,5 @@ matrix[0].Naxis[i] = header[0].Naxis[i]; - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); ALLOCATE (matrix[0].buffer, char, Nbytes); matrix[0].size = Nbytes; Index: /trunk/Ohana/src/libfits/matrix/F_matrix.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_matrix.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_matrix.c (revision 7054) @@ -2,5 +2,5 @@ # include -int fits_matrix_size (Header *header) { +int gfits_matrix_size (Header *header) { int i, Nrec, size; Index: /trunk/Ohana/src/libfits/matrix/F_multiply_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_multiply_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_multiply_M.c (revision 7054) @@ -3,5 +3,5 @@ /******************* fits multiply matrix ***********************************/ -int fits_multiply_matrix (Matrix *M1, Matrix *M2, Matrix *M3) { +int gfits_multiply_matrix (Matrix *M1, Matrix *M2, Matrix *M3) { int i,j; @@ -14,7 +14,7 @@ for (i = 0; i < M1[0].Naxis[0]; i++) { for (j = 0; j < M1[0].Naxis[1]; j++) { - value = fits_get_matrix_value (M1, i, j); - value *= fits_get_matrix_value (M2, i, j); - fits_set_matrix_value (M3, i, j, value); + value = gfits_get_matrix_value (M1, i, j); + value *= gfits_get_matrix_value (M2, i, j); + gfits_set_matrix_value (M3, i, j, value); } } Index: /trunk/Ohana/src/libfits/matrix/F_read_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_read_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_read_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits read matrix ***********************************/ -int fits_read_matrix (char *filename, Matrix *matrix) { +int gfits_read_matrix (char *filename, Matrix *matrix) { FILE *f; @@ -9,5 +9,5 @@ int status; - status = fits_read_header (filename, &header); + status = gfits_read_header (filename, &header); if (!status) { fprintf (stderr, "error reading header of FITS file %s\n", filename); @@ -20,5 +20,5 @@ fseek (f, header.size, 0); - status = fits_load_matrix (f, matrix, &header); + status = gfits_load_matrix (f, matrix, &header); fclose (f); Index: /trunk/Ohana/src/libfits/matrix/F_read_portion.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_read_portion.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_read_portion.c (revision 7054) @@ -9,5 +9,5 @@ /*********************** fits read matrix ***********************************/ /** the result of this function is a matrix with dimension Npix * 1 **/ -int fits_read_portion (char *filename, Matrix *matrix, int Nskip, int Npix) { +int gfits_read_portion (char *filename, Matrix *matrix, int Nskip, int Npix) { FILE *f; @@ -17,5 +17,5 @@ int perpix; - status = fits_read_header (filename, &header); + status = gfits_read_header (filename, &header); if (!status) { fprintf (stderr, "error reading header of FITS file %s\n", filename); @@ -96,5 +96,5 @@ # endif - fits_free_header (&header); + gfits_free_header (&header); if (nbytes < Nbytes - 2880) { /* this is a bad FITS error: image is not OK */ Index: /trunk/Ohana/src/libfits/matrix/F_read_segment.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_read_segment.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_read_segment.c (revision 7054) @@ -6,5 +6,5 @@ /*********************** fits read matrix ***********************************/ -int fits_read_segment (char *filename, Matrix *matrix, char *region) { +int gfits_read_segment (char *filename, Matrix *matrix, char *region) { FILE *f; @@ -16,5 +16,5 @@ int perpix; - status = fits_read_header (filename, &header); + status = gfits_read_header (filename, &header); if (!status) { fprintf (stderr, "error reading header of FITS file %s\n", filename); @@ -128,5 +128,5 @@ # endif - fits_free_header (&header); + gfits_free_header (&header); if (nbytes < Nbytes - 2880) { /* this is a bad FITS error: image is not OK */ Index: /trunk/Ohana/src/libfits/matrix/F_set_M_value.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_set_M_value.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_set_M_value.c (revision 7054) @@ -3,5 +3,5 @@ /****************** fits set matrix value ***********************************/ -void fits_set_matrix_value (matrix, x, y, Value) +void gfits_set_matrix_value (matrix, x, y, Value) Matrix *matrix; int x, y; Index: /trunk/Ohana/src/libfits/matrix/F_write_M.c =================================================================== --- /trunk/Ohana/src/libfits/matrix/F_write_M.c (revision 7053) +++ /trunk/Ohana/src/libfits/matrix/F_write_M.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits write matrix ***********************************/ -int fits_write_matrix (char *filename, Matrix *matrix) { +int gfits_write_matrix (char *filename, Matrix *matrix) { FILE *f; @@ -13,5 +13,5 @@ fseek (f, 0, SEEK_END); /* write matrix to end of file! */ - status = fits_fwrite_matrix (f, matrix); + status = gfits_fwrite_matrix (f, matrix); fclose (f); return (status); @@ -19,5 +19,5 @@ /*********************** fits write matrix ***********************************/ -int fits_fwrite_matrix (FILE *f, Matrix *matrix) { +int gfits_fwrite_matrix (FILE *f, Matrix *matrix) { int i, status, nbytes, Nbytes; Index: /trunk/Ohana/src/libfits/table/F_create_T.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_create_T.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_create_T.c (revision 7054) @@ -3,14 +3,14 @@ /*********************** fits create table *******************************/ -int fits_create_table (Header *header, FTable *table) { +int gfits_create_table (Header *header, FTable *table) { int Nbytes; char type[80]; - fits_scan (header, "XTENSION", "%s", 1, type); + gfits_scan (header, "XTENSION", "%s", 1, type); table[0].header = header; - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1)); if (!strcmp (type, "TABLE")) { @@ -27,15 +27,15 @@ /*********************** fits create table *******************************/ -int fits_create_vtable (Header *header, VTable *table, int Nrow) { +int gfits_create_vtable (Header *header, VTable *table, int Nrow) { int i, Nx, Ny; char type[80]; - fits_scan (header, "XTENSION", "%s", 1, type); + gfits_scan (header, "XTENSION", "%s", 1, type); table[0].header = header; Nx = table[0].header[0].Naxis[0]; Ny = table[0].header[0].Naxis[0]; - table[0].size = fits_matrix_size (header); + table[0].size = gfits_matrix_size (header); table[0].pad = table[0].size - Nx*Ny; Index: /trunk/Ohana/src/libfits/table/F_create_TH.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_create_TH.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_create_TH.c (revision 7054) @@ -7,5 +7,5 @@ /*********************** fits create Theader *********************************/ -int fits_create_Theader (Header *header, char *type) { +int gfits_create_Theader (Header *header, char *type) { int i; @@ -19,19 +19,19 @@ strncpy (header[0].buffer, "END", 3); - fits_modify (header, "XTENSION", "%s", 1, type); - fits_modify (header, "BITPIX", "%d", 1, header[0].bitpix); - fits_modify (header, "NAXIS", "%d", 1, header[0].Naxes); + gfits_modify (header, "XTENSION", "%s", 1, type); + gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix); + gfits_modify (header, "NAXIS", "%d", 1, header[0].Naxes); for (i = 0; i < header[0].Naxes; i++) { sprintf (axis, "NAXIS%d", i + 1); - fits_modify (header, axis, "%d", 1, header[0].Naxis[i], 1); + gfits_modify (header, axis, "%d", 1, header[0].Naxis[i], 1); } /* PCOUNT & GCOUNT are not implemented, but they are required to be here */ - fits_modify (header, "PCOUNT", "%d", 1, 0); - fits_modify (header, "GCOUNT", "%d", 1, 1); + gfits_modify (header, "PCOUNT", "%d", 1, 0); + gfits_modify (header, "GCOUNT", "%d", 1, 1); if (!strcmp (type, "IMAGE")) { - fits_modify (header, "BSCALE", "%lf", 1, header[0].bscale); - fits_modify (header, "BZERO", "%lf", 1, header[0].bzero); + gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale); + gfits_modify (header, "BZERO", "%lf", 1, header[0].bzero); } @@ -40,5 +40,5 @@ /*********************** fits create table header *********************************/ -int fits_create_table_header (Header *header, char *type, char *extname) { +int gfits_create_table_header (Header *header, char *type, char *extname) { int i, valid; @@ -71,23 +71,23 @@ /* required keywords */ - fits_modify (header, "XTENSION", "%s", 1, type); - fits_modify (header, "BITPIX", "%d", 1, header[0].bitpix); - fits_modify (header, "NAXIS", "%d", 1, header[0].Naxes); + gfits_modify (header, "XTENSION", "%s", 1, type); + gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix); + gfits_modify (header, "NAXIS", "%d", 1, header[0].Naxes); for (i = 0; i < header[0].Naxes; i++) { sprintf (axis, "NAXIS%d", i + 1); - fits_modify (header, axis, "%d", 1, header[0].Naxis[i], 1); + gfits_modify (header, axis, "%d", 1, header[0].Naxis[i], 1); } /* PCOUNT & GCOUNT are not implemented, but they are required to be here */ - fits_modify (header, "PCOUNT", "%d", 1, 0); - fits_modify (header, "GCOUNT", "%d", 1, 1); + gfits_modify (header, "PCOUNT", "%d", 1, 0); + gfits_modify (header, "GCOUNT", "%d", 1, 1); if (!strcmp (type, "IMAGE")) { - fits_modify (header, "BSCALE", "%lf", 1, header[0].bscale); - fits_modify (header, "BZERO", "%lf", 1, header[0].bzero); + gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale); + gfits_modify (header, "BZERO", "%lf", 1, header[0].bzero); } - fits_modify (header, "TFIELDS", "%d", 1, 0); - fits_modify (header, "EXTNAME", "%s", 1, extname); + gfits_modify (header, "TFIELDS", "%d", 1, 0); + gfits_modify (header, "EXTNAME", "%s", 1, extname); return (TRUE); Index: /trunk/Ohana/src/libfits/table/F_define_column.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_define_column.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_define_column.c (revision 7054) @@ -3,32 +3,32 @@ /***********************/ -int fits_define_bintable_column (Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero) { +int gfits_define_bintable_column (Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero) { int Nfields, Nbytes, Nval, Naxis1; char type[16], field[16]; - if (!fits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); + if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); Nfields = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); - fits_scan (header, "NAXIS1", "%d", 1, &Naxis1); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); + gfits_scan (header, "NAXIS1", "%d", 1, &Naxis1); Nfields ++; Naxis1 += Nbytes*Nval; sprintf (field, "TTYPE%d", Nfields); - fits_modify (header, field, "%s", 1, label); - fits_modify (header, field, "%C", 1, comment); + gfits_modify (header, field, "%s", 1, label); + gfits_modify (header, field, "%C", 1, comment); sprintf (field, "TUNIT%d", Nfields); - fits_modify (header, field, "%s", 1, unit); + gfits_modify (header, field, "%s", 1, unit); sprintf (field, "TFORM%d", Nfields); - fits_modify (header, field, "%s", 1, format); + gfits_modify (header, field, "%s", 1, format); sprintf (field, "TSCAL%d", Nfields); - fits_modify (header, field, "%lf", 1, bscale); + gfits_modify (header, field, "%lf", 1, bscale); sprintf (field, "TZERO%d", Nfields); - fits_modify (header, field, "%lf", 1, bzero); + gfits_modify (header, field, "%lf", 1, bzero); /* update TFIELDS & NAXIS1 */ - fits_modify (header, "TFIELDS", "%d", 1, Nfields); - fits_modify (header, "NAXIS1", "%d", 1, Naxis1); + gfits_modify (header, "TFIELDS", "%d", 1, Nfields); + gfits_modify (header, "NAXIS1", "%d", 1, Naxis1); header[0].Naxis[0] = Naxis1; @@ -37,5 +37,5 @@ /***********************/ -int fits_define_table_column (Header *header, char *format, char *label, char *comment, char *unit) { +int gfits_define_table_column (Header *header, char *format, char *label, char *comment, char *unit) { int Nstart, Nfields, Nbytes, Nval, Naxis1; @@ -43,9 +43,9 @@ strcpy (cformat, format); - if (!fits_table_format (cformat, type, &Nval, &Nbytes)) return (FALSE); + if (!gfits_table_format (cformat, type, &Nval, &Nbytes)) return (FALSE); Nfields = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); - fits_scan (header, "NAXIS1", "%d", 1, &Naxis1); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); + gfits_scan (header, "NAXIS1", "%d", 1, &Naxis1); Nstart = Naxis1 + 1; Nfields ++; @@ -53,16 +53,16 @@ sprintf (field, "TTYPE%d", Nfields); - fits_modify (header, field, "%s", 1, label); - fits_modify (header, field, "%C", 1, comment); + gfits_modify (header, field, "%s", 1, label); + gfits_modify (header, field, "%C", 1, comment); sprintf (field, "TUNIT%d", Nfields); - fits_modify (header, field, "%s", 1, unit); + gfits_modify (header, field, "%s", 1, unit); sprintf (field, "TFORM%d", Nfields); - fits_modify (header, field, "%s", 1, format); + gfits_modify (header, field, "%s", 1, format); sprintf (field, "TBCOL%d", Nfields); - fits_modify (header, field, "%d", 1, Nstart); + gfits_modify (header, field, "%d", 1, Nstart); - fits_modify (header, "TFIELDS", "%d", 1, Nfields); - fits_modify (header, "NAXIS1", "%d", 1, Naxis1); + gfits_modify (header, "TFIELDS", "%d", 1, Nfields); + gfits_modify (header, "NAXIS1", "%d", 1, Naxis1); header[0].Naxis[0] = Naxis1; Index: /trunk/Ohana/src/libfits/table/F_free_T.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_free_T.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_free_T.c (revision 7054) @@ -2,5 +2,5 @@ # include -int fits_free_table (FTable *table) { +int gfits_free_table (FTable *table) { if (table[0].buffer == (char *) NULL) return (TRUE); @@ -10,5 +10,5 @@ } -int fits_free_vtable (VTable *table) { +int gfits_free_vtable (VTable *table) { int i; Index: /trunk/Ohana/src/libfits/table/F_get_T_column.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_get_T_column.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_get_T_column.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits get table column *****************************/ -void fits_get_table_column (table, X, mode, values) +void gfits_get_table_column (table, X, mode, values) Table *table; int X; @@ -23,8 +23,8 @@ sprintf (field, "TBCOL%d\0", X); - fits_scan (&table[0].header, field, "%d", &start, 1); + gfits_scan (&table[0].header, field, "%d", &start, 1); start --; sprintf (field, "TFORM%d\0", X); - fits_scan (&table[0].header, field, "%s", Tform, 1); + gfits_scan (&table[0].header, field, "%s", Tform, 1); Nchar = atof (&Tform[1]); Index: /trunk/Ohana/src/libfits/table/F_get_T_value.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_get_T_value.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_get_T_value.c (revision 7054) @@ -4,5 +4,5 @@ /*********************** fits get table value ********************************/ -void fits_get_table_value (table, X, Y, mode, value) +void gfits_get_table_value (table, X, Y, mode, value) Table *table; int X, Y; @@ -17,9 +17,9 @@ sprintf (field, "TBCOL%d\0", X); - fits_scan (&table[0].header, field, "%d", &start, 1); + gfits_scan (&table[0].header, field, "%d", &start, 1); start --; sprintf (field, "TFORM%d\0", X); - fits_scan (&table[0].header, field, "%s", Tform, 1); + gfits_scan (&table[0].header, field, "%s", Tform, 1); Nchar = atof (&Tform[1]); Index: /trunk/Ohana/src/libfits/table/F_get_column.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_get_column.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_get_column.c (revision 7054) @@ -13,5 +13,5 @@ /***********************/ -int fits_get_bintable_column_type (Header *header, char *label, char *type, int *Nval) { +int gfits_get_bintable_column_type (Header *header, char *label, char *type, int *Nval) { int i, N, Nfields, Nbytes; @@ -23,21 +23,21 @@ /* find label in header */ tlabel[0] = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); - for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { - sprintf (field, "TTYPE%d", i); - fits_scan (header, field, "%s", 1, tlabel); - } - if (strcmp (label, tlabel)) return (FALSE); - N = i - 1; - - sprintf (field, "TFORM%d", N); - fits_scan (header, field, "%s", 1, format); - - if (!fits_bintable_format (format, type, Nval, &Nbytes)) return (FALSE); - return (TRUE); -} - -/***********************/ -int fits_get_bintable_column (Header *header, FTable *table, char *label, void **data) { + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); + for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { + sprintf (field, "TTYPE%d", i); + gfits_scan (header, field, "%s", 1, tlabel); + } + if (strcmp (label, tlabel)) return (FALSE); + N = i - 1; + + sprintf (field, "TFORM%d", N); + gfits_scan (header, field, "%s", 1, format); + + if (!gfits_bintable_format (format, type, Nval, &Nbytes)) return (FALSE); + return (TRUE); +} + +/***********************/ +int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) { int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb; @@ -52,8 +52,8 @@ /* find label in header */ tlabel[0] = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); - for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { - sprintf (field, "TTYPE%d", i); - fits_scan (header, field, "%s", 1, tlabel); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); + for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { + sprintf (field, "TTYPE%d", i); + gfits_scan (header, field, "%s", 1, tlabel); } if (strcmp (label, tlabel)) return (FALSE); @@ -65,15 +65,15 @@ /* interpret format */ sprintf (field, "TSCAL%d", Nfields); - fits_scan (header, field, "%lf", 1, &Bscale); + gfits_scan (header, field, "%lf", 1, &Bscale); sprintf (field, "TZERO%d", Nfields); - fits_scan (header, field, "%lf", 1, &Bzero); - sprintf (field, "TFORM%d", N); - fits_scan (header, field, "%s", 1, format); - - if (!fits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); + gfits_scan (header, field, "%lf", 1, &Bzero); + sprintf (field, "TFORM%d", N); + gfits_scan (header, field, "%s", 1, format); + + if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); /* check existing table dimensions */ - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); /* scan columns to find insert point */ @@ -81,6 +81,6 @@ for (i = 1; i < N; i++) { sprintf (field, "TFORM%d", i); - fits_scan (header, field, "%s", 1, format); - fits_bintable_format (format, tmpline, &Nv, &Nb); + gfits_scan (header, field, "%s", 1, format); + gfits_bintable_format (format, tmpline, &Nv, &Nb); Nstart += Nv*Nb; } @@ -163,5 +163,5 @@ /***********************/ -int fits_get_table_column_type (Header *header, char *label, char *type) { +int gfits_get_table_column_type (Header *header, char *label, char *type) { int i, N, Nfields, Nval, Nbytes; @@ -173,8 +173,8 @@ /* find label in header */ tlabel[0] = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); - for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { - sprintf (field, "TTYPE%d", i); - fits_scan (header, field, "%s", 1, tlabel); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); + for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { + sprintf (field, "TTYPE%d", i); + gfits_scan (header, field, "%s", 1, tlabel); } if (strcmp (label, tlabel)) return (FALSE); @@ -183,12 +183,12 @@ /* interpret format */ sprintf (field, "TFORM%d", N); - fits_scan (header, field, "%s", 1, format); - - if (!fits_table_format (format, type, &Nval, &Nbytes)) return (FALSE); - return (TRUE); -} - -/***********************/ -int fits_get_table_column (Header *header, FTable *table, char *label, void **data) { + gfits_scan (header, field, "%s", 1, format); + + if (!gfits_table_format (format, type, &Nval, &Nbytes)) return (FALSE); + return (TRUE); +} + +/***********************/ +int gfits_get_table_column (Header *header, FTable *table, char *label, void **data) { int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb; @@ -202,8 +202,8 @@ /* find label in header */ tlabel[0] = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); - for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { - sprintf (field, "TTYPE%d", i); - fits_scan (header, field, "%s", 1, tlabel); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); + for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { + sprintf (field, "TTYPE%d", i); + gfits_scan (header, field, "%s", 1, tlabel); } if (strcmp (label, tlabel)) return (FALSE); @@ -212,12 +212,12 @@ /* interpret format */ sprintf (field, "TFORM%d", N); - fits_scan (header, field, "%s", 1, format); - - if (!fits_table_format (format, type, &Nval, &Nbytes)) return (FALSE); + gfits_scan (header, field, "%s", 1, format); + + if (!gfits_table_format (format, type, &Nval, &Nbytes)) return (FALSE); strcpy (cformat, format); /* check existing table dimensions */ - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); /* scan columns to find insert point */ @@ -225,6 +225,6 @@ for (i = 1; i < N; i++) { sprintf (field, "TFORM%d", i); - fits_scan (header, field, "%s", 1, format); - fits_table_format (format, tmp, &Nv, &Nb); + gfits_scan (header, field, "%s", 1, format); + gfits_table_format (format, tmp, &Nv, &Nb); Nstart += Nv*Nb; } Index: /trunk/Ohana/src/libfits/table/F_read_T.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_read_T.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_read_T.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits read table ***********************************/ -int fits_read_ftable (char *filename, FTable *table, char *extname) { +int gfits_read_ftable (char *filename, FTable *table, char *extname) { int status; @@ -11,5 +11,5 @@ if (f == NULL) return (FALSE); - status = fits_fread_ftable (f, table, extname); + status = gfits_fread_ftable (f, table, extname); fclose (f); return (status); @@ -17,5 +17,5 @@ /*********************** fits read table ***********************************/ -int fits_fread_ftable (FILE *f, FTable *table, char *extname) { +int gfits_fread_ftable (FILE *f, FTable *table, char *extname) { int j, found, Nbytes; @@ -29,19 +29,19 @@ for (j = -1; !found; j++) { /* load data for this header */ - if (!fits_load_header (f, header)) return (FALSE); + if (!gfits_load_header (f, header)) return (FALSE); /* check if this is the correct extension or not */ bzero (tname, 80); - fits_scan (header, "EXTNAME", "%s", 1, tname); + gfits_scan (header, "EXTNAME", "%s", 1, tname); if (!strcmp (tname, extname)) { - if (fits_fread_ftable_data (f, table)) return (TRUE); - fits_free_header (header); + if (gfits_fread_ftable_data (f, table)) return (TRUE); + gfits_free_header (header); return (FALSE); } /* skip to next header */ - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); fseek (f, Nbytes, SEEK_CUR); - fits_free_header (header); + gfits_free_header (header); } return (TRUE); @@ -49,15 +49,15 @@ /*********************** fits read ftable data ***********************************/ -int fits_fread_ftable_data (FILE *f, FTable *table) { +int gfits_fread_ftable_data (FILE *f, FTable *table) { int Nbytes, Nread; /* find buffer size */ - Nbytes = fits_matrix_size (table[0].header); + Nbytes = gfits_matrix_size (table[0].header); ALLOCATE (table[0].buffer, char, Nbytes); Nread = fread (table[0].buffer, sizeof (char), Nbytes, f); if (Nread != Nbytes) { - fits_free_table (table); + gfits_free_table (table); return (FALSE); } @@ -67,5 +67,5 @@ /*********************** fits read ftable data ***********************************/ -int fits_fread_vtable_range (FILE *f, VTable *table, int start, int Nrows) { +int gfits_fread_vtable_range (FILE *f, VTable *table, int start, int Nrows) { int i, Nbytes, Nread, Nskip, Nx, Ny; @@ -75,5 +75,5 @@ Nx = table[0].header[0].Naxis[0]; Ny = table[0].header[0].Naxis[1]; - table[0].size = fits_matrix_size (table[0].header); + table[0].size = gfits_matrix_size (table[0].header); table[0].pad = table[0].size - Nx*Ny; @@ -105,5 +105,5 @@ /*********************** fits read virtual table ***********************************/ -int fits_fread_vtable (FILE *f, VTable *table, char *extname, int Nrow, int *row) { +int gfits_fread_vtable (FILE *f, VTable *table, char *extname, int Nrow, int *row) { int i, j, Nbytes, Nread; @@ -117,16 +117,16 @@ for (j = -1; TRUE; j++) { /* load data for this header */ - if (!fits_load_header (f, header)) return (FALSE); + if (!gfits_load_header (f, header)) return (FALSE); /* find buffer size */ - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); /* check if this is the correct extension or not */ bzero (tname, 80); - fits_scan (header, "EXTNAME", "%s", 1, tname); + gfits_scan (header, "EXTNAME", "%s", 1, tname); if (strcmp (tname, extname)) { /* skip to next header */ fseek (f, Nbytes, SEEK_CUR); - fits_free_header (header); + gfits_free_header (header); continue; } @@ -134,6 +134,6 @@ /* file pointer is at beginning of desired table data */ start = ftell (f); - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); for (i = 0; i < Nrow; i++) { if (row[i] > Ny) { return (FALSE); } @@ -152,5 +152,5 @@ ALLOCATE (table[0].row, int, MAX (1, Nrow)); for (i = 0; i < Nrow; i++) table[0].row[i] = row[i]; - table[0].size = fits_matrix_size (table[0].header); + table[0].size = gfits_matrix_size (table[0].header); table[0].pad = table[0].size - Nx*Ny; return (TRUE); @@ -162,5 +162,5 @@ /* a poor function: read only the first table, regardless of name */ /* keep until we are sure ohana code does not use it */ -int fits_read_table (char *filename, FTable *table) { +int gfits_read_table (char *filename, FTable *table) { FILE *f; @@ -168,10 +168,10 @@ int status, i, nbytes, Nbytes, matrix_size; - if (!fits_read_header (filename, &header)) { + if (!gfits_read_header (filename, &header)) { fprintf (stderr, "error reading header of FITS file %s\n", filename); return (FALSE); } - if (!fits_read_Theader (filename, &table[0].header)) { + if (!gfits_read_Theader (filename, &table[0].header)) { fprintf (stderr, "error reading Theader of FITS file %s\n", filename); return (FALSE); @@ -179,16 +179,16 @@ if ((f = fopen (filename, "r")) == NULL) { - fits_free_header (&header); - fits_free_header (&table[0].header); - return (FALSE); - } - - matrix_size = fits_matrix_size (&header); + gfits_free_header (&header); + gfits_free_header (&table[0].header); + return (FALSE); + } + + matrix_size = gfits_matrix_size (&header); Nbytes = header.size + matrix_size + table[0].header.size; fseek (f, Nbytes, 0); - fits_free_header (&header); + gfits_free_header (&header); - fits_scan (&table[0].header, "TFIELDS", "%d", 1, &table[0].Nfields); + gfits_scan (&table[0].header, "TFIELDS", "%d", 1, &table[0].Nfields); /* place the field sizes in the structure? */ @@ -198,5 +198,5 @@ table[0].Naxis[i] = table[0].header.Naxis[i]; - Nbytes = fits_matrix_size (&table[0].header); + Nbytes = gfits_matrix_size (&table[0].header); ALLOCATE (table[0].buffer, char, Nbytes); nbytes = fread (table[0].buffer, sizeof(char), Nbytes, f); @@ -213,5 +213,5 @@ -int fits_fread_header_extname (FILE *f, Header *header, char *extname) { +int gfits_fread_header_extname (FILE *f, Header *header, char *extname) { int Nbytes; @@ -219,15 +219,15 @@ fseek (f, 0, SEEK_SET); - fits_fread_header (f, header); + gfits_fread_header (f, header); if (!strcasecmp (extname, "PHU")) return (TRUE); - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); fseek (f, Nbytes, SEEK_CUR); - while (fits_fread_header (f, header)) { - fits_scan (header, "EXTNAME", "%s", 1, current); + while (gfits_fread_header (f, header)) { + gfits_scan (header, "EXTNAME", "%s", 1, current); if (!strcmp (current, extname)) return (TRUE); - Nbytes = fits_matrix_size (header); + Nbytes = gfits_matrix_size (header); fseek (f, Nbytes, SEEK_CUR); } Index: /trunk/Ohana/src/libfits/table/F_read_TH.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_read_TH.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_read_TH.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits read Theader ***********************************/ -int fits_read_Theader (char *filename, Header *Theader) { +int gfits_read_Theader (char *filename, Header *Theader) { FILE *f; @@ -9,5 +9,5 @@ int status, Nbytes; - status = fits_read_header (filename, &header); + status = gfits_read_header (filename, &header); if (!status) { fprintf (stderr, "error reading header of FITS file %s\n", filename); @@ -18,13 +18,13 @@ if (f == NULL) { Theader[0].buffer = NULL; - fits_free_header (&header); + gfits_free_header (&header); return (FALSE); } - Nbytes = fits_matrix_size (&header); + Nbytes = gfits_matrix_size (&header); fseek (f, Nbytes, SEEK_SET); - fits_free_header (&header); + gfits_free_header (&header); - status = fits_load_Theader (f, Theader); + status = gfits_load_Theader (f, Theader); fclose (f); return (status); @@ -33,5 +33,5 @@ /* load table from STREAM positioned at beginning of table header */ /*********************** fits load Theader ***********************************/ -int fits_load_Theader (FILE *f, Header *Theader) { +int gfits_load_Theader (FILE *f, Header *Theader) { char *p; @@ -49,5 +49,5 @@ if (Nbytes != FT_RECORD_SIZE) done = TRUE; - p = fits_header_field (Theader, "END", 1); + p = gfits_header_field (Theader, "END", 1); if (p != NULL) done = TRUE; @@ -60,18 +60,18 @@ status = TRUE; - status &= fits_scan (Theader, "BITPIX", "%d", 1, &Theader[0].bitpix); - status &= fits_scan (Theader, "NAXIS", "%d", 1, &Theader[0].Naxes); + status &= gfits_scan (Theader, "BITPIX", "%d", 1, &Theader[0].bitpix); + status &= gfits_scan (Theader, "NAXIS", "%d", 1, &Theader[0].Naxes); if (!status) return (FALSE); - fits_scan (Theader, "NAXIS1", "%d", 1, &Theader[0].Naxis[0]); - fits_scan (Theader, "NAXIS2", "%d", 1, &Theader[0].Naxis[1]); - fits_scan (Theader, "NAXIS3", "%d", 1, &Theader[0].Naxis[2]); - fits_scan (Theader, "NAXIS4", "%d", 1, &Theader[0].Naxis[3]); - fits_scan (Theader, "NAXIS5", "%d", 1, &Theader[0].Naxis[4]); - fits_scan (Theader, "NAXIS6", "%d", 1, &Theader[0].Naxis[5]); - fits_scan (Theader, "NAXIS7", "%d", 1, &Theader[0].Naxis[6]); - fits_scan (Theader, "NAXIS8", "%d", 1, &Theader[0].Naxis[7]); - fits_scan (Theader, "NAXIS9", "%d", 1, &Theader[0].Naxis[8]); - fits_scan (Theader, "NAXIS10", "%d", 1, &Theader[0].Naxis[9]); + gfits_scan (Theader, "NAXIS1", "%d", 1, &Theader[0].Naxis[0]); + gfits_scan (Theader, "NAXIS2", "%d", 1, &Theader[0].Naxis[1]); + gfits_scan (Theader, "NAXIS3", "%d", 1, &Theader[0].Naxis[2]); + gfits_scan (Theader, "NAXIS4", "%d", 1, &Theader[0].Naxis[3]); + gfits_scan (Theader, "NAXIS5", "%d", 1, &Theader[0].Naxis[4]); + gfits_scan (Theader, "NAXIS6", "%d", 1, &Theader[0].Naxis[5]); + gfits_scan (Theader, "NAXIS7", "%d", 1, &Theader[0].Naxis[6]); + gfits_scan (Theader, "NAXIS8", "%d", 1, &Theader[0].Naxis[7]); + gfits_scan (Theader, "NAXIS9", "%d", 1, &Theader[0].Naxis[8]); + gfits_scan (Theader, "NAXIS10", "%d", 1, &Theader[0].Naxis[9]); return (TRUE); @@ -79,9 +79,9 @@ /*********************** fits fread Theader ***********************************/ -int fits_fread_Theader (FILE *f, Header *Theader) { +int gfits_fread_Theader (FILE *f, Header *Theader) { int status; - status = fits_load_Theader (f, Theader); + status = gfits_load_Theader (f, Theader); return (status); } Index: /trunk/Ohana/src/libfits/table/F_set_column.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_set_column.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_set_column.c (revision 7054) @@ -13,5 +13,5 @@ /***********************/ -int fits_set_bintable_column (Header *header, FTable *table, char *label, void *data, int Nrow) { +int gfits_set_bintable_column (Header *header, FTable *table, char *label, void *data, int Nrow) { int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb; @@ -26,8 +26,8 @@ /* find label in header */ tlabel[0] = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { sprintf (field, "TTYPE%d", i); - fits_scan (header, field, "%s", 1, tlabel); + gfits_scan (header, field, "%s", 1, tlabel); } if (strcmp (label, tlabel)) return (FALSE); @@ -36,21 +36,21 @@ /* interpret format */ sprintf (field, "TSCAL%d", N); - fits_scan (header, field, "%lf", 1, &Bscale); + gfits_scan (header, field, "%lf", 1, &Bscale); sprintf (field, "TZERO%d", N); - fits_scan (header, field, "%lf", 1, &Bzero); + gfits_scan (header, field, "%lf", 1, &Bzero); sprintf (field, "TFORM%d", N); - fits_scan (header, field, "%s", 1, format); - - if (!fits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); + gfits_scan (header, field, "%s", 1, format); + + if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); /* check existing table dimensions */ - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); if (Ny == 0) { Ny = Nrow; header[0].Naxis[1] = Ny; - fits_modify (header, "NAXIS2", "%d", 1, Ny); - - nbytes = fits_matrix_size (header); + gfits_modify (header, "NAXIS2", "%d", 1, Ny); + + nbytes = gfits_matrix_size (header); REALLOCATE (table[0].buffer, char, MAX (nbytes, 1)); bzero (table[0].buffer, nbytes); @@ -63,6 +63,6 @@ for (i = 1; i < N; i++) { sprintf (field, "TFORM%d", i); - fits_scan (header, field, "%s", 1, format); - fits_bintable_format (format, tmpline, &Nv, &Nb); + gfits_scan (header, field, "%s", 1, format); + gfits_bintable_format (format, tmpline, &Nv, &Nb); Nstart += Nv*Nb; } @@ -153,5 +153,5 @@ /***********************/ -int fits_set_table_column (Header *header, FTable *table, char *label, void *data, int Nrow) { +int gfits_set_table_column (Header *header, FTable *table, char *label, void *data, int Nrow) { int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb; @@ -164,8 +164,8 @@ /* find label in header */ tlabel[0] = 0; - fits_scan (header, "TFIELDS", "%d", 1, &Nfields); + gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) { sprintf (field, "TTYPE%d", i); - fits_scan (header, field, "%s", 1, tlabel); + gfits_scan (header, field, "%s", 1, tlabel); } if (strcmp (label, tlabel)) return (FALSE); @@ -174,18 +174,18 @@ /* interpret format */ sprintf (field, "TFORM%d", N); - fits_scan (header, field, "%s", 1, format); - - if (!fits_table_format (format, type, &Nval, &Nbytes)) return (FALSE); + gfits_scan (header, field, "%s", 1, format); + + if (!gfits_table_format (format, type, &Nval, &Nbytes)) return (FALSE); strcpy (cformat, format); /* check existing table dimensions */ - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); if (Ny == 0) { Ny = Nrow; header[0].Naxis[1] = Ny; - fits_modify (header, "NAXIS2", "%d", 1, Ny); - - nbytes = fits_matrix_size (header); + gfits_modify (header, "NAXIS2", "%d", 1, Ny); + + nbytes = gfits_matrix_size (header); REALLOCATE (table[0].buffer, char, MAX (nbytes, 1)); bzero (table[0].buffer, nbytes); @@ -198,6 +198,6 @@ for (i = 1; i < N; i++) { sprintf (field, "TFORM%d", i); - fits_scan (header, field, "%s", 1, format); - fits_table_format (format, tmp, &Nv, &Nb); + gfits_scan (header, field, "%s", 1, format); + gfits_table_format (format, tmp, &Nv, &Nb); Nstart += Nv*Nb; } Index: /trunk/Ohana/src/libfits/table/F_table_column.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_table_column.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_table_column.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits table column ****************************/ -int fits_table_column (Table *table, char *field, char *mode,...) { +int gfits_table_column (Table *table, char *field, char *mode,...) { /* we expect one more field: the pointer to the array we read in */ @@ -19,5 +19,5 @@ for (i = 0; i < table[0].Nfields; i++) { sprintf (string, "TTYPE%d\0", i+1); - fits_scan (&table[0].header, string, "%s", 1, this_field); + gfits_scan (&table[0].header, string, "%s", 1, this_field); if (!strcmp (field, this_field)) { break; @@ -33,7 +33,7 @@ sprintf (string, "TBCOL%d\0", N); - fits_scan (&table[0].header, string, "%d", 1, &start); + gfits_scan (&table[0].header, string, "%d", 1, &start); sprintf (string, "TFORM%d\0", N); - fits_scan (&table[0].header, string, "%s", 1, form); + gfits_scan (&table[0].header, string, "%s", 1, form); /* we could use some error checking from the FITS table form, but it is not immediately crucial */ @@ -43,5 +43,5 @@ } else { sprintf (string, "TBCOL%d\0", N+1); - fits_scan (&table[0].header, string, "%d", 1, &end); + gfits_scan (&table[0].header, string, "%d", 1, &end); } width = end - start; @@ -88,5 +88,5 @@ break; default: - fprintf (stderr, "unknown fits_table_column mode: %s\n", mode); + fprintf (stderr, "unknown gfits_table_column mode: %s\n", mode); return (FALSE); } Index: /trunk/Ohana/src/libfits/table/F_table_format.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_table_format.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_table_format.c (revision 7054) @@ -3,5 +3,5 @@ /***********************/ -int fits_bintable_format (char *format, char *type, int *Nval, int *Nbytes) { +int gfits_bintable_format (char *format, char *type, int *Nval, int *Nbytes) { char *Lchar, *Fchar; @@ -53,5 +53,5 @@ /***********************/ -int fits_table_format (char *format, char *type, int *Nval, int *Nbytes) { +int gfits_table_format (char *format, char *type, int *Nval, int *Nbytes) { char Fchar, Size[80], Type; @@ -90,14 +90,14 @@ /** extract a table subset to a vtable ***/ -int fits_table_to_vtable (FTable *ftable, VTable *vtable, int start, int Nkeep) { +int gfits_table_to_vtable (FTable *ftable, VTable *vtable, int start, int Nkeep) { - /* fits_table_to_vtable (f, v, 0, Ny - 1) - keep all of table - fits_table_to_vtable (f, v, 0, 0) - keep none of table + /* gfits_table_to_vtable (f, v, 0, Ny - 1) - keep all of table + gfits_table_to_vtable (f, v, 0, 0) - keep none of table */ int i, Nx, Ny; - fits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx); - fits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny); if (start + Nkeep > Ny) return (FALSE); @@ -122,10 +122,10 @@ /** convert specified rows to vtable */ -int fits_vtable_from_ftable (FTable *ftable, VTable *vtable, int *row, int Nrow) { +int gfits_vtable_from_ftable (FTable *ftable, VTable *vtable, int *row, int Nrow) { int i, N, Nx, Ny; - fits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx); - fits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny); /* make empty vtable from table */ @@ -150,5 +150,5 @@ /* use table def to format a complete string */ -char *fits_table_print (FTable *table,...) { +char *gfits_table_print (FTable *table,...) { int i, Nx, Nfields; @@ -159,6 +159,6 @@ va_start (argp, table); - fits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx); - fits_scan (table[0].header, "TFIELDS", "%d", 1, &Nfields); + gfits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (table[0].header, "TFIELDS", "%d", 1, &Nfields); ALLOCATE (line, char, Nx + 1); @@ -168,6 +168,6 @@ sprintf (field, "TFORM%d", i); - fits_scan (table[0].header, field, "%s", 1, format); /* get field format */ - fits_table_format (format, type, &Nval, &Nbytes); /* convert to c-style */ + gfits_scan (table[0].header, field, "%s", 1, format); /* get field format */ + gfits_table_format (format, type, &Nval, &Nbytes); /* convert to c-style */ Nchar = Nval * Nbytes; if (!strcmp (type, "int")) { Index: /trunk/Ohana/src/libfits/table/F_table_row.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_table_row.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_table_row.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits table column ****************************/ -int fits_add_rows (FTable *table, char *data, int Nrow, int Nbytes) { +int gfits_add_rows (FTable *table, char *data, int Nrow, int Nbytes) { int Nx, Ny; @@ -11,6 +11,6 @@ header = table[0].header; - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); if (header[0].Naxis[1] != Ny) return (FALSE); @@ -23,7 +23,7 @@ Ny += Nrow; header[0].Naxis[1] = Ny; - fits_modify (header, "NAXIS2", "%d", 1, Ny); + gfits_modify (header, "NAXIS2", "%d", 1, Ny); - nbytes = fits_matrix_size (header); + nbytes = gfits_matrix_size (header); REALLOCATE (table[0].buffer, char, MAX (nbytes, 1)); table[0].size = nbytes; @@ -35,5 +35,5 @@ /*********************** fits add (real) rows to virtual table ****************************/ -int fits_vadd_rows (VTable *table, char *data, int Nrow, int Nbytes) { +int gfits_vadd_rows (VTable *table, char *data, int Nrow, int Nbytes) { int i, Nx, Ny; @@ -43,6 +43,6 @@ header = table[0].header; - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); if (header[0].Naxis[1] != Ny) return (FALSE); @@ -64,7 +64,7 @@ Ny += Nrow; header[0].Naxis[1] = Ny; - fits_modify (header, "NAXIS2", "%d", 1, Ny); + gfits_modify (header, "NAXIS2", "%d", 1, Ny); - table[0].size = fits_matrix_size (table[0].header); + table[0].size = gfits_matrix_size (table[0].header); table[0].pad = table[0].size - Nx*Ny; @@ -73,5 +73,5 @@ /*********************** fits table column ****************************/ -int fits_delete_rows (FTable *table, int Nstart, int Nrow) { +int gfits_delete_rows (FTable *table, int Nstart, int Nrow) { int Nx, Ny, N0, N1, N2; @@ -81,6 +81,6 @@ header = table[0].header; - fits_scan (header, "NAXIS1", "%d", 1, &Nx); - fits_scan (header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (header, "NAXIS2", "%d", 1, &Ny); if (header[0].Naxis[1] != Ny) return (FALSE); @@ -97,7 +97,7 @@ Ny -= Nrow; header[0].Naxis[1] = Ny; - fits_modify (header, "NAXIS2", "%d", 1, Ny); + gfits_modify (header, "NAXIS2", "%d", 1, Ny); - nbytes = fits_matrix_size (header); + nbytes = gfits_matrix_size (header); REALLOCATE (table[0].buffer, char, MAX (nbytes, 1)); table[0].size = nbytes; Index: /trunk/Ohana/src/libfits/table/F_write_T.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_write_T.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_write_T.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits write header *********************************/ -int fits_write_table (char *filename, FTable *table) { +int gfits_write_table (char *filename, FTable *table) { FILE *f; @@ -14,5 +14,5 @@ status = fseek (f, 0, SEEK_END); /* write table to end of file! */ - status = fits_fwrite_table (f, table); + status = gfits_fwrite_table (f, table); fclose (f); @@ -21,5 +21,5 @@ /*********************** fits write table *********************************/ -int fits_fwrite_table (FILE *f, FTable *table) { +int gfits_fwrite_table (FILE *f, FTable *table) { int Nbytes; @@ -32,5 +32,5 @@ /*********************** fits write virtual table *********************************/ -int fits_fwrite_vtable (FILE *f, VTable *table) { +int gfits_fwrite_vtable (FILE *f, VTable *table) { int i, Nx, Ny, Npad, offset, start; @@ -40,6 +40,6 @@ Nrow = table[0].Nrow; row = table[0].row; - fits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx); - fits_scan (table[0].header, "NAXIS2", "%d", 1, &Ny); + gfits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx); + gfits_scan (table[0].header, "NAXIS2", "%d", 1, &Ny); /* file pointer is at beginning of desired table data */ Index: /trunk/Ohana/src/libfits/table/F_write_TH.c =================================================================== --- /trunk/Ohana/src/libfits/table/F_write_TH.c (revision 7053) +++ /trunk/Ohana/src/libfits/table/F_write_TH.c (revision 7054) @@ -3,5 +3,5 @@ /*********************** fits write header *********************************/ -int fits_write_Theader (char *filename, Header *header) { +int gfits_write_Theader (char *filename, Header *header) { FILE *f; @@ -14,5 +14,5 @@ status = fseek (f, 0, SEEK_END); /* write header to end of file! */ - status = fits_fwrite_Theader (f, header); + status = gfits_fwrite_Theader (f, header); fclose (f); @@ -21,5 +21,5 @@ /*********************** fits write header *********************************/ -int fits_fwrite_Theader (FILE *f, Header *header) { +int gfits_fwrite_Theader (FILE *f, Header *header) { int Nbytes;