Index: /branches/eam_branch_20071130/Ohana/src/addstar/src/addstar.c
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/addstar/src/addstar.c	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/addstar/src/addstar.c	(revision 15731)
@@ -90,5 +90,5 @@
     catalog.catflags  = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
     catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
-    if (options.update) catalog.catflags = LOAD_AVES | LOAD_MEAS_META | LOAD_MISS | LOAD_SECF;
+    if (options.update) catalog.catflags = LOAD_AVES | LOAD_MISS | LOAD_SECF;
 
     // open as read or write, depending on desire
@@ -142,5 +142,9 @@
     if (Nsubset && !options.only_images) {
       SetProtect (TRUE);
-      dvo_catalog_save (&catalog, VERBOSE);
+      if (options.update) {
+	dvo_catalog_update (&catalog, VERBOSE);
+      } else {
+	dvo_catalog_save (&catalog, VERBOSE);
+      }
       SetProtect (FALSE);
     }
Index: /branches/eam_branch_20071130/Ohana/src/libdvo/include/dvo.h
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/libdvo/include/dvo.h	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/libdvo/include/dvo.h	(revision 15731)
@@ -23,5 +23,5 @@
 typedef enum {M_UNDEF = -1, M_NONE, M_MEF, M_SPLIT, M_SINGLE, M_CUBE, M_SLICE, M_MODES, N_MODE} ElixirDetrendModes;
 
-typedef enum {DVO_CAT_OPEN_FAIL, DVO_CAT_OPEN_OK, DVO_CAT_OPEN_EMPTY};
+typedef enum {DVO_CAT_OPEN_FAIL, DVO_CAT_OPEN_OK, DVO_CAT_OPEN_EMPTY} DVOCatalogOpenModes;
 
 typedef enum {
Index: /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog.c
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog.c	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog.c	(revision 15731)
@@ -90,9 +90,15 @@
   catalog[0].Nmeasure = 0;
   catalog[0].Nmissing = 0;
-
-  catalog[0].Nave_disk  = 0;
+  catalog[0].Nsecf_mem = 0;
+
+  catalog[0].Naves_disk = 0;
   catalog[0].Nmeas_disk = 0;
   catalog[0].Nmiss_disk = 0;
+  catalog[0].Nsecf_disk = 0;
+
+  catalog[0].Naves_off  = 0;
   catalog[0].Nmeas_off  = 0;
+  catalog[0].Nmiss_off  = 0;
+  catalog[0].Nsecf_off  = 0;
 
   /* pointers to SPLIT data files */
@@ -269,6 +275,7 @@
 }
 
-// write out the data, unlink if empty?
-// XXX consider conditions in which we can allow a save...
+// write out the data, unlink if empty?  'save' means: write out all data currently in
+// memory.  NOTE: this is currently not always possible: for non-SPLIT moe files, this
+// operation may require expanding the file size, which does not automatically happen
 int dvo_catalog_save (Catalog *catalog, char VERBOSE) {
 
@@ -294,32 +301,22 @@
 }
 
-# if (0)
-// XXX deprecate this function: choice of update or not is made in dvo_catalog_save_split, etc
+// write out the in-memory data which extends beyond the data on disk.  NOTE: this is
+// currently only possible for the SPLIT mode.
 int dvo_catalog_update (Catalog *catalog, char VERBOSE) {
 
-  // even if the data is sorted on disk, if we only load the MEAS_META, we are
-  // treating it as unsorted (eg, append only)
-  // XXX deprecate this statement?
-  XXX: 
-  check on this;
-  if (catalog[0].catflags & LOAD_MEAS_META) {
-      catalog[0].sorted = FALSE;
-  }
+  // set the 'sorted' header keyword
+  catalog[0].sorted = FALSE;
+  gfits_modify (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
 
   /* update is only valid for catmode SPLIT */
   switch (catalog[0].catmode) {
     case DVO_MODE_RAW:
-      dvo_catalog_save_raw (catalog, VERBOSE);
+      fprintf (stderr, "not allowed for RAW mode\n");
       break;
     case DVO_MODE_MEF:
-      dvo_catalog_save_mef (catalog, VERBOSE);
+      fprintf (stderr, "not allowed for MEF mode\n");
       break;
     case DVO_MODE_SPLIT:
-      /* new file needs to use save_catalog_split */
-      if (catalog[0].Nave_disk == 0) {
-	dvo_catalog_save_split (catalog, VERBOSE);
-      } else {
-	dvo_catalog_update_split (catalog, VERBOSE);
-      }
+      dvo_catalog_update_split (catalog, VERBOSE);
       break;
     default:
@@ -330,5 +327,4 @@
   return (TRUE);
 }
-# endif
 
 int dvo_catalog_check (Catalog *catalog, int Nsecfilt, int extend) {
Index: /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog_raw.c
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog_raw.c	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog_raw.c	(revision 15731)
@@ -201,5 +201,5 @@
 
   /* save the current number so we can do partial updates */
-  catalog[0].Nave_disk  = catalog[0].Naverage;
+  catalog[0].Naves_disk = catalog[0].Naverage;
   catalog[0].Nmeas_disk = catalog[0].Nmeasure;
   catalog[0].Nmiss_disk = catalog[0].Nmissing;
Index: /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog_split.c
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog_split.c	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/libdvo/src/dvo_catalog_split.c	(revision 15731)
@@ -6,8 +6,76 @@
 // * ok
 
-int dvo_catalog_open_subcat (Catalog *catalog, Catalog **Subcat, char *name, int VERBOSE) {
-
-  char *path;
+int dvo_catalog_secfilt_to_primary (Catalog *catalog, SecFilt **myPrimary, SecFilt **mySecfilt, int *myNsecfilt) {
+
+  int i, j, Nallfilt, Nsecfilt, Ntotal;
+
+  SecFilt *primary;
+  SecFilt *secfilt;
+
+  if (catalog[0].secfilt == NULL) {       
+    fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c)\n");
+    exit (1);
+  }
+  secfilt = catalog[0].secfilt;
+
+  // XXX this translation only works if we have loaded / created a matched average/secfilt set
+  assert (catalog[0].Nsecf_mem == catalog[0].Nsecfilt*catalog[0].Naverage);
+
+  Nallfilt = catalog[0].Nsecfilt;
+  Nsecfilt = catalog[0].Nsecfilt - 1;
+  Ntotal = Nsecfilt * catalog[0].Naverage;
+  ALLOCATE (primary, SecFilt, catalog[0].Naverage);
+  ALLOCATE (secfilt, SecFilt, Ntotal);
+
+  for (i = 0; i < catalog[0].Naverage; i++) {
+    primary[i] = secfilt[i*Nallfilt + 0];
+    for (j = 0; j < Nsecfilt; j++) {
+      secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
+    }
+  }		
+  catalog[0].Nsecfilt --;
+  catalog[0].Nsecf_mem = catalog[0].Naverage*catalog[0].Nsecfilt;
+
+  *myPrimary = primary;
+  *mySecfilt = secfilt;
+  *myNsecfilt = Nsecfilt;
+}
+
+int dvo_catalog_save_subcat (Catalog *catalog, FTable *ftable, int start, int Nrows, int Ndisk, int Ntotal) {
+
+  Matrix matrix;
+
+  /* rewind file pointers and truncate (file is still open) */
+  fseek (catalog->f, 0, SEEK_SET);
+
+  // write PHU header
+  if (!gfits_fwrite_header  (catalog->f, &catalog->header)) {
+    fprintf (stderr, "can't write primary header");
+    return (FALSE);
+  }
+
+  // write the PHU matrix; this is probably a NOP, do I have to keep it in?
+  gfits_create_matrix (&catalog->header, &matrix);
+  if (!gfits_fwrite_matrix  (catalog->f, &matrix)) {
+    fprintf (stderr, "can't write primary matrix");
+    gfits_free_matrix (&matrix);
+    return (FALSE);
+  }
+  gfits_free_matrix (&matrix);
+
+  // write the table data
+  if (!gfits_fwrite_ftable_range (catalog->f, ftable, start, Nrows, Ndisk, Ntotal)) {
+    fprintf (stderr, "can't write table data");
+    return (FALSE);
+  }
+  return (TRUE);
+}
+
+int dvo_catalog_open_subcat (Catalog *catalog, Catalog **Subcat, Header *header, char *name, int VERBOSE) {
+
+  int status;
+  char *path, string[80];
   Catalog *subcat;
+  Matrix matrix;
 
   /* in split mode, we need to init & open the corresponding measure file (even if we do not read
@@ -47,6 +115,7 @@
     return (DVO_CAT_OPEN_FAIL);
   }
+  gfits_free_matrix (&matrix);
   /* read Measure table header */
-  if (!gfits_fread_header (subcat[0].f, &header)) {
+  if (!gfits_fread_header (subcat[0].f, header)) {
     if (VERBOSE) fprintf (stderr, "can't read %s PHU header\n", name);
     return (DVO_CAT_OPEN_FAIL);
@@ -68,4 +137,6 @@
   /* ftable header storage for below */
   ftable.header = &header;
+  ftable.buffer = NULL;
+  header.buffer = NULL;
 
   /* needed to find the split files below */
@@ -130,5 +201,5 @@
 
   /*** Measure Table ***/
-  status = dvo_catalog_open_subcat (catalog, &catalog[0].measure_catalog, "MEASURE");
+  status = dvo_catalog_open_subcat (catalog, &catalog[0].measure_catalog, ftable.header, "MEASURE", VERBOSE);
   if (status == DVO_CAT_OPEN_FAIL) {
     return (FALSE);
@@ -149,6 +220,4 @@
       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, catalog[0].Nmeas_disk);
     }
-    gfits_free_header (&header);
-    gfits_free_matrix (&matrix);
     catalog[0].Nmeasure = catalog[0].Nmeas_disk;
     catalog[0].Nmeas_off = 0;
@@ -160,11 +229,12 @@
     catalog[0].Nmeas_off = catalog[0].Nmeas_disk;
   }
+  gfits_free_header (ftable.header);
 
   /*** Missing Table ***/
-  status = dvo_catalog_open_subcat (catalog, &catalog[0].missing_catalog, "MISSING");
+  status = dvo_catalog_open_subcat (catalog, &catalog[0].missing_catalog, ftable.header, "MISSING", VERBOSE);
   if (status == DVO_CAT_OPEN_FAIL) {
     return (FALSE);
   }
-  if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nmeas_disk > 0)) {
+  if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nmiss_disk > 0)) {
     return (FALSE);
   }
@@ -180,6 +250,4 @@
       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, catalog[0].Nmiss_disk);
     }
-    gfits_free_header (&header);
-    gfits_free_matrix (&matrix);
     catalog[0].Nmissing = catalog[0].Nmiss_disk;
     catalog[0].Nmiss_off = 0;
@@ -191,7 +259,8 @@
     catalog[0].Nmiss_off = catalog[0].Nmiss_disk;
   }
+  gfits_free_header (ftable.header);
 
   /*** Secfilt Table ***/
-  status = dvo_catalog_open_subcat (catalog, &catalog[0].secfilt_catalog, "SECFILT");
+  status = dvo_catalog_open_subcat (catalog, &catalog[0].secfilt_catalog, ftable.header, "SECFILT", VERBOSE);
   if (status == DVO_CAT_OPEN_FAIL) {
     return (FALSE);
@@ -202,5 +271,5 @@
   if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_SECF)) {
     /* read secfilt table data */
-    if (!gfits_fread_ftable_data (secfilt[0].f, &ftable)) {
+    if (!gfits_fread_ftable_data (catalog[0].secfilt_catalog[0].f, &ftable)) {
       if (VERBOSE) fprintf (stderr, "can't read table secfilt data\n");
       return (FALSE);
@@ -218,7 +287,10 @@
       tmpfilt  = catalog[0].secfilt;
       Ntmpfilt = catalog[0].Nsecfilt;
-      Nsecfilt = catalog[0].Nsecfilt + 1;
-      Ntotal = Nsecfilt * catalog[0].Naves_disk;
-      ALLOCATE (catalog[0].secfilt, SecFilt, Ntotal);
+
+      catalog[0].Nsecfilt ++;
+      catalog[0].Nsecf_disk = catalog[0].Nsecfilt * catalog[0].Naves_disk;
+      Nsecfilt = catalog[0].Nsecfilt;
+
+      ALLOCATE (catalog[0].secfilt, SecFilt, catalog[0].Nsecf_disk);
       for (i = 0; i < catalog[0].Naves_disk; i++) {
 	catalog[0].secfilt[i*Nsecfilt + 0] = primary[i];
@@ -227,10 +299,6 @@
 	}
       }		
-      catalog[0].Nsecfilt = Nsecfilt;
-      catalog[0].Nsecf_disk = Ntotal;
       free (primary);
     } 
-    gfits_free_header (&header);
-    gfits_free_matrix (&matrix);
     catalog[0].Nsecf_mem = catalog[0].Nsecf_disk;
     catalog[0].Nsecf_off = 0;
@@ -246,4 +314,5 @@
     catalog[0].Nsecf_off = catalog[0].Nsecf_disk;
   }
+  gfits_free_header (ftable.header);
 
   return (TRUE);
@@ -252,10 +321,16 @@
 // I need to always read both average and secfilt at the same time to correctly manage the
 // primary secfilt values...
-
-// XXX merge these? use the mode to choose which component?
-
-int dvo_catalog_load_segment_split_average (Catalog *catalog, int start, int Nrows) {
-
-  // XXX check the open status of the FILE *f?
+int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, int start, int Nrows) {
+
+  int Naverage, Nsecfilt, Nexpect, Nitems, Nmeasure, Nmissing;
+  Header header;
+  Matrix matrix;
+  VTable vtable;
+  SecFilt *primary;
+
+  /* vtable header storage for below */
+  vtable.header = &header;
+  vtable.buffer = NULL;
+  header.buffer = NULL;
 
   /*** Average (& SecFilt) Table ***/
@@ -286,5 +361,5 @@
 
     // XXX Vtable version is needed (merge Ftable and Vtable versions?)
-    catalog[0].average = VtableToAverage (&ftable, &Naverage, &catalog[0].catformat, &primary);
+    catalog[0].average = VtableToAverage (&vtable, &Naverage, &catalog[0].catformat, &primary);
 
     // XXX validate the sizes?  start + Nrows < Naves_disk (no other constraints)
@@ -326,5 +401,5 @@
        we need to interleave these magnitudes with the secfilt entries just loaded */
     if (primary != NULL) {
-      int Ntmpfilt, Ntotal, i, j;
+      int Ntmpfilt, i, j;
       SecFilt *tmpfilt;
       tmpfilt  = catalog[0].secfilt;
@@ -425,5 +500,5 @@
 }
 
-/* save_catalog_split writes complete new files from scratch */
+/* save_catalog_split writes all data currently in memory to disk */
 int dvo_catalog_save_split (Catalog *catalog, char VERBOSE) {
 
@@ -435,91 +510,79 @@
   SecFilt *primary, *secfilt;
   int i, j, Nsecfilt, Nallfilt, Ntotal;
+  int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
+  int first, start, Nrows;
 
   ftable.header = &header;
-
-  if (catalog[0].Naverage == 0) {
+  ftable.buffer = NULL;
+  header.buffer = NULL;
+  
+  // skip empty catalogs: it is illegal to have Measures without corresponding Averages
+  Naves_disk_new = MAX (catalog[0].Naves_disk, catalog[0].Naverage + catalog[0].Naves_off);
+  if (Naves_disk_new == 0) {
     if (VERBOSE) fprintf (stderr, "no stars in catalog, skipping\n");
     return (TRUE);
   }
 
-  /* for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary */
-  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || // special case for ELIXIR
-      (catalog[0].catformat == DVO_FORMAT_LONEOS)) { // special case for LONEOS
-    if (catalog[0].secfilt == NULL) {       
-      fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c)\n");
-      exit (1);
-    }
-    secfilt = catalog[0].secfilt;
-
-    // XXX this translation only works if we have loaded / created a matched average/secfilt set
-    assert (catalog[0].Nsecf_mem == catalog[0].Nsecfilt*catalog[0].Naverage);
-
-    Nallfilt = catalog[0].Nsecfilt;
-    Nsecfilt = catalog[0].Nsecfilt - 1;
-    Ntotal = Nsecfilt * catalog[0].Naverage;
-    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
-    ALLOCATE (secfilt, SecFilt, Ntotal);
-
-    for (i = 0; i < catalog[0].Naverage; i++) {
-      primary[i] = secfilt[i*Nallfilt + 0];
-      for (j = 0; j < Nsecfilt; j++) {
-	secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
-      }
-    }		
-    catalog[0].Nsecfilt --;
-    catalog[0].Nsecf_mem = catalog[0].Naverage*catalog[0].Nsecfilt;
-  } else {
-    primary = NULL;
-    secfilt = catalog[0].secfilt;
-    Nsecfilt = catalog[0].Nsecfilt;
-  }
+  // for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary
+  switch (catalog[0].catformat) {
+    case DVO_FORMAT_ELIXIR: // special case for ELIXIR
+    case DVO_FORMAT_LONEOS: // special case for LONEOS
+      dvo_catalog_secfilt_to_primary (catalog, &primary, &secfilt, &Nsecfilt);
+      break;
+    default:
+      primary = NULL;
+      secfilt = catalog[0].secfilt;
+      Nsecfilt = catalog[0].Nsecfilt;
+      break;
+  }
+
+  Nmeas_disk_new = MAX (catalog[0].Nmeas_disk, catalog[0].Nmeasure + catalog[0].Nmeas_off);
+  Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off);
+  Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off);
 
   /* make sure header is consistent with data */
-  gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
-  gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure);
-  gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
+  gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
+  gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
+  gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
   gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
 
-  /* rewind file pointers and truncate (file is still open) */
-  fseek (catalog[0].f, 0, SEEK_SET);
-
-  /* write table PHU header - always write this out */
-  /* XXX EAM : check if disk file size has changed */
-  if (!gfits_fwrite_header  (catalog[0].f, &catalog[0].header)) {
-    fprintf (stderr, "can't write primary header");
-    goto failure;
-  }
-
   /* in split mode, we can save only part of the data */ 
 
   /*** Average Table ***/
-
   if (catalog[0].average != NULL) {
-    ftruncate (fileno (catalog[0].f), catalog[0].header.size);
-
-    /* this is probably a NOP, do I have to keep it in? */
-    gfits_create_matrix (&catalog[0].header, &matrix);
-    if (!gfits_fwrite_matrix  (catalog[0].f, &matrix)) {
-      fprintf (stderr, "can't write primary matrix");
-      goto failure;
-    }
-    gfits_free_matrix (&matrix);
-
-    /* write out Average table (convert to FITS table format) */
-    if (!AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary)) {
+
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Naves_off; // first disk row to write
+    Nrows  = catalog[0].Naverage - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first < catalog[0].Naverage);
+    assert (catalog[0].Naves_disk >= catalog[0].Naves_off);
+
+    /* convert internal to external format */
+    if (!AverageToFtable (&ftable, &catalog[0].average[first], Nrows, catalog[0].catformat, primary)) {
       fprintf (stderr, "trouble converting format\n");
       goto failure;
     }
-    if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
+
+    if (!dvo_catalog_save_subset (catalog, ftable, start, Nrows, catalog[0].Naves_disk, Naves_disk_new)) {
+      fprintf (stderr, "failure writing Average table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
+  } else {
+    // even if we do not save the average table, we need to keep the header in sync
+    /* rewind file pointers and truncate (file is still open) */
+    fseek (catalog[0].f, 0, SEEK_SET);
+
+    /* write table PHU header - always write this out */
+    /* XXX EAM : check if disk file size has changed */
+    if (!gfits_fwrite_header  (catalog[0].f, &catalog[0].header)) {
+      fprintf (stderr, "can't write primary header");
+      goto failure;
+    }
   }
 
@@ -527,43 +590,26 @@
   if (catalog[0].measure != NULL) {
 
-    /* catalog file data is stored in separate structure */
-    catfile = catalog[0].measure_catalog;
-
-    /* XXX EAM : warn about this condition; add code to handle? */
-    if (catalog[0].Nmeas_off != 0) {
-      fprintf (stderr, "WARNING: LOAD_MEAS_META mixed with save??\n");
-      fprintf (stderr, "WARNING: this should not be allowed to happen!\n");
-    }
-
-    /* rewind file pointers and truncate (file is still open) */
-    fseek (catfile[0].f, 0, SEEK_SET);
-    ftruncate (fileno (catfile[0].f), 0);
-
-    /* write table PHU header */
-    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
-      fprintf (stderr, "can't write primary header");
-      goto failure;
-    }
-
-    /* this is probably a NOP, do I have to keep it in? */
-    gfits_create_matrix (&catfile[0].header, &matrix);
-    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
-      fprintf (stderr, "can't write primary matrix");
-      goto failure;
-    }
-    gfits_free_matrix (&matrix);
-
-    /* write out Measure table (convert to FITS table format) */
-    MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
-    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nmeas_off; // first disk row to write
+    Nrows  = catalog[0].Nmeasure - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first < catalog[0].Nmeasure);
+    assert (catalog[0].Nmeas_disk >= catalog[0].Nmeas_off);
+
+    // convert to external table format
+    if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Measure table
+    if (!dvo_catalog_save_subset (catalog[0].measure_catalog, ftable, start, Nrows, catalog[0].Nmeas_disk, Nmeas_disk_new)) {
+      fprintf (stderr, "trouble writing Measure table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
   }
 
@@ -571,37 +617,22 @@
   if (catalog[0].missing != NULL) {
 
-    /* catalog data is stored in separate catalog */
-    catfile = catalog[0].missing_catalog;
-
-    /* rewind file pointers and truncate (file is still open) */
-    fseek (catfile[0].f, 0, SEEK_SET);
-    ftruncate (fileno (catfile[0].f), 0);
-
-    /* write table PHU header */
-    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
-      fprintf (stderr, "can't write primary header");
-      goto failure;
-    }
-
-    /* this is probably a NOP, do I have to keep it in? */
-    gfits_create_matrix (&catfile[0].header, &matrix);
-    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
-      fprintf (stderr, "can't write primary matrix");
-      goto failure;
-    }
-    gfits_free_matrix (&matrix);
-
-    /* write out Missing table (convert to FITS table format) */
-    gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing);
-    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
+    if (catalog[0].Nmiss_off != 0) {
+      fprintf (stderr, "inconsistency: Missing table cannot be written in segments\n");
+      goto failure;
+    }
+
+    // convert to external table format
+    if (!gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Missing table (must write out entire table)
+    if (!dvo_catalog_save_subset (catalog[0].missing_catalog, ftable, 0, catalog[0].Nmissing, catalog[0].Nmissing, catalog[0].Nmissing)) {
+      fprintf (stderr, "trouble writing Missing Table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
   }
 
@@ -609,38 +640,24 @@
   if (catalog[0].secfilt != NULL) {
 
-    /* catalog file data is stored in a separate catalog structure */
-    catfile = catalog[0].secfilt_catalog;
-
-    /* rewind file pointers and truncate (file is still open) */
-    fseek (catfile[0].f, 0, SEEK_SET);
-    ftruncate (fileno (catfile[0].f), 0);
-
-    /* write table PHU header */
-    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
-      fprintf (stderr, "can't write primary header");
-      goto failure;
-    }
-
-    /* this is probably a NOP, do I have to keep it in? */
-    gfits_create_matrix (&catfile[0].header, &matrix);
-    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
-      fprintf (stderr, "can't write primary matrix");
-      goto failure;
-    }
-    gfits_free_matrix (&matrix);
-
-    /* write out SecFilt table (convert to FITS table format) */
-    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
-    SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
-    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nsecf_off; // first disk row to write
+    Nitems = catalog[0].Nsecf_mem;
+    Nrows  = Nitems - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first < Nitems);
+    assert (catalog[0].Nsecf_disk >= catalog[0].Nsecf_off);
+
+    // convert to external table format
+    SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat);
+
+    // write out SecFilt table
+    if (!dvo_catalog_save_subset (catalog[0].secfilt_catalog, ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
+      fprintf (stderr, "failure writing SecFilt table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
   }
 
@@ -650,9 +667,10 @@
     free (secfilt);
   }
-
   return (TRUE);
 
 failure:
   /* free temp storage */
+  gfits_free_header (&header);
+  gfits_free_table (&ftable);
   if (primary != NULL) {
     free (primary);
@@ -662,9 +680,5 @@
 }
 
-/* update_catalog_split only writes new lines to file.  
- * if file is empty, call save_catalog_split instead.
- * XXX EAM : save_catalog SHOULD do this
- */
-
+/* update_catalog_split only writes new lines to file. */
 int dvo_catalog_update_split (Catalog *catalog, char VERBOSE) {
 
@@ -678,83 +692,79 @@
   SecFilt *primary, *secfilt;
   int j, Nsecfilt, Nallfilt, Ntotal;
+  int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
+  int first, start, Nrows;
 
   ftable.header = &header;
-  vtable.header = &header;
-
-  if (catalog[0].Naverage == 0) {
+  ftable.buffer = NULL;
+  header.buffer = NULL;
+
+  // skip empty catalogs: it is illegal to have Measures without corresponding Averages
+  Naves_disk_new = MAX (catalog[0].Naves_disk, catalog[0].Naverage + catalog[0].Naves_off);
+  if (Naves_disk_new == 0) {
     if (VERBOSE) fprintf (stderr, "no stars in catalog, skipping\n");
     return (TRUE);
   }
 
-  /** for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary **/
-  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || // special case for ELIXIR
-      (catalog[0].catformat == DVO_FORMAT_LONEOS)) { // special case for LONEOS
-    if (catalog[0].secfilt == NULL) { 
-      fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c:544)\n");
-      exit (1);
-    }
-    secfilt = catalog[0].secfilt;
-
-    Nallfilt = catalog[0].Nsecfilt;
-    Nsecfilt = catalog[0].Nsecfilt - 1;
-    Ntotal = Nsecfilt * catalog[0].Naverage;
-    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
-    ALLOCATE (secfilt, SecFilt, Ntotal);
-
-    for (i = 0; i < catalog[0].Naverage; i++) {
-      primary[i] = secfilt[i*Nallfilt + 0];
-      for (j = 0; j < Nsecfilt; j++) {
-	secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
-      }
-    }		
-  } else {
-    primary = NULL;
-    secfilt = catalog[0].secfilt;
-    Nsecfilt = catalog[0].Nsecfilt;
-  }
+  // for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary 
+  switch (catalog[0].catformat) {
+    case DVO_FORMAT_ELIXIR: // special case for ELIXIR
+    case DVO_FORMAT_LONEOS: // special case for LONEOS
+      dvo_catalog_secfilt_to_primary (catalog, &primary, &secfilt, &Nsecfilt);
+      break;
+    default:
+      primary = NULL;
+      secfilt = catalog[0].secfilt;
+      Nsecfilt = catalog[0].Nsecfilt;
+      break;
+  }
+
+  Nmeas_disk_new = MAX (catalog[0].Nmeas_disk, catalog[0].Nmeasure + catalog[0].Nmeas_off);
+  Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off);
+  Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off);
 
   /* make sure header is consistent with data */
-  gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
-  gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure + catalog[0].Nmeas_off);
-  gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
+  gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
+  gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
+  gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
   gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
 
-  /* rewind file pointers and truncate (file is still open) */
-  fseek (catalog[0].f, 0, SEEK_SET);
-
-  /* write table PHU header - always write this out */
-  /* XXX EAM : check if disk file size has changed */
-  if (!gfits_fwrite_header  (catalog[0].f, &catalog[0].header)) {
-    fprintf (stderr, "can't write primary header");
-    goto failure;
-  }
+  /* in split mode, we can save only part of the data */ 
 
   /*** Average Table ***/
   if (catalog[0].average != NULL) {
 
-    /* skip past matrix (already at end of header) */
-    Nskip = gfits_data_size (&catalog[0].header);
-    fseek (catalog[0].f, Nskip, SEEK_CUR);
-
-    /* how many lines to write out? */
-    Nout = catalog[0].Naverage - catalog[0].Nave_disk;
-
-    /* write out Average table (convert to FITS table format) */
-    AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
-    /* convert only output rows to vtable */
-    gfits_table_to_vtable (&ftable, &vtable, catalog[0].Nave_disk, Nout);
-
-    if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_vtable (catalog[0].f, &vtable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
-    gfits_free_vtable (&vtable);
+    first  = catalog[0].Naves_disk - catalog[0].Naves_off; // first row to write (memory)
+    start  = catalog[0].Naves_disk;                        // first row to write (disk)
+    Nrows  = catalog[0].Naverage - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first < catalog[0].Naverage);
+    assert (catalog[0].Naves_disk >= catalog[0].Naves_off);
+
+    /* convert internal to external format */
+    if (!AverageToFtable (&ftable, &catalog[0].average[first], Nrows, catalog[0].catformat, primary)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    if (!dvo_catalog_save_subset (catalog, ftable, start, Nrows, catalog[0].Naves_disk, Naves_disk_new)) {
+      fprintf (stderr, "failure writing Average table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
+  } else {
+    // even if we do not save the average table, we need to keep the header in sync
+    /* rewind file pointers and truncate (file is still open) */
+    fseek (catalog[0].f, 0, SEEK_SET);
+
+    /* write table PHU header - always write this out */
+    /* XXX EAM : check if disk file size has changed */
+    if (!gfits_fwrite_header  (catalog[0].f, &catalog[0].header)) {
+      fprintf (stderr, "can't write primary header");
+      goto failure;
+    }
   }
 
@@ -762,89 +772,53 @@
   if (catalog[0].measure != NULL) {
 
-    catfile = catalog[0].measure_catalog;
-
-    /* skip past PHU header and matrix */
-    Nskip = catfile[0].header.size + gfits_data_size (&catfile[0].header);
-    fseek (catfile[0].f, Nskip, SEEK_SET);
-
-    Ndisk  = catalog[0].Nmeas_disk;
-    Nstart = catalog[0].Nmeas_disk - catalog[0].Nmeas_off; /* where is first new line? */
-    Nout   = catalog[0].Nmeasure - Nstart;                   /* how many lines to write out? */
-    Nlines = catalog[0].Nmeasure + catalog[0].Nmeas_off;   /* how many lines total in file */
-
-    /* convert to output format FITS table (only rows for output : 0 - Nout) */
-    MeasureToFtable (&ftable, &catalog[0].measure[Nstart], Nout, catalog[0].catformat);
-
-    gfits_scan (&header, "NAXIS1", "%d", 1, &Nx);
-    gfits_scan (&header, "NAXIS2", "%d", 1, &Ny);
-
-    /* convert all output rows to vtable */
-    ALLOCATE (vtable.row, int, MAX (1, Nout));
-    ALLOCATE (vtable.buffer, char *, MAX (1, Nout));
-    for (i = 0; i < Nout; i++) {
-      ALLOCATE (vtable.buffer[i], char, MAX (1, Nx));
-      memcpy (vtable.buffer[i], &ftable.buffer[i*Nx], Nx);
-      vtable.row[i] = i + Ndisk;
-    }
-
-    /* modify vtable to represent full disk table */
-    gfits_modify (&header, "NAXIS2", "%d", 1, Nlines);
-    header.Naxis[1] = Nlines;
-
-    vtable.size = gfits_data_size (&header);
-    vtable.Nrow = Nout;
-    vtable.pad = vtable.size - Nx*Ny;
-
-    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_vtable (catfile[0].f, &vtable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
-    gfits_free_vtable (&vtable);
+    first  = catalog[0].Nmeas_disk - catalog[0].Nmeas_off;  // first row in memory to write
+    start  = catalog[0].Nmeas_off; // first disk row to write
+    Nrows  = catalog[0].Nmeasure - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first < catalog[0].Nmeasure);
+    assert (catalog[0].Nmeas_disk >= catalog[0].Nmeas_off);
+
+    // convert to external table format
+    if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Measure table
+    if (!dvo_catalog_save_subset (catalog[0].measure_catalog, ftable, start, Nrows, catalog[0].Nmeas_disk, Nmeas_disk_new)) {
+      fprintf (stderr, "trouble writing Measure table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
-  }
-
-  /*** Missing Table ***/
+  }
+
   /* missing table CANNOT be written unsorted, thus it is always written 
      out in full */
 
+  /*** Missing Table ***/
+
   if (catalog[0].missing != NULL) {
 
-    catfile = catalog[0].missing_catalog;
-
-    /* rewind file pointers and truncate (file is still open) */
-    fseek (catfile[0].f, 0, SEEK_SET);
-    ftruncate (fileno (catfile[0].f), 0);
-
-    /* write table PHU header */
-    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
-      fprintf (stderr, "can't write primary header");
-      goto failure;
-    }
-
-    /* this is probably a NOP, do I have to keep it in? */
-    gfits_create_matrix (&catfile[0].header, &matrix);
-    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
-      fprintf (stderr, "can't write primary matrix");
-      goto failure;
-    }
-    gfits_free_matrix (&matrix);
-
-    /* write out Missing table (convert to FITS table format) */
-    gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing);
-    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
+    if (catalog[0].Nmiss_off != 0) {
+      fprintf (stderr, "inconsistency: Missing table cannot be written in segments\n");
+      goto failure;
+    }
+
+    // convert to external table format
+    if (!gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Missing table (must write out entire table)
+    if (!dvo_catalog_save_subset (catalog[0].missing_catalog, ftable, 0, catalog[0].Nmissing, catalog[0].Nmissing, catalog[0].Nmissing)) {
+      fprintf (stderr, "trouble writing Missing Table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
   }
 
@@ -852,31 +826,24 @@
   if (catalog[0].secfilt != NULL) {
 
-    catfile = catalog[0].secfilt_catalog;
-
-    /* skip past PHU header and matrix */
-    Nskip = catfile[0].header.size + gfits_data_size (&catfile[0].header);
-    fseek (catfile[0].f, Nskip, SEEK_SET);
-
-    /* how many lines to write out? */
-    Nout  = catalog[0].Nsecfilt * (catalog[0].Naverage - catalog[0].Nave_disk);
-    Ndisk = catalog[0].Nsecfilt * catalog[0].Nave_disk;
-
-    /* convert to output format FITS table */
-    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
-    SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
-    /* convert only output rows to vtable */
-    gfits_table_to_vtable (&ftable, &vtable, Ndisk, Nout);
-
-    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
-      fprintf (stderr, "can't write table header");
-      goto failure;
-    }
-    if (!gfits_fwrite_vtable (catfile[0].f, &vtable)) {
-      fprintf (stderr, "can't write table data");
-      goto failure;
-    }
-    gfits_free_vtable (&vtable);
+    first  = catalog[0].Nsecf_disk - catalog[0].Nsecf_off;  // first row in memory to write
+    start  = catalog[0].Nsecf_off; // first disk row to write
+    Nitems = catalog[0].Nsecf_mem;
+    Nrows  = Nitems - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first < Nitems);
+    assert (catalog[0].Nmeas_disk >= catalog[0].Nmeas_off);
+
+    // convert to external table format
+    SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat);
+
+    // write out SecFilt table
+    if (!dvo_catalog_save_subset (catalog[0].secfilt_catalog, ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
+      fprintf (stderr, "failure writing SecFilt table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
     gfits_free_table (&ftable);
-    gfits_free_header (&header);
   }
 
@@ -911,2 +878,13 @@
    the vtable based on the ftable, but with Ny = Nmeasure */  
   
+
+
+    // * convert to an ftable
+    // * optionally write the PHU header/matrix
+    // * advance to the start of the output data block:
+    // ** Nx * catalog[0].Nmeas_off
+    // * write out the ftable data block
+    // * if Nmeas_off + Nmeasure >= Nmeas_disk, update padding
+    // ** start = Nmeas_off
+    // ** Nrows = Nmeasure
+
Index: /branches/eam_branch_20071130/Ohana/src/libfits/include/gfitsio.h
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/libfits/include/gfitsio.h	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/libfits/include/gfitsio.h	(revision 15731)
@@ -178,4 +178,5 @@
 int     gfits_fwrite_table             PROTO((FILE *f, FTable *table));
 int     gfits_fwrite_vtable            PROTO((FILE *f, VTable *table));
+int     gfits_fwrite_ftable_range      PROTO((FILE *f, FTable *table, int start, int Nrows, int Ndisk, int Ntotal));
 int     gfits_get_bintable_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));
Index: /branches/eam_branch_20071130/Ohana/src/libfits/table/F_write_T.c
===================================================================
--- /branches/eam_branch_20071130/Ohana/src/libfits/table/F_write_T.c	(revision 15730)
+++ /branches/eam_branch_20071130/Ohana/src/libfits/table/F_write_T.c	(revision 15731)
@@ -69,2 +69,47 @@
 /* this will add data beyond the end of the table in the file if needed,
    filling intervening gap with 0 */
+
+/*********************** fits read ftable data ***********************************/
+int gfits_fwrite_ftable_range (FILE *f, FTable *ftable, int start, int Nrows, int Ndisk, int Ntotal) {
+
+  int Nbytes, Nwrite, Nskip, Nx, Npad;
+  char *pad;
+
+  if (start < 0) return (FALSE);
+  
+  /* modify vtable to represent full disk table */
+  gfits_modify (ftable[0].header, "NAXIS2", "%d", 1, Ntotal);
+  ftable[0].header[0].Naxis[1] = Ntotal;
+
+  Nx = ftable[0].header[0].Naxis[0]; // final output table size on disk 
+  ftable[0].size = gfits_data_size (ftable[0].header);
+
+  Nskip = start * Nx;
+  Nbytes = Nrows * Nx;
+
+  // cursor must be at start of the table header
+  if (!gfits_fwrite_Theader (f, ftable[0].header)) {
+    fprintf (stderr, "can't write table header");
+    return (FALSE);
+  }
+
+  // cursor must be at start of the table (after table header)
+  fseek (f, Nskip, SEEK_CUR);
+  Nwrite = fwrite (ftable[0].buffer, sizeof (char), Nbytes, f);
+  if (Nwrite != Nbytes) {
+    return (FALSE);
+  }
+
+  if (Ntotal >= Ndisk) {
+    Npad = ftable[0].size - Nx*Ntotal;
+    ALLOCATE (pad, char, Npad);
+    bzero (pad, Npad);
+    Nbytes = fwrite (pad, sizeof (char), Npad, f);
+    free (pad);
+
+    if (Nbytes != Npad) return (FALSE); 
+  }
+
+  return (TRUE);
+}	
+