Changeset 30631 for branches/czw_branch/20101203/Ohana/src/opihi

Timestamp:

Feb 14, 2011, 1:05:28 PM (15 years ago)

Author:

watersc1

Message:

Merge of trunk back into branch.

Location:

branches/czw_branch/20101203

Files:

• . (modified) (1 prop)
• Ohana/src/opihi/cmd.astro/cgrid.c (modified) (1 diff)
• Ohana/src/opihi/cmd.astro/region.c (modified) (2 diffs)
• Ohana/src/opihi/cmd.astro/test (copied) (copied from trunk/Ohana/src/opihi/cmd.astro/test )
• Ohana/src/opihi/cmd.astro/test/region.sh (copied) (copied from trunk/Ohana/src/opihi/cmd.astro/test/region.sh )
• Ohana/src/opihi/cmd.data/limits.c (modified) (1 diff)
• Ohana/src/opihi/cmd.data/match2d.c (modified) (6 diffs)
• Ohana/src/opihi/cmd.data/reindex.c (modified) (3 diffs)
• Ohana/src/opihi/cmd.data/subset.c (modified) (2 diffs)
• Ohana/src/opihi/cmd.data/vstats.c (modified) (8 diffs)
• Ohana/src/opihi/cmd.data/write_vectors.c (modified) (1 diff)
• Ohana/src/opihi/doc/image-graph-overlay.txt (copied) (copied from trunk/Ohana/src/opihi/doc/image-graph-overlay.txt )
• Ohana/src/opihi/dvo/avextract.c (modified) (2 diffs)
• Ohana/src/opihi/dvo/dbExtractImages.c (modified) (2 diffs)
• Ohana/src/opihi/dvo/dbExtractMeasures.c (modified) (3 diffs)
• Ohana/src/opihi/dvo/dbFields.c (modified) (4 diffs)
• Ohana/src/opihi/dvo/gimages.c (modified) (1 diff)
• Ohana/src/opihi/dvo/gstar.c (modified) (3 diffs)
• Ohana/src/opihi/dvo/images.c (modified) (1 diff)
• Ohana/src/opihi/dvo/imextract.c (modified) (1 diff)
• Ohana/src/opihi/dvo/imphot.c (modified) (4 diffs)
• Ohana/src/opihi/dvo/mextract.c (modified) (1 diff)
• Ohana/src/opihi/dvo/mmextract.c (modified) (2 diffs)
• Ohana/src/opihi/dvo/photometry.c (modified) (3 diffs)
• Ohana/src/opihi/dvo/skycat.c (modified) (2 diffs)
• Ohana/src/opihi/include/dvoshell.h (modified) (3 diffs)
• Ohana/src/opihi/include/shell.h (modified) (1 diff)
• Ohana/src/opihi/lib.shell/VectorOps.c (modified) (1 diff)
• Ohana/src/opihi/lib.shell/command.c (modified) (5 diffs)
• Ohana/src/opihi/lib.shell/expand_vars.c (modified) (1 diff)
• Ohana/src/opihi/lib.shell/parse.c (modified) (10 diffs)
• Ohana/src/opihi/lib.shell/stack_math.c (modified) (4 diffs)

branches/czw_branch/20101203/Ohana/src/opihi/cmd.astro/cgrid.c

@@ -98 +98 @@
 
   if (argc != 1) {
-    gprint (GP_ERR, "USAGE: cgrid [style]\n");
+    gprint (GP_ERR, "USAGE: cgrid [style] [-ra-by-hour] [-labels]\n");
     return (FALSE);
   }

branches/czw_branch/20101203/Ohana/src/opihi/cmd.astro/region.c

@@ -18 +18 @@
   FREE (name);
 
+  NoClear = FALSE;
+  if ((N = get_argument (argc, argv, "-no-clear"))) {
+    remove_argument (N, &argc, argv);
+    NoClear = TRUE;
+  }
+
   if ((N = get_argument (argc, argv, "-image"))) {
     remove_argument (N, &argc, argv);
     KapaGetImageCoords (kapa, &graphmode.coords);
     KapaGetImageRange (kapa, &graphmode.xmin, &graphmode.xmax, &graphmode.ymax, &graphmode.ymin);
+
+    set_variable ("XMIN", graphmode.xmin);
+    set_variable ("XMAX", graphmode.xmax);
+    set_variable ("YMIN", graphmode.ymin);
+    set_variable ("YMAX", graphmode.ymax);
+
+    set_variable ("RMIN", Ra  + graphmode.xmin);
+    set_variable ("RMAX", Ra  + graphmode.xmax);
+    set_variable ("DMIN", Dec + graphmode.ymin);
+    set_variable ("DMAX", Dec + graphmode.ymax);
+
+    // if (!NoClear) KapaClearSections (kapa);
+    KapaSetLimits (kapa, &graphmode);
+
     SetGraph (&graphmode);
     return (TRUE);
@@ -45 +65 @@
     remove_argument (N, &argc, argv);
     graphmode.flipnorth = FALSE;
-  }
-
-  NoClear = FALSE;
-  if ((N = get_argument (argc, argv, "-no-clear"))) {
-    remove_argument (N, &argc, argv);
-    NoClear = TRUE;
   }
 

branches/czw_branch/20101203/Ohana/src/opihi/cmd.data/limits.c

@@ -26 +26 @@
 
   // XXX need an option to set the limits based on the current image bounds
+  if ((N = get_argument (argc, argv, "-image"))) {
+    remove_argument (N, &argc, argv);
+    KapaGetImageRange (kapa, &graphmode.xmin, &graphmode.xmax, &graphmode.ymax, &graphmode.ymin);
+
+    set_variable ("XMIN", graphmode.xmin);
+    set_variable ("XMAX", graphmode.xmax);
+    set_variable ("YMIN", graphmode.ymin);
+    set_variable ("YMAX", graphmode.ymax);
+
+    // if (!NoClear) KapaClearSections (kapa);
+    SetGraph (&graphmode);
+    KapaSetLimits (kapa, &graphmode);
+    return (TRUE);
+    // Set Region based on image
+  }
 
   if (argc == 1) {

branches/czw_branch/20101203/Ohana/src/opihi/cmd.data/match2d.c

@@ -1 +1 @@
 # include "data.h"
+
 int find_matches2d (Vector *X1, Vector *Y1, Vector *X2, Vector *Y2, double Radius, Vector *index1, Vector *index2);
+int find_matches2d_closest (Vector *X1, Vector *Y1, Vector *X2, Vector *Y2, double Radius, Vector *index);
 
 // match2d (X1) (Y1) (X2) (Y2) (Radius) [-index1 (index1)] [-index2 (index2)] [-nomatch1 nomatch1] [-nomatch2 nomatch2]
@@ -6 +8 @@
 int match2d (int argc, char **argv) {
   
-  int N;
+  int N, CLOSEST;
   double Radius;
   char *endptr;
@@ -12 +14 @@
   Vector *index1, *index2;
 
+  CLOSEST = FALSE;
+  if ((N = get_argument (argc, argv, "-closest"))) {
+    remove_argument (N, &argc, argv);
+    CLOSEST = TRUE;
+  }
+
   if ((N = get_argument (argc, argv, "-index1"))) {
     remove_argument (N, &argc, argv);
@@ -30 +38 @@
   if (argc != 6) {
     gprint (GP_ERR, "USAGE: match2d X1 Y1 X2 Y2 Radius [-index1 (index1)] [-index2 (index2)] [-closest]\n");
-    // gprint (GP_ERR, "USAGE: match2d X1 Y1 X2 Y2 Radius [-index1 (index1)] [-index2 (index2)] [-closest]\n");
-    // gprint (GP_ERR, "  if -closest is provided, index1 & index2 will have the same length as X1 and X2 (respectively)\n");
-    // gprint (GP_ERR, "    with either the index of the match or a value of -1 for non-matches\n");
-    return (FALSE);
-  }
+    gprint (GP_ERR, "  if -closest is provided, index1 & index2 will have the same length as X1 and X2 (respectively)\n");
+    gprint (GP_ERR, "    with either the index of the match or a value of -1 for non-matches\n");
+    return (FALSE);
+  }
+
+  /*
+    we have two modes of operation:  
+
+    without -closest, we are finding all matched pairs within the match radius.  in this
+    case, the two index vectors have the same length, one entry per matched pair.
+    x1[index1],y1[index1] matches to x2[index2],y2[index2].
+
+    with -closest selected, we are finding the closest element of set 1 to each of set 2
+    and vice versa.  in this case, index1 is always the same length as x1,y1, while index2
+    is the same lengths as x2,y2.  x2[index1],y2[index1] matches x1,y1 while
+    x1[index2],y1[index2] matches x2,y2
+
+   */
 
   if ((X1vec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);    
@@ -61 +82 @@
   }
 
-  find_matches2d (X1vec, Y1vec, X2vec, Y2vec, Radius, index1, index2);
+  if (CLOSEST) {
+      find_matches2d_closest (X1vec, Y1vec, X2vec, Y2vec, Radius, index1);
+      find_matches2d_closest (X2vec, Y2vec, X1vec, Y1vec, Radius, index2);
+  } else {
+      find_matches2d (X1vec, Y1vec, X2vec, Y2vec, Radius, index1, index2);
+  }
 
   return (TRUE);
@@ -132 +158 @@
   return (TRUE);
 }
+
+// find the elements of X2,Y2 which are closest to each element of X1,Y1 (-1 if no match)
+int find_matches2d_closest (Vector *X1, Vector *Y1, Vector *X2, Vector *Y2, double Radius, Vector *index) {
+  
+  off_t i, j, Jmin, Ji, I, J, *N1, *N2, NMATCH;
+  double dX, dY, dR, Radius2, Rmin;
+
+  NMATCH = X1->Nelements;
+  ResetVector (index, OPIHI_INT, NMATCH);
+
+  ALLOCATE (N1, off_t, X1->Nelements);
+  ALLOCATE (N2, off_t, X2->Nelements);
+
+  for (i = 0; i < X1->Nelements; i++) { N1[i] = i; }
+  for (i = 0; i < X2->Nelements; i++) { N2[i] = i; }
+
+  sort_coords_indexonly (X1->elements.Flt, Y1->elements.Flt, N1, X1->Nelements);
+  sort_coords_indexonly (X2->elements.Flt, Y2->elements.Flt, N2, X2->Nelements);
+
+  Radius2 = Radius*Radius;
+
+  // find the closest entry in list 2 to the current entry in list 1:
+  for (i = j = 0; (i < X1->Nelements) && (j < X2->Nelements);) {
+    I = N1[i];
+    J = N2[j];
+
+    dX = X1->elements.Flt[I] - X2->elements.Flt[J];
+
+    if (dX <= -1.02*Radius) { 
+      // no match in list 2 to this entry
+      index->elements.Int[I] = -1;
+      i++; 
+      continue; 
+    }
+    if (dX >= +1.02*Radius) { j++; continue; }
+
+    // look for closest matches of list2() to list1(i)
+    Jmin = -1;
+    Rmin = Radius2;
+    for (Ji = j; (dX > -1.02*Radius) && (Ji < X2->Nelements); Ji++) {
+      J = N2[Ji];
+      dX = X1->elements.Flt[I] - X2->elements.Flt[J];
+      dY = Y1->elements.Flt[I] - Y2->elements.Flt[J];
+      dR = dX*dX + dY*dY;
+      if (dR > Radius2) continue;
+      if (dR < Rmin) {
+        Rmin = dR;
+        Jmin  = J;
+      }
+    }
+
+    // no match in list 2 to this entry
+    if (Jmin == -1) {
+      index->elements.Int[I] = -1;
+      i++;
+      continue;
+    }
+    index->elements.Int[I] = Jmin;
+    i++;
+  }
+  index->Nelements = NMATCH;
+
+  free (N1);
+  free (N2);
+
+  return (TRUE);
+}

branches/czw_branch/20101203/Ohana/src/opihi/cmd.data/reindex.c

@@ -5 +5 @@
 int reindex (int argc, char **argv) {
   
-  int  i, Npts, Nmax, valid;
+  int  i, Npts, Nmax;
   Vector *ivec, *ovec, *xvec;
 
@@ -11 +11 @@
   Npts = 0;
 
-  valid = TRUE;
-  valid &= (argc >= 6);
-  valid &= !strcmp(argv[2], "=");
-  valid &= !strcmp(argv[4], "using");
-  if (!valid) {
-    gprint (GP_ERR, "USAGE: reindex (out) = (in) using (index)\n");
-    gprint (GP_ERR, "  creates a new vectors (out) from (in) based on sequence in (index)\n");
-    return (FALSE);
-  }
+  if (argc != 6) goto usage;
+  if (strcmp(argv[2], "=")) goto usage;
+  if (strcmp(argv[4], "using")) goto usage;
 
   if ((ovec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) goto error;
@@ -63 +57 @@
   DeleteVector (ovec);
   return (FALSE);
+
+usage:
+    gprint (GP_ERR, "USAGE: reindex (out) = (in) using (index)\n");
+    gprint (GP_ERR, "  creates a new vectors (out) from (in) based on sequence in (index)\n");
+    return (FALSE);
 }
 

branches/czw_branch/20101203/Ohana/src/opihi/cmd.data/subset.c

@@ -34 +34 @@
 
   // ovec matches ivec in type
-  ResetVector (ovec, ivec->type, MAX (tvec[0].Nelements, 1));
+  ResetVector (ovec, ivec->type, tvec[0].Nelements);
 
   // we have four cases: (ivec == flt or int) and (tvec == flt or int)
@@ -75 +75 @@
 
   // free up unused memory
-  ResetVector (ovec, ivec->type, MAX (Npts, 1));
+  ResetVector (ovec, ivec->type, Npts);
 
   DeleteVector (tvec);

branches/czw_branch/20101203/Ohana/src/opihi/cmd.data/vstats.c

@@ -3 +3 @@
 int vstats (int argc, char **argv) {
   
-  int i, N;
-  double max, min, sum, var, dvar, mean, stdev;
-  float IgnoreValue;
+  int i, iter, N, Nbin, Niter;
+  double max, min, pmin, pmax, sum, var, dvar, mean, stdev;
+  float IgnoreValue, Nsigma;
   int Ignore, Quiet;
 
-  int *Nval, bin, Nmode, Nmed;
-  double dx, mode, median;
+  int *Nval, bin, Nmode, Nmed, Nused;
+  double dx, mode, median, threshold;
   Vector *vec;
+  char *mask = NULL;
 
   IgnoreValue = 0;
@@ -21 +22 @@
   }
 
+  Niter = 1;
+  Nsigma = 3.0;
+
+  if ((N = get_argument (argc, argv, "-sigma-clip"))) {
+    remove_argument (N, &argc, argv);
+    Nsigma = atof(argv[N]);
+    Niter = 3;
+    remove_argument (N, &argc, argv);
+  }
+
+  if ((N = get_argument (argc, argv, "-iter"))) {
+    remove_argument (N, &argc, argv);
+    Niter = atoi(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+
   Quiet = FALSE;
   if ((N = get_argument (argc, argv, "-q"))) {
@@ -32 +49 @@
 
   if (argc != 2) {
-    gprint (GP_ERR, "USAGE: vstat (vector)\n");
+    gprint (GP_ERR, "USAGE: vstat (vector) [-ignore value] [-q] [-quiet] [-iter Niter] [-sigma-clip Nsigma]\n");
+    gprint (GP_ERR, "  default is 1 iteration without sigma clipping or 3 with sigma clipping\n");
     return (FALSE);
   }
@@ -39 +57 @@
 
   /* we need two passes, one for max, min, mean, sum, one for median, stdev, etc */
+
+  // set a good / bad mask
+  ALLOCATE (mask, char, vec[0].Nelements);
+  if (vec[0].type == OPIHI_FLT) {
+    opihi_flt *X = vec[0].elements.Flt;
+    for (i = 0; i < vec[0].Nelements; i++, X++) {
+      mask[i] = 1;
+      if (!finite (*X)) continue;
+      if (Ignore && (*X == IgnoreValue)) continue;
+      mask[i] = 0;
+    }      
+  } else {
+    opihi_int *X = vec[0].elements.Int;
+    for (i = 0; i < vec[0].Nelements; i++, X++) {
+      mask[i] = 1;
+      if (!finite (*X)) continue;
+      if (Ignore && (*X == IgnoreValue)) continue;
+      mask[i] = 0;
+    }      
+  }
 
   /* calculate max, min, mean, sum, npix */
@@ -47 +85 @@
     opihi_flt *X = vec[0].elements.Flt;
     for (i = 0; i < vec[0].Nelements; i++, X++) {
-      if (!finite (*X)) continue;
-      if (Ignore && (*X == IgnoreValue)) continue;
+      if (mask[i]) continue;
       max = MAX (*X, max);
       min = MIN (*X, min);
@@ -57 +94 @@
     opihi_int *X = vec[0].elements.Int;
     for (i = 0; i < vec[0].Nelements; i++, X++) {
-      if (!finite (*X)) continue;
-      if (Ignore && (*X == IgnoreValue)) continue;
+      if (mask[i]) continue;
       max = MAX (*X, max);
       min = MIN (*X, min);
@@ -67 +103 @@
   mean = sum / N;
 
-  /* calculate median and mode with resolution of (max - min) / 1000 */ 
-  dx = (max - min) / 1000;
-  if (dx == 0) {
-    median = mode = min;
-    stdev = 0.0;
-    goto skip;
-  }
-
-  ALLOCATE (Nval, int, 1002);
-  bzero (Nval, 1000*sizeof(int));
-  var = 0;
-  if (vec[0].type == OPIHI_FLT) {
-    opihi_flt *X = vec[0].elements.Flt;
-    for (i = 0; i < vec[0].Nelements; i++, X++) {
-      if (!finite (*X)) continue;
-      if (Ignore && (*X == IgnoreValue)) continue;
-      bin = MAX (0, MIN (1000, (*X - min) / dx));
-      Nval[bin] ++;
-      dvar = (*X - mean);
-      var += dvar*dvar;
-    }      
-  } else {
-    opihi_int *X = vec[0].elements.Int;
-    for (i = 0; i < vec[0].Nelements; i++, X++) {
-      if (!finite (*X)) continue;
-      if (Ignore && (*X == IgnoreValue)) continue;
-      bin = MAX (0, MIN (1000, (*X - min) / dx));
-      Nval[bin] ++;
-      dvar = (*X - mean);
-      var += dvar*dvar;
-    }      
-  }
-  stdev = sqrt (var / N);
-
-  Nmode = 0;
-  mode = Nval[Nmode];
-  median = 0;
-  Nmed = -1;
-  for (i = 0; i < 1001; i++) {
-    if (Nmed == -1) {
-      median += Nval[i];
-      if (median >= N / 2.0) {
-        Nmed = i;
-        median = i * dx + min;
+  // we do Niter passes; on each pass, we exclude entries > Nsigma from the median
+  pmin = min;
+  pmax = max;
+
+  stdev = mode = median = Nused = 0.0;
+
+  for (iter = 0; iter < Niter; iter ++) {
+
+    // reduce Nbin after the first iteration?
+    Nbin = 1000;
+
+    /* calculate median and mode with resolution of (max - min) / 1000 */ 
+    dx = (pmax - pmin) / Nbin;
+    if (dx == 0) {
+      median = mode = min;
+      stdev = 0.0;
+      goto skip;
+    }
+
+    ALLOCATE (Nval, int, Nbin + 2);
+    bzero (Nval, Nbin*sizeof(int));
+    var = 0;
+    if (vec[0].type == OPIHI_FLT) {
+      opihi_flt *X = vec[0].elements.Flt;
+      for (i = 0; i < vec[0].Nelements; i++, X++) {
+        if (mask[i]) continue;
+        bin = MAX (0, MIN (Nbin, (*X - pmin) / dx));
+        Nval[bin] ++;
+        dvar = (*X - mean);
+        var += dvar*dvar;
+      }      
+    } else {
+      opihi_int *X = vec[0].elements.Int;
+      for (i = 0; i < vec[0].Nelements; i++, X++) {
+        if (mask[i]) continue;
+        bin = MAX (0, MIN (Nbin, (*X - pmin) / dx));
+        Nval[bin] ++;
+        dvar = (*X - mean);
+        var += dvar*dvar;
+      }      
+    }
+    stdev = sqrt (var / N);
+
+    Nmode = 0;
+    mode = Nval[Nmode];
+    median = 0;
+    Nmed = -1;
+    for (i = 0; i < Nbin + 1; i++) {
+      if (Nmed == -1) {
+        median += Nval[i];
+        if (median >= N / 2.0) {
+          Nmed = i;
+          median = i * dx + pmin;
+        }
       }
-    }
-    if (mode < Nval[i]) {
-      Nmode = i;
-      mode = Nval[Nmode];
-    }
-  }
-  mode = Nmode * dx + min;
-  free (Nval);
+      if (mode < Nval[i]) {
+        Nmode = i;
+        mode = Nval[Nmode];
+      }
+    }
+    mode = Nmode * dx + pmin;
+    free (Nval);
+
+    threshold = Nsigma * stdev;
+
+    // we are going to do another pass: mark the entries to skip
+    pmin = max;
+    pmax = min;
+    if (iter < Niter - 1) {
+      if (vec[0].type == OPIHI_FLT) {
+        opihi_flt *X = vec[0].elements.Flt;
+        for (i = 0; i < vec[0].Nelements; i++, X++) {
+          if (mask[i]) continue;
+          if (fabs(*X - median) > threshold) {
+            mask[i] = 1;
+          } else {
+            pmin = MIN (*X, pmin);
+            pmax = MAX (*X, pmax);
+          }      
+        }
+      } else {
+        opihi_int *X = vec[0].elements.Int;
+        for (i = 0; i < vec[0].Nelements; i++, X++) {
+          if (mask[i]) continue;
+          if (fabs(*X - median) > threshold) {
+            mask[i] = 1;
+          } else {
+            pmin = MIN (*X, pmin);
+            pmax = MAX (*X, pmax);
+          }
+        }      
+      }
+    }
+    // gprint (GP_ERR, "iter %d, mean: %g, stdev: %g, min: %g, max: %g, median: %g, mode: %g, Npts: %d\n", 
+    // iter, mean, stdev, min, max, median, mode, N);
+  }
+
+  Nused = 0;
+  for (i = 0; i < vec[0].Nelements; i++) {
+    if (mask[i]) continue;
+    Nused ++;
+  }
 
 skip:
+  FREE(mask);
+
   if (!Quiet) {
     gprint (GP_ERR, "mean: %g, stdev: %g, min: %g, max: %g, median: %g, mode: %g, Npts: %d\n", 
-             mean, stdev, min, max, median, mode, N);
-  }
-
+            mean, stdev, min, max, median, mode, N);
+  }
+
+  set_variable ("PMIN",      pmin);
+  set_variable ("PMAX",      pmax);
   set_variable ("MIN",      min);
   set_variable ("MAX",      max);
@@ -134 +223 @@
   set_variable ("TOTAL",    sum);
   set_int_variable ("NPIX", N);
+  set_int_variable ("NPTS", N);
+  set_int_variable ("NUSED", Nused);
   set_variable ("SIGMA",    stdev);
   return (TRUE);

branches/czw_branch/20101203/Ohana/src/opihi/cmd.data/write_vectors.c

@@ -140 +140 @@
       if (fmttype[j] == 'd') {
         if (vec[j][0].type == OPIHI_FLT) {
-          fprintf (f, fmtlist[j], (int)(vec[j][0].elements.Flt[i]));
+          fprintf (f, fmtlist[j], (opihi_int)(vec[j][0].elements.Flt[i]));
         } else {
-          fprintf (f, fmtlist[j], (int)(vec[j][0].elements.Int[i]));
+          fprintf (f, fmtlist[j], (opihi_int)(vec[j][0].elements.Int[i]));
         }
       } 
       if (fmttype[j] == 'f') {
         if (vec[j][0].type == OPIHI_FLT) {
-          fprintf (f, fmtlist[j], (float)(vec[j][0].elements.Flt[i]));
+          fprintf (f, fmtlist[j], (opihi_flt)(vec[j][0].elements.Flt[i]));
         } else {
-          fprintf (f, fmtlist[j], (float)(vec[j][0].elements.Int[i]));
+          fprintf (f, fmtlist[j], (opihi_flt)(vec[j][0].elements.Int[i]));
         }
       } 

branches/czw_branch/20101203/Ohana/src/opihi/dvo/avextract.c

@@ -44 +44 @@
 
   // parse skyregion options
-  if ((selection = SetRegionSelection (&argc, argv)) == NULL) goto escape;
+  if ((selection = SetRegionSelection (&argc, argv)) == NULL) {
+    print_error(); 
+    goto escape; 
+  }
 
   // command-line is of the form: avextract field,field, field [where (field op value)...]
@@ -68 +71 @@
   // construct the db Boolean math stack (frees cstack)
   stack = dbRPN (Ncstack, cstack, &Nstack);
+  if (Ncstack && !Nstack) {
+    print_error(); 
+    goto escape; 
+  }
 
   // add the skyregion limits to the where statement (or create)

branches/czw_branch/20101203/Ohana/src/opihi/dvo/dbExtractImages.c

@@ -241 +241 @@
 
     case IMAGE_NCAL:
-      value.Int = image[N].Mxxxx;
+      value.Int = image[N].nFitPhotom;
       break;
     case IMAGE_SKY:
-      value.Flt = image[N].Myyyy + 0x8000;
+      value.Flt = NAN;
       break;
     case IMAGE_FLAGS:
@@ -299 +299 @@
       value.Flt = (field->ID == IMAGE_X_UR_FP) ? x : y;
       break;
+
+    case IMAGE_X_ERR_SYS:
+      value.Flt = image[N].dXpixSys;
+      break;
+    case IMAGE_Y_ERR_SYS:
+      value.Flt = image[N].dXpixSys;
+      break;
+    case IMAGE_MAG_ERR_SYS:
+      value.Flt = image[N].dMagSys;
+      break;
+
+    case IMAGE_NFIT_PHOTOM:
+      value.Int = image[N].nFitPhotom;
+      break;
+    case IMAGE_NFIT_ASTROM:
+      value.Int = image[N].nFitAstrom;
+      break;
+    case IMAGE_NLINK_PHOTOM:
+      value.Int = image[N].nLinkPhotom;
+      break;
+    case IMAGE_NLINK_ASTROM:
+      value.Int = image[N].nLinkAstrom;
+      break;
   }
   return (value);

branches/czw_branch/20101203/Ohana/src/opihi/dvo/dbExtractMeasures.c

@@ -320 +320 @@
       break;
     case MEAS_FWHM: /* OK */
-      value.Flt = 0.01*(measure[0].FWx + measure[0].FWy) / 2.0;
+      value.Flt = FromShortPixels(measure[0].FWx + measure[0].FWy) / 2.0;
       break;
     case MEAS_FWHM_MAJ: /* OK */
-      value.Flt = 0.01*measure[0].FWx;
+      value.Flt = FromShortPixels(measure[0].FWx);
       break;
     case MEAS_FWHM_MIN: /* OK */
-      value.Flt = 0.01*measure[0].FWy;
+      value.Flt = FromShortPixels(measure[0].FWy);
       break;
     case MEAS_THETA: /* OK */
-      value.Flt = measure[0].theta;
+      value.Flt = FromShortDegrees(measure[0].theta);
       break;
     case MEAS_MXX: /* OK */
-      value.Flt = measure[0].Mxx;
+      value.Flt = FromShortPixels(measure[0].Mxx);
       break;
     case MEAS_MXY: /* OK */
-      value.Flt = measure[0].Mxy;
+      value.Flt = FromShortPixels(measure[0].Mxy);
       break;
     case MEAS_MYY: /* OK */
-      value.Flt = measure[0].Myy;
+      value.Flt = FromShortPixels(measure[0].Myy);
       break;
     case MEAS_DOPHOT: /* OK */
@@ -382 +382 @@
       break;
     case MEAS_XCCD_ERR: /* OK */
-      value.Flt = measure[0].dXccd / 100.0;
+      value.Flt = FromShortPixels(measure[0].dXccd);
       break;
     case MEAS_YCCD_ERR: /* OK */
-      value.Flt = measure[0].dYccd / 100.0;
+      value.Flt = FromShortPixels(measure[0].dYccd);
+      break;
+    case MEAS_POS_SYS_ERR: /* OK */
+      value.Flt = FromShortPixels(measure[0].dRsys);
       break;
     case MEAS_XMOSAIC: /* OK */
@@ -425 +428 @@
       value.Flt = measure[0].psfQual;
       break;
+    case MEAS_PSF_QF_PERFECT: /* OK */
+      value.Flt = NAN;
+      break;
     case MEAS_PSF_CHISQ: /* OK */
       value.Flt = measure[0].psfChisq;

branches/czw_branch/20101203/Ohana/src/opihi/dvo/dbFields.c

@@ -194 +194 @@
   if (!strcasecmp (fieldName, "XCCD:ERR"))       ESCAPE (MEAS_XCCD_ERR,       MAG_NONE, OPIHI_FLT);
   if (!strcasecmp (fieldName, "YCCD:ERR"))       ESCAPE (MEAS_YCCD_ERR,       MAG_NONE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "POS_SYS_ERR"))    ESCAPE (MEAS_POS_SYS_ERR,    MAG_NONE, OPIHI_FLT);
   if (!strcasecmp (fieldName, "XMOSAIC"))        ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
   if (!strcasecmp (fieldName, "YMOSAIC"))        ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
@@ -205 +206 @@
   if (!strcasecmp (fieldName, "IMAGEID"))        ESCAPE (MEAS_IMAGE_ID,       MAG_NONE, OPIHI_INT);
   if (!strcasecmp (fieldName, "PSF_QF"))         ESCAPE (MEAS_PSF_QF,         MAG_NONE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, MAG_NONE, OPIHI_FLT);
   if (!strcasecmp (fieldName, "PSF_CHISQ"))      ESCAPE (MEAS_PSF_CHISQ,      MAG_NONE, OPIHI_FLT);
   if (!strcasecmp (fieldName, "PSF_NDOF"))       ESCAPE (MEAS_PSF_NDOF,       MAG_NONE, OPIHI_INT);
@@ -398 +400 @@
   if (!strcasecmp (fieldName, "trate"    )) ESCAPE (IMAGE_TRATE,     MAG_NONE, OPIHI_FLT);
 
-  // XXX : these are mapped to ridiculous things: Myyyy + 0x8000 and Mxxxx
   if (!strcasecmp (fieldName, "ncal"     )) ESCAPE (IMAGE_NCAL,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       MAG_NONE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       MAG_NONE, OPIHI_FLT); // deprecated for now
 
   if (!strcasecmp (fieldName, "imflags"  )) ESCAPE (IMAGE_FLAGS,     MAG_NONE, OPIHI_INT);
@@ -427 +428 @@
   if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   MAG_NONE, OPIHI_FLT);
 
+  if (!strcasecmp (fieldName, "dX_SYS"  )) ESCAPE (IMAGE_X_ERR_SYS,  MAG_NONE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dY_SYS"  )) ESCAPE (IMAGE_Y_ERR_SYS,  MAG_NONE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dM_SYS"  )) ESCAPE (IMAGE_MAG_ERR_SYS,MAG_NONE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "NFIT_PHOTOM")) ESCAPE (IMAGE_NFIT_PHOTOM,MAG_NONE, OPIHI_INT);
+  if (!strcasecmp (fieldName, "NFIT_ASTROM")) ESCAPE (IMAGE_NFIT_ASTROM,MAG_NONE, OPIHI_INT);
+  if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM,MAG_NONE, OPIHI_INT);
+  if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM,MAG_NONE, OPIHI_INT);
+
   // for words that don't parse, try a photcode
   gprint (GP_ERR, "unknown field '%s' for image table in DVO database\n", fieldName);

branches/czw_branch/20101203/Ohana/src/opihi/dvo/gimages.c

@@ -201 +201 @@
     }
 
-    /*** XXX we need to re-introduce the use of applyMcal
-    Mcal = applyMcal (&image[i], 2048.0, 2048.0);
-    ***/
+    // XXX Mcal = applyMcal (&image[i], 2048.0, 2048.0);
 
   got_spot:

branches/czw_branch/20101203/Ohana/src/opihi/dvo/gstar.c

@@ -222 +222 @@
             gprint (GP_LOG, "%5d ",    catalog.measure[m].photcode);
             gprint (GP_LOG, "%-20s ",  GetPhotcodeNamebyCode (catalog.measure[m].photcode));
-            gprint (GP_LOG, "%5.2f ",  0.01*catalog.measure[m].FWx);
-            gprint (GP_LOG, "%5.2f ",  0.01*catalog.measure[m].FWy);
+            gprint (GP_LOG, "%5.2f ",  FromShortPixels(catalog.measure[m].FWx));
+            gprint (GP_LOG, "%5.2f ",  FromShortPixels(catalog.measure[m].FWy));
 
             if (FULL_OUTPUT) {
@@ -233 +233 @@
                 gprint (GP_LOG, "%f ", catalog.measure[m].Xccd);
                 gprint (GP_LOG, "%f ", catalog.measure[m].Yccd);
-                gprint (GP_LOG, "%d ", catalog.measure[m].dXccd);
-                gprint (GP_LOG, "%d ", catalog.measure[m].dYccd);
+                gprint (GP_LOG, "%f ", FromShortPixels(catalog.measure[m].dXccd));
+                gprint (GP_LOG, "%f ", FromShortPixels(catalog.measure[m].dYccd));
                 gprint (GP_LOG, "%f ", catalog.measure[m].Sky);
                 gprint (GP_LOG, "%f ", catalog.measure[m].dSky);
@@ -244 +244 @@
                 gprint (GP_LOG, "%f ", catalog.measure[m].crNsigma);
                 gprint (GP_LOG, "%f ", catalog.measure[m].extNsigma);
-                gprint (GP_LOG, "%f ", (360.0/(float)0xffff)*catalog.measure[m].theta);
+                gprint (GP_LOG, "%f ", FromShortDegrees(catalog.measure[m].theta));
             }
             gprint (GP_LOG, "\n");

branches/czw_branch/20101203/Ohana/src/opihi/dvo/images.c

@@ -223 +223 @@
       goto got_type;
     }
-    // For 'TrianglePts' (TRI-), we are using the Mx,My, etc terms to save the coordinates
-    // this means triangular images cannot carry photometric zero-point variations
+    // For 'TrianglePts' (TRI-), we are absurdly overloaded values otherwise not used
     if (typehash == TrianglePts) {
       Npts = 3;
-      x[0] = image[i].Mx;   y[0] = image[i].My;
-      x[1] = image[i].Mxxx; y[1] = image[i].Mxyy;
-      x[2] = image[i].Mxxy; y[2] = image[i].Myyy;
+      x[0] = image[0].dXpixSys;      y[0] = image[0].dYpixSys;
+      x[1] = image[0].dMagSys;       y[1] = image[0].nFitAstrom;
+      x[2] = image[0].photom_map_id; y[2] = image[0].astrom_map_id;
       goto got_type;
     }

branches/czw_branch/20101203/Ohana/src/opihi/dvo/imextract.c

@@ -62 +62 @@
   // construct the db Boolean math stack (frees cstack)
   stack = dbRPN (Ncstack, cstack, &Nstack);
+  if (Ncstack && !Nstack) {
+    print_error(); 
+    goto escape; 
+  }
 
   // add the skyregion limits to the where statement (or create)

branches/czw_branch/20101203/Ohana/src/opihi/dvo/imphot.c

@@ -9 +9 @@
   char bufname[64];
   float *p;
-  double fx, fy, x, y, applyMcal();
+  double fx, fy, x, y;
   Image *image;
   Buffer *buf;
@@ -63 +63 @@
     for (y = 0; y < 200; y+=1.0) {
       for (x = 0; x < 100; x+=1.0, p++) {
-        *p = applyMcal (&image[subset[0]], (fx*x), (fy*y));
+        // *p = applyMcal (&image[subset[0]], (fx*x), (fy*y));
+        *p = image[subset[0]].Mcal;
       }
     }
@@ -70 +71 @@
   for (j = 0; j < Nsubset; j++) {
     i = subset[j];
+    gprint (GP_ERR, "%s: %f\n", image[i].name, image[i].Mcal);
+
+// XXX old code when we had the option of a 2D zero point model
+# if (0)      
     switch (image[i].order) {
     case 0:
@@ -90 +95 @@
       break;
     }
+# endif
   }
 

branches/czw_branch/20101203/Ohana/src/opihi/dvo/mextract.c

@@ -68 +68 @@
   // construct the db Boolean math stack (frees cstack)
   stack = dbRPN (Ncstack, cstack, &Nstack);
-  if ((Ncstack > 0) && (Nstack < 1)) {
+  if (Ncstack && !Nstack) {
     print_error ();
     goto escape;

branches/czw_branch/20101203/Ohana/src/opihi/dvo/mmextract.c

@@ -106 +106 @@
   // construct the db Boolean math stack (frees cstack)
   stack1 = dbRPN (Ncstack1, cstack1, &Nstack1);
-  if ((Ncstack1 > 0) && (Nstack1 < 1)) {
+  if (Ncstack1 && !Nstack1) {
     print_error ();
     goto escape;
@@ -113 +113 @@
   // construct the db Boolean math stack (frees cstack)
   stack2 = dbRPN (Ncstack2, cstack2, &Nstack2);
-  if ((Ncstack2 > 0) && (Nstack2 < 1)) {
+  if (Ncstack2 && !Nstack2) {
     print_error ();
     goto escape;

branches/czw_branch/20101203/Ohana/src/opihi/dvo/photometry.c

@@ -778 +778 @@
   } else {
     
-    if (0.01 * measure[0].FWx < 3.0) return (FALSE);
-    if (0.01 * measure[0].FWx > 10.0) return (FALSE);
+    if (FromShortPixels(measure[0].FWx < 3.0)) return (FALSE);
+    if (FromShortPixels(measure[0].FWx > 10.0)) return (FALSE);
 
     return (TRUE);
@@ -810 +810 @@
     Nm = 0;
     for (i = 0; i < average[0].Nmeasure; i++) {
-      fwhm = measure[i].FWx / 100.0;
+      fwhm = FromShortPixels(measure[i].FWx);
       switch (FWHMsign) {
         case 0:
@@ -1166 +1166 @@
       break;
     case MEAS_FWHM: /* OK */
-      value = 0.01*measure[0].FWx;
+      value = FromShortPixels(measure[0].FWx);
       break;
     case MEAS_DB_FLAGS: /* ? */

branches/czw_branch/20101203/Ohana/src/opihi/dvo/skycat.c

@@ -36 +36 @@
 
   if (argc != 1) {
-    gprint (GP_ERR, "USAGE: skycat [-all]\n");
+    gprint (GP_ERR, "USAGE: skycat [-all] [-depth depth] [-v]\n");
     return (FALSE);
   }
@@ -116 +116 @@
 
   r = ohana_normalize_angle (r);
+  while (r < Rmin) { r += 360.0; }
+  while (r > Rmax) { r -= 360.0; }
 
   if (*leftside == -1) {

branches/czw_branch/20101203/Ohana/src/opihi/include/dvoshell.h

@@ -107 +107 @@
       MEAS_XCCD_ERR, 
       MEAS_YCCD_ERR, 
+      MEAS_POS_SYS_ERR, 
       MEAS_XMOSAIC, 
       MEAS_YMOSAIC, 
@@ -116 +117 @@
       MEAS_IMAGE_ID, 
       MEAS_PSF_QF, 
+      MEAS_PSF_QF_PERFECT, 
       MEAS_PSF_CHISQ, 
       MEAS_PSF_NDOF,
@@ -218 +220 @@
       IMAGE_Y_UL_FP,
       IMAGE_Y_UR_FP,
+      IMAGE_X_ERR_SYS,
+      IMAGE_Y_ERR_SYS,
+      IMAGE_MAG_ERR_SYS,
+      IMAGE_NFIT_PHOTOM,
+      IMAGE_NFIT_ASTROM,
+      IMAGE_NLINK_PHOTOM,
+      IMAGE_NLINK_ASTROM
 };
 

branches/czw_branch/20101203/Ohana/src/opihi/include/shell.h

@@ -76 +76 @@
 char         *expand_vars               PROTO((char *line));
 char         *expand_vectors            PROTO((char *line));
-char         *parse                     PROTO((char *line));
+char         *parse                     PROTO((int *status, char *line));
 char        **parse_commands            PROTO((char *, int *));
 void          welcome                   PROTO((void));

branches/czw_branch/20101203/Ohana/src/opihi/lib.shell/VectorOps.c

@@ -178 +178 @@
   vec[0].Nelements = Nelements;
   if (type == OPIHI_FLT) {
-    REALLOCATE (vec[0].elements.Flt, opihi_flt, Nelements);
+    REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX(1, Nelements));
     vec[0].type = OPIHI_FLT;
   } else {
-    REALLOCATE (vec[0].elements.Int, opihi_int, Nelements);
+    REALLOCATE (vec[0].elements.Int, opihi_int, MAX(1, Nelements));
     vec[0].type = OPIHI_INT;
   }

branches/czw_branch/20101203/Ohana/src/opihi/lib.shell/command.c

@@ -10 +10 @@
   Command *cmd;
 
-  // rawline = NULL;
-  rawline = strcreate (line);
+  // the input line is never NULL
+  if (!line) { fprintf (stderr, "programming error\n"); abort(); }
+
+  rawline = strcreate (line);  // used for error messages which should echo the unparsed line
 
   /* force a space between ! and first word: !ls becomes ! ls */
@@ -22 +24 @@
   /* expand anything of the form $fred or $fred$sam, etc */ 
   line = expand_vars (line);     /* line is freed here, new one allocated */
+  if (!line) goto escape;
+
   /* expand anything of the form fred[N] */ 
   line = expand_vectors (line);  /* line is freed here, new one allocated */
+  if (!line) goto escape;
 
   // print the line with the variables and vectors expanded, but before evaluating 
@@ -29 +34 @@
   if (VERBOSE_SHELL == OPIHI_VERBOSE_ON) gprint (GP_ERR, "opihi: %s\n", line);
 
-  /* solve math expresions, assign variable, if needed */
-  line = parse (line);        /* line is freed here, new one allocated */
-  /* any entry in line of the form {foo} returns value or tmp vector / buffer */
+  /* solve math expresions, assign variable, if needed.  any entry in line of the form {foo}
+   * returns value or tmp vector / buffer */
+  line = parse (&status, line);        /* line is freed here, new one allocated */
+  if (!status) goto escape;
 
   /* we may have reallocated line, return new pointer */
@@ -39 +45 @@
   if (argc == 0) {
       FREE (rawline);
+      set_int_variable ("STATUS", TRUE);
       return (TRUE);  /* empty command or assignment */
   }
@@ -74 +81 @@
   FREE (rawline);
   return (status);
+
+ escape:
+  set_int_variable ("STATUS", FALSE);
+
+  # if (DEBUG) 
+  gprint (GP_ERR, "command: %s, status: %d\n", line, FALSE);
+  # endif
+
+  FREE (rawline);
+
+  if (VERBOSE_SHELL != OPIHI_VERBOSE_OFF) gprint (GP_ERR, "error on line: %s\n", rawline);
+
+  // return the current value of line, in case it was modified
+  *outline = line;
+  return FALSE;
 }
 

branches/czw_branch/20101203/Ohana/src/opihi/lib.shell/expand_vars.c

@@ -64 +64 @@
     /* variable assignment (skip these variables) */
     if ((L == line) && (V1 != NULL)) {
-      if ((*V1 == '=') || !strcmp (V1, "++") || !strcmp (V1, "--")) {
+      int isAssignment;
+
+      isAssignment = FALSE;
+      isAssignment |= (V1[0] == '=');
+      isAssignment |= (V1[0] == '+') && (V1[1] == '=');
+      isAssignment |= (V1[0] == '-') && (V1[1] == '=');
+      isAssignment |= (V1[0] == '+') && (V1[1] == '+');
+      isAssignment |= (V1[0] == '-') && (V1[1] == '-');
+
+      if (isAssignment) {
         *N = *L;
         free (V0);

branches/czw_branch/20101203/Ohana/src/opihi/lib.shell/parse.c

@@ -1 +1 @@
 # include "opihi.h"
 
-char *parse (char *line) {
+char *parse (int *status, char *line) {
 
   double fval;
   float *fptr;
   char *newline, *N, *L, *val, *B, *V, *V0, *V1, *c1, *c2, *p;
-  int Nx, Ny, Nbytes, status, size, NLINE, isBuffer, inRange;
+  int Nx, Ny, Nbytes, filestatus, size, NLINE, isBuffer, inRange;
   FILE *f;
   Vector *vec;
   Buffer *buf;
+
+  *status = TRUE; 
 
   Ny = 0;
@@ -49 +51 @@
     }
 
+    if (!strncmp (V1, "+=", 2)) {
+        V1 ++;
+        if (*V1 == 0) goto error;
+        V1 ++;
+        if (*V1 == 0) goto error;
+
+        val = get_variable (V0);
+        if (val == NULL) {
+            fval = 0.0;
+        } else {
+            fval = atof (val);
+        }
+
+        /* dvomath returns a new string, or NULL, with the result of the expression */
+        val = dvomath (1, &V1, &size, 0);
+        if (val == NULL) goto error;
+        fval += atof(val);
+        // save the result
+        set_variable (V0, fval);
+        goto escape;
+    }
+
+    if (!strncmp (V1, "-=", 2)) {
+        V1 ++;
+        if (*V1 == 0) goto error;
+        V1 ++;
+        if (*V1 == 0) goto error;
+
+        val = get_variable (V0);
+        if (val == NULL) {
+            fval = 0.0;
+        } else {
+            fval = atof (val);
+        }
+
+        /* dvomath returns a new string, or NULL, with the result of the expression */
+        val = dvomath (1, &V1, &size, 0);
+        if (val == NULL) goto error;
+        fval -= atof(val);
+        // save the result
+        set_variable (V0, fval);
+        goto escape;
+    }
+
     /* not an assignement, syntax error */
     if (*V1 != '=') goto error;
@@ -73 +119 @@
       Nbytes = fread (val, 1, 1023, f);
       val[Nbytes] = 0;
-      status = pclose (f);
+      filestatus = pclose (f);
       free (B);
 
-      if (status) gprint (GP_ERR, "warning: exit status of command %d\n", status);
+      if (filestatus) gprint (GP_ERR, "warning: exit status of command %d\n", filestatus);
 
       /* convert all but last return to ' '.  drop last return */
@@ -88 +134 @@
         }
       }
+      // save the resulting value
+      set_str_variable (V0, val);
+      goto escape;  /* frees temp variables */
+    }
+
+    /* simple variable assignment */
+    /* dvomath returns a new string, or NULL, with the result of the expression */
+    val = dvomath (1, &V1, &size, 0);
+    if (val == NULL) { 
+      while (OHANA_WHITESPACE (*V1)) V1++;
+      val = strcreate (V1);
     } 
-
-    /* simple variable assignment */
-    if (*V1 != '`') {
-      /* dvomath returns a new string, or NULL, with the result of the expression */
-      val = dvomath (1, &V1, &size, 0);
-      if (val == NULL) { 
-        while (OHANA_WHITESPACE (*V1)) V1++;
-        val = strcreate (V1);
-      } 
-    }
-    /* both dvomath and command replacement create (char *) val */
+    // save the result
     set_str_variable (V0, val);
     goto escape;  /* frees temp variables */
@@ -172 +219 @@
       if (!inRange) {
         gprint (GP_ERR, "no element %d,%d\n", Nx, Ny);
-        goto escape;
+        goto error;
       }
       if (Nx < 0) Nx += buf[0].header.Naxis[0];
@@ -188 +235 @@
       if (!inRange) {
         gprint (GP_ERR, "no element %d\n", Nx);
-        goto escape;
+        goto error;
       }
       if (Nx < 0) Nx += vec[0].Nelements;
@@ -197 +244 @@
       }
     }
-
     goto escape;
   }
@@ -226 +272 @@
     if (c1 == NULL) {
       gprint (GP_ERR, "no close brackets!\n");
-      goto escape;
+      goto error;
     }
     c2 = strchr (L, '{');
     if ((c2 != NULL) && (c2 < c1)) {
       gprint (GP_ERR, "can't nest brackets!\n");
-      goto escape;
+      goto error;
     }
     *c1 = 0;
@@ -240 +286 @@
     if (val == NULL) {
       print_error ();
-      goto escape;
+      goto error;
     } 
 
@@ -257 +303 @@
   
   REALLOCATE (newline, char, strlen (newline) + 1);
+  *status = TRUE;
   return (newline); 
 
 error:
   gprint (GP_ERR, "syntax error\n");
-
-escape:
+  // assignment or increment operation: free line and return NULL
   if (line != (char *) NULL) free (line);
   if (val != (char *) NULL) free (val);
   if (V0 != (char *) NULL) free (V0);
+  *status = FALSE;
+  return NULL;
+
+escape:
+  // assignment or increment operation: free line and return NULL
+  if (line != (char *) NULL) free (line);
+  if (val != (char *) NULL) free (val);
+  if (V0 != (char *) NULL) free (V0);
+  *status = TRUE;
   return (NULL);
 }

branches/czw_branch/20101203/Ohana/src/opihi/lib.shell/stack_math.c

@@ -972 +972 @@
         *out = OP;                                              \
       }                                                         \
-      clear_stack (V1);                                         \
-      return (TRUE);                                            \
+      goto escape;                                              \
     }                                                           \
     if ((V1->vector->type == OPIHI_INT) && (FTYPE == 'S')) {    \
@@ -982 +981 @@
         *out = OP;                                              \
       }                                                         \
-      clear_stack (V1);                                         \
-      return (TRUE);                                            \
+      goto escape;                                              \
     }                                                           \
     if ((V1->vector->type == OPIHI_INT) && (FTYPE == 's')) {    \
@@ -992 +990 @@
         *out = OP;                                              \
       }                                                         \
-      clear_stack (V1);                                         \
-      return (TRUE);                                            \
+      goto escape;                                              \
     } }                                                 
 
@@ -1035 +1032 @@
 # undef V_FUNC
 
+escape:
+
   if (V1[0].type == 'v') {
     free (V1[0].vector[0].elements.Ptr);