Index: trunk/psLib/src/fits/psFitsTableNew.c
===================================================================
--- trunk/psLib/src/fits/psFitsTableNew.c	(revision 33030)
+++ trunk/psLib/src/fits/psFitsTableNew.c	(revision 41896)
@@ -137,4 +137,63 @@
 
     return table;
+}
+
+psFitsTable *psFitsTableCreate (psArray *tableColumns, int numRows) {
+
+    psFitsTable *table = psFitsTableAlloc (tableColumns->n, numRows);
+
+    // now define the table colums
+    for (int i = 0; i < tableColumns->n; i++) {
+	psFitsTableColumn *column = &table->columns[i];
+
+	psFitsTableColumn *myColumn = tableColumns->data[i];
+
+	column->name = psStringCopy (myColumn->name);
+	column->type = myColumn->type;
+	column->vectorType = myColumn->vectorType;
+	column->elementSize = myColumn->elementSize;
+	
+        psMetadataAddS32(table->index, PS_LIST_TAIL, column->name, 0, NULL, i);
+
+	switch (column->type) {
+	  case PS_DATA_S8:  column->data.S8  = psAlloc(sizeof(psS8) *table->numRows); break;
+	  case PS_DATA_S16: column->data.S16 = psAlloc(sizeof(psS16)*table->numRows); break;
+	  case PS_DATA_S32: column->data.S32 = psAlloc(sizeof(psS32)*table->numRows); break;
+	  case PS_DATA_S64: column->data.S64 = psAlloc(sizeof(psS64)*table->numRows); break;
+	  case PS_DATA_U8:  column->data.U8  = psAlloc(sizeof(psU8) *table->numRows); break;
+	  case PS_DATA_U16: column->data.U16 = psAlloc(sizeof(psU16)*table->numRows); break;
+	  case PS_DATA_U32: column->data.U32 = psAlloc(sizeof(psU32)*table->numRows); break;
+	  case PS_DATA_U64: column->data.U64 = psAlloc(sizeof(psU64)*table->numRows); break;
+	  case PS_DATA_F32: column->data.F32 = psAlloc(sizeof(psF32)*table->numRows); break;
+	  case PS_DATA_F64: column->data.F64 = psAlloc(sizeof(psF64)*table->numRows); break;
+	  default: break;
+	}
+    }
+    return table;
+}
+
+static void freeColumn(psFitsTableColumn *column)
+{
+    // add any element frees here
+    return;
+}
+
+psFitsTableColumn *psFitsTableColumnAlloc (char *name, psDataType type) {
+
+    psFitsTableColumn *column = psAlloc(sizeof(psFitsTableColumn));
+    psMemSetDeallocator(column, (psFreeFunc) freeColumn);
+
+    column->name = psStringCopy (name);
+    column->type = type;
+    column->vectorType  = 0;
+    column->elementSize = 1;
+    column->data.S8 = NULL; // no data yet allocated, place-holder only
+    return column;
+}
+
+bool psFitsTableColumnAdd (psArray *tableColumns, char *name, psDataType type) {
+    psFitsTableColumn *column = psFitsTableColumnAlloc (name, type);
+    psArrayAdd (tableColumns, 10, column);
+    return true;
 }
 
@@ -397,4 +456,70 @@
 psFitsTableGetNumTYPE(Bool, BOOL);
 
+#define psFitsTableSetNumTYPE(TYPE, NAME) \
+    bool psFitsTableSet##NAME(psFitsTable *table, int row, const char *name, ps##TYPE value) { \
+									\
+    if (row >= table->numRows || row < 0) { return false; }		\
+									\
+    bool mdok;								\
+    int col = psMetadataLookupS32(&mdok, table->index, name);		\
+    if (!mdok) { return false; }					\
+    if (col < 0) { return false; }					\
+									\
+    psFitsTableColumn *column = &table->columns[col];			\
+    switch (column->type) {						\
+      case PS_DATA_S8:							\
+	column->data.S8[row] = (psS8) value;				\
+        break;								\
+      case PS_DATA_S16:							\
+	column->data.S16[row] = (psS16) value;				\
+        break;								\
+      case PS_DATA_S32:							\
+	column->data.S32[row] = (psS32) value;				\
+        break;								\
+      case PS_DATA_S64:							\
+	column->data.S64[row] = (psS64) value;				\
+        break;								\
+      case PS_DATA_U8:							\
+	column->data.U8[row] = (psU8) value;				\
+        break;								\
+      case PS_DATA_U16:							\
+	column->data.U16[row] = (psU16) value;				\
+        break;								\
+      case PS_DATA_U32:							\
+	column->data.U32[row] = (psU32) value;				\
+        break;								\
+      case PS_DATA_U64:							\
+	column->data.U64[row] = (psU64) value;				\
+        break;								\
+      case PS_DATA_F32:							\
+	column->data.F32[row] = (psF32) value;				\
+        break;								\
+      case PS_DATA_F64:							\
+	column->data.F64[row] = (psF64) value;				\
+        break;								\
+      case PS_DATA_BOOL:						\
+	if (value) { column->data.F64[row] = 1; }			\
+	else { column->data.F64[row] = 0; }				\
+        break;								\
+      default:								\
+        /* if you get to this point, the value is not a number. */	\
+	return false;							\
+        break;								\
+    }									\
+    return true;							\
+}
+
+psFitsTableSetNumTYPE(S8, S8);
+psFitsTableSetNumTYPE(U8, U8);
+psFitsTableSetNumTYPE(S16, S16);
+psFitsTableSetNumTYPE(U16, U16);
+psFitsTableSetNumTYPE(S32, S32);
+psFitsTableSetNumTYPE(U32, U32);
+psFitsTableSetNumTYPE(S64, S64);
+psFitsTableSetNumTYPE(U64, U64);
+psFitsTableSetNumTYPE(F32, F32);
+psFitsTableSetNumTYPE(F64, F64);
+psFitsTableSetNumTYPE(Bool, BOOL);
+
 // remove rows from table that are marked in the mask array as censored.
 bool psFitsTableCensor(psFitsTable *table, bool *censorMask)