IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jul 16, 2006, 10:58:49 PM (20 years ago)
Author:
eugene
Message:

major updates to use gprint for buffered / threaded printing

Location:
trunk/Ohana/src/opihi/cmd.data
Files:
102 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/cmd.data/accum.c

    r4689 r7917  
    1616
    1717  if ((argc != 6) && (argc != 7)) {
    18     fprintf (stderr, "USAGE: accum <value> <vector> <key> start end [delta]\n");
    19     fprintf (stderr, "  sum <value> in bins corresponding to the value of <key>\n");
     18    gprint (GP_ERR, "USAGE: accum <value> <vector> <key> start end [delta]\n");
     19    gprint (GP_ERR, "  sum <value> in bins corresponding to the value of <key>\n");
    2020    return (FALSE);
    2121  }
    … …  
    2424  if ((key = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2525  if (val[0].Nelements != key[0].Nelements) {
    26     fprintf (stderr, "key and value don't match\n");
     26    gprint (GP_ERR, "key and value don't match\n");
    2727    return (FALSE);
    2828  }
    … …  
    3636    delta = 1;
    3737  if ((start == end) || (delta == 0)) {
    38     fprintf (stderr, "error in value: %f to %f, %f\n", start, end, delta);
     38    gprint (GP_ERR, "error in value: %f to %f, %f\n", start, end, delta);
    3939    return (FALSE);
    4040  }

  • trunk/Ohana/src/opihi/cmd.data/applyfit.c

    r2598 r7917  
    1212
    1313  if (argc != 3) {
    14     fprintf (stderr, "USAGE: applyfit x y\n");
     14    gprint (GP_ERR, "USAGE: applyfit x y\n");
    1515    return (FALSE);
    1616  }
    … …  
    1818  c = get_variable ("Cn");
    1919  if (c == (char *) NULL) {
    20     fprintf (stderr, "no fit available\n");
     20    gprint (GP_ERR, "no fit available\n");
    2121    return (FALSE);
    2222  }
    … …  
    3131    c = get_variable (name);
    3232    if (c == (char *) NULL) {
    33       fprintf (stderr, "missing fit term %d\n", i);
     33      gprint (GP_ERR, "missing fit term %d\n", i);
    3434      return (FALSE);
    3535    }

  • trunk/Ohana/src/opihi/cmd.data/applyfit2d.c

    r2598 r7917  
    1212
    1313  if (argc != 4) {
    14     fprintf (stderr, "USAGE: applyfit x y z\n");
     14    gprint (GP_ERR, "USAGE: applyfit x y z\n");
    1515    return (FALSE);
    1616  }
    … …  
    1818  c = get_variable ("Cnn");
    1919  if (c == (char *) NULL) {
    20     fprintf (stderr, "no fit available\n");
     20    gprint (GP_ERR, "no fit available\n");
    2121    return (FALSE);
    2222  }
    … …  
    3434      c = get_variable (name);
    3535      if (c == (char *) NULL) {
    36         fprintf (stderr, "missing fit term %d,%d\n", i, j);
     36        gprint (GP_ERR, "missing fit term %d,%d\n", i, j);
    3737        return (FALSE);
    3838      }

  • trunk/Ohana/src/opihi/cmd.data/box.c

    r6684 r7917  
    5353     
    5454 usage:
    55   fprintf (stderr, "USAGE: box [-ticks NNNN] [-axis NNNN] [-labels NNNN]\n");
     55  gprint (GP_ERR, "USAGE: box [-ticks NNNN] [-axis NNNN] [-labels NNNN]\n");
    5656  return (FALSE);
    5757}

  • trunk/Ohana/src/opihi/cmd.data/center.c

    r5846 r7917  
    1616
    1717  if ((argc != 3) && (argc != 4)) {
    18     fprintf (stderr, "USAGE: center x y [zoom]\n");
     18    gprint (GP_ERR, "USAGE: center x y [zoom]\n");
    1919    return (FALSE);
    2020  }

  • trunk/Ohana/src/opihi/cmd.data/clear.c

    r5850 r7917  
    2121
    2222  if (argc != 1) {
    23     fprintf (stderr, "USAGE: clear [-n Xgraph]\n");
     23    gprint (GP_ERR, "USAGE: clear [-n Xgraph]\n");
    2424    return (FALSE);
    2525  }

  • trunk/Ohana/src/opihi/cmd.data/clip.c

    r4689 r7917  
    2727
    2828  if ((argc != 6) && (!(DO_INF || DO_NAN))) {
    29     fprintf (stderr, "USAGE: clip (buffer) [min Vmin max Vmax] [-inf val] [-nan val]\n");
     29    gprint (GP_ERR, "USAGE: clip (buffer) [min Vmin max Vmax] [-inf val] [-nan val]\n");
    3030    return (FALSE);
    3131  }

  • trunk/Ohana/src/opihi/cmd.data/concat.c

    r2598 r7917  
    1010  /** check basic syntax **/
    1111  if (argc != 3) {
    12     fprintf (stderr, "SYNTAX: concat (vector/value) vector\n");
    13     fprintf (stderr, "  concatanate (vector/value) to vector\n");
     12    gprint (GP_ERR, "SYNTAX: concat (vector/value) vector\n");
     13    gprint (GP_ERR, "  concatanate (vector/value) to vector\n");
    1414    return (FALSE);
    1515  }

  • trunk/Ohana/src/opihi/cmd.data/contour.c

    r2598 r7917  
    7171 
    7272  if (argc != 5) {
    73     fprintf (stderr, "USAGE: contour <buffer> X Y level\n");
     73    gprint (GP_ERR, "USAGE: contour <buffer> X Y level\n");
    7474    return (FALSE);
    7575  }
    … …  
    9797
    9898  for (j = 1; j < Ny; j++) {
    99     if (!(j%10)) fprintf (stderr, ".");
     99    if (!(j%10)) gprint (GP_ERR, ".");
    100100    for (i = 1; i < Nx; i++, v00++, v01++, v10++, v11++) {
    101101

  • trunk/Ohana/src/opihi/cmd.data/create.c

    r7080 r7917  
    1515 
    1616  if ((argc != 5) && (argc != 4)) {
    17     fprintf (stderr, "USAGE: create vector start end [delta]\n");
     17    gprint (GP_ERR, "USAGE: create vector start end [delta]\n");
    1818    return (FALSE);
    1919  }
    … …  
    2626  if (argc == 5) delta = atof (argv[4]);
    2727  if ((start == end) || (delta == 0)) {
    28     fprintf (stderr, "error in value: %f to %f, %f\n", start, end, delta);
     28    gprint (GP_ERR, "error in value: %f to %f, %f\n", start, end, delta);
    2929    return (FALSE);
    3030  }
    … …  
    5050
    5151  if (argc != 4) {
    52     fprintf (stderr, "USAGE: create -image buffer Nx Ny\n");
     52    gprint (GP_ERR, "USAGE: create -image buffer Nx Ny\n");
    5353    return (FALSE);
    5454  }

  • trunk/Ohana/src/opihi/cmd.data/cursor.c

    r7080 r7917  
    3535
    3636  if ((argc != 1) && (argc != 2)) {
    37     fprintf (stderr, "USAGE: cursor [Npts] [-n window] [-g | -i]\n");
     37    gprint (GP_ERR, "USAGE: cursor [Npts] [-n window] [-g | -i]\n");
    3838    return (FALSE);
    3939  }
    … …  
    6060        Z = gfits_get_matrix_value (&buf[0].matrix, (int) X, (int) Y);
    6161      }
    62       fprintf (GetOutfile(), "%s %f %f  %f\n", key, X, Y, Z);
     62      gprint (GP_LOG, "%s %f %f  %f\n", key, X, Y, Z);
    6363    } else {
    6464      XY_to_RD (&R, &D, X, Y, &graphmode.coords);
    … …  
    6767      sprintf (string, "D%s", key);
    6868      set_variable (string, D);
    69       fprintf (GetOutfile(), "%s %f %f\n", key, X, Y);
     69      gprint (GP_LOG, "%s %f %f\n", key, X, Y);
    7070    }
    7171    if (!strcasecmp (key, "Q")) break;

  • trunk/Ohana/src/opihi/cmd.data/cut.c

    r2843 r7917  
    2222
    2323  if (argc != 9) {
    24     fprintf (stderr, "USAGE: cut <buffer> <X vector> <Y vector> <X|Y> sx sy nx ny\n");
     24    gprint (GP_ERR, "USAGE: cut <buffer> <X vector> <Y vector> <X|Y> sx sy nx ny\n");
    2525    return (FALSE);
    2626  }
    … …  
    3737
    3838  if ((sx < 0) || (sy < 0) || (sx+nx > Nx) || (sy+ny > Ny)) {
    39     fprintf (stderr, "region out of range\n");
     39    gprint (GP_ERR, "region out of range\n");
    4040    return (FALSE);
    4141  }
    … …  
    111111
    112112  default:
    113     fprintf (stderr, "<dir> can be X or Y\n");
     113    gprint (GP_ERR, "<dir> can be X or Y\n");
    114114    return (FALSE);
    115115    break;

  • trunk/Ohana/src/opihi/cmd.data/delete.c

    r3900 r7917  
    1616
    1717  if (argc < 2) {
    18     fprintf (stderr, "USAGE: delete <obiect> [<object> ..]\n");
     18    gprint (GP_ERR, "USAGE: delete <obiect> [<object> ..]\n");
    1919    return (FALSE);
    2020  }
    … …  
    2424    if (DeleteNamedVector (argv[i])) continue;
    2525    if (DeleteNamedScalar (argv[i])) continue;
    26     if (!Quiet) fprintf (stderr, "can't find object %s\n", argv[i]);
     26    if (!Quiet) gprint (GP_ERR, "can't find object %s\n", argv[i]);
    2727  }
    2828

  • trunk/Ohana/src/opihi/cmd.data/device.c

    r2843 r7917  
    2424  if (IsImage) {
    2525    if (!GetImage (&Source, &Nsource)) return (FALSE);
    26     fprintf (stderr, "kii %d\n", Nsource);
     26    gprint (GP_ERR, "kii %d\n", Nsource);
    2727  } else {
    2828    if (!GetGraph (NULL, &Source, &Nsource)) return (FALSE);
    29     fprintf (stderr, "kapa %d\n", Nsource);
     29    gprint (GP_ERR, "kapa %d\n", Nsource);
    3030  }
    3131

  • trunk/Ohana/src/opihi/cmd.data/dimendown.c

    r6678 r7917  
    5858
    5959 usage:
    60     fprintf (stderr, "USAGE: dimendown <buffer> <vector>\n");
    61     fprintf (stderr, "  -x : fill vector with buffer x-coords\n");
    62     fprintf (stderr, "  -y : fill vector with buffer y-coords\n");
     60    gprint (GP_ERR, "USAGE: dimendown <buffer> <vector>\n");
     61    gprint (GP_ERR, "  -x : fill vector with buffer x-coords\n");
     62    gprint (GP_ERR, "  -y : fill vector with buffer y-coords\n");
    6363    return (FALSE);
    6464}

  • trunk/Ohana/src/opihi/cmd.data/dimenup.c

    r7080 r7917  
    99
    1010  if (argc != 5) {
    11     fprintf (stderr, "USAGE: dimenup <vector> <buffer> Nx Ny\n");
     11    gprint (GP_ERR, "USAGE: dimenup <vector> <buffer> Nx Ny\n");
    1212    return (FALSE);
    1313  }
    … …  
    2020  Ny = atof (argv[4]);
    2121  if (Npix != Nx * Ny) {
    22     fprintf (stderr, "dimensions don't match\n");
     22    gprint (GP_ERR, "dimensions don't match\n");
    2323    return (FALSE);
    2424  }

  • trunk/Ohana/src/opihi/cmd.data/dot.c

    r7080 r7917  
    99
    1010  if (argc != 3) {
    11     fprintf (stderr, "USAGE: plot <x> <y>\n");
     11    gprint (GP_ERR, "USAGE: plot <x> <y>\n");
    1212    return (FALSE);
    1313  }

  • trunk/Ohana/src/opihi/cmd.data/erase.c

    r5846 r7917  
    1515
    1616  if (argc < 2) {
    17     fprintf (stderr, "USAGE: erase (overlay) [overlay, overlay, ..] \n");
    18     fprintf (stderr, " (overlay) may be: red (0), green (1), blue (2), yellow (3) or all\n");
     17    gprint (GP_ERR, "USAGE: erase (overlay) [overlay, overlay, ..] \n");
     18    gprint (GP_ERR, " (overlay) may be: red (0), green (1), blue (2), yellow (3) or all\n");
    1919    return (FALSE);
    2020  }
    … …  
    2929    }
    3030    if (!KiiSelectOverlay (argv[i], &N)) {
    31       fprintf (stderr, "%s is not a valid overlay\n", argv[i]);
     31      gprint (GP_ERR, "%s is not a valid overlay\n", argv[i]);
    3232      return (FALSE);
    3333    }

  • trunk/Ohana/src/opihi/cmd.data/extract.c

    r7080 r7917  
    1010
    1111  if (argc != 11) {
    12     fprintf (stderr, "USAGE: extract <from> <to> sx sy nx ny Sx Sy Nx Ny\n");
     12    gprint (GP_ERR, "USAGE: extract <from> <to> sx sy nx ny Sx Sy Nx Ny\n");
    1313    return (FALSE);
    1414  }
    … …  
    2929
    3030  if ((Sy + ny > Ny) || (Sx + nx > Nx)) {
    31     fprintf (stderr, "mismatch between source and dest regions\n");
    32     fprintf (stderr, "%d + %d > %d or %d + %d > %d\n", Sy, ny, Ny, Sx, nx, Nx);
     31    gprint (GP_ERR, "mismatch between source and dest regions\n");
     32    gprint (GP_ERR, "%d + %d > %d or %d + %d > %d\n", Sy, ny, Ny, Sx, nx, Nx);
    3333    return (FALSE);
    3434  }
    … …  
    3838      (sx > in[0].matrix.Naxis[0]) ||
    3939      (sy > in[0].matrix.Naxis[1])) {
    40     fprintf (stderr, "region outside of source image\n");
     40    gprint (GP_ERR, "region outside of source image\n");
    4141    return (FALSE);
    4242  }
    4343
    4444  if ((Sx + nx > Nx) || (Sy + ny > Ny)) {
    45     fprintf (stderr, "source region larger than dest region\n");
     45    gprint (GP_ERR, "source region larger than dest region\n");
    4646    return (FALSE);
    4747  }
    4848  if ((Sx < 0) || (Sy < 0)) {
    49     fprintf (stderr, "dest region out of range\n");
     49    gprint (GP_ERR, "dest region out of range\n");
    5050    return (FALSE);
    5151  }
    … …  
    6868  } else {
    6969    if ((out[0].header.Naxis[1] != Ny) || (out[0].header.Naxis[0] != Nx)) {
    70       fprintf (stderr, "matrix sizes mis-matched\n");
    71       fprintf (stderr, "%d x %d  vs  %d x %d\n", Nx, Ny,
     70      gprint (GP_ERR, "matrix sizes mis-matched\n");
     71      gprint (GP_ERR, "%d x %d  vs  %d x %d\n", Nx, Ny,
    7272               out[0].header.Naxis[0], out[0].header.Naxis[1]);
    7373      return (FALSE);

  • trunk/Ohana/src/opihi/cmd.data/fft1d.c

    r4689 r7917  
    88
    99  if ((argc != 6) || (strcmp (argv[3], "to"))) {
    10     fprintf (stderr, "USAGE: fft1d (real) (imag) to (real) (imag)\n");
     10    gprint (GP_ERR, "USAGE: fft1d (real) (imag) to (real) (imag)\n");
    1111    return (FALSE);
    1212  }
    … …  
    2424  Npix = Ire[0].Nelements;
    2525  if (!ZeroImaginary && (Npix != Iim[0].Nelements)) {
    26     fprintf (stderr, "vector mismatch in size\n");
     26    gprint (GP_ERR, "vector mismatch in size\n");
    2727    return (FALSE);
    2828  }
    2929
    3030  if (!IsBinary (Npix)) {
    31     fprintf (stderr, "Npix is not a binary number!\n");
     31    gprint (GP_ERR, "Npix is not a binary number!\n");
    3232    return (FALSE);
    3333  }

  • trunk/Ohana/src/opihi/cmd.data/fft2d.c

    r7080 r7917  
    1515
    1616  if ((argc != 6) || (strcmp (argv[3], "to"))) {
    17     fprintf (stderr, "USAGE: fft2d (real) (imag) to (real) (imag)\n");
     17    gprint (GP_ERR, "USAGE: fft2d (real) (imag) to (real) (imag)\n");
    1818    return (FALSE);
    1919  }
    … …  
    4343  Naxis[0] = Ny; Naxis[1] = Nx;
    4444  if (!IsBinary (Npix)) {
    45     fprintf (stderr, "dimensions are not binary!\n");
     45    gprint (GP_ERR, "dimensions are not binary!\n");
    4646    return (FALSE);
    4747  }

  • trunk/Ohana/src/opihi/cmd.data/fit.c

    r4689 r7917  
    4242
    4343  if (argc != 4) {
    44     fprintf (stderr, "USAGE: fit x y order [-dy wt] [-quiet/-q] [-clip Nsigma Niter]\n");
     44    gprint (GP_ERR, "USAGE: fit x y order [-dy wt] [-quiet/-q] [-clip Nsigma Niter]\n");
    4545    return (FALSE);
    4646  }
    … …  
    5050
    5151  if (xvec[0].Nelements != yvec[0].Nelements) {
    52     fprintf (stderr, "vectors must have same length\n");
     52    gprint (GP_ERR, "vectors must have same length\n");
    5353    return (FALSE);
    5454  }
    5555  if (Weight && xvec[0].Nelements != dyvec[0].Nelements) {
    56     fprintf (stderr, "vectors must have same length\n");
     56    gprint (GP_ERR, "vectors must have same length\n");
    5757    return (FALSE);
    5858  }
    … …  
    166166     
    167167  /* print & save basic fit parameters */
    168   if (!Quiet) fprintf (stderr, "y = ");
     168  if (!Quiet) gprint (GP_ERR, "y = ");
    169169  for (i = 0; i < nterm; i++) {
    170170    sprintf (name, "C%d", i);
    171171    set_variable (name, b[i][0]);
    172     if (!Quiet) fprintf (stderr, "%f x^%d ", b[i][0], i);
     172    if (!Quiet) gprint (GP_ERR, "%f x^%d ", b[i][0], i);
    173173  }
    174174  sprintf (name, "Cn");
    … …  
    176176 
    177177  /* print & save basic fit parameters */
    178   if (!Quiet) fprintf (stderr, "\n");
    179   if (!Quiet) fprintf (stderr, "    ");
     178  if (!Quiet) gprint (GP_ERR, "\n");
     179  if (!Quiet) gprint (GP_ERR, "    ");
    180180  for (i = 0; i < nterm; i++) {
    181181    sprintf (name, "dC%d", i);
    182182    set_variable (name, sqrt(c[i][i]));
    183     if (!Quiet) fprintf (stderr, "%f     ", sqrt(c[i][i]));
    184   }
    185   if (!Quiet) fprintf (stderr, "\n");
     183    if (!Quiet) gprint (GP_ERR, "%f     ", sqrt(c[i][i]));
     184  }
     185  if (!Quiet) gprint (GP_ERR, "\n");
    186186
    187187  set_variable ("dC", sigma);

  • trunk/Ohana/src/opihi/cmd.data/fit2d.c

    r5850 r7917  
    4848
    4949  if (argc != 5) {
    50     fprintf (stderr, "USAGE: fit x y z order [-dz wt]\n");
     50    gprint (GP_ERR, "USAGE: fit x y z order [-dz wt]\n");
    5151    return (FALSE);
    5252  }
    … …  
    5757
    5858  if (xvec[0].Nelements != yvec[0].Nelements) {
    59     fprintf (stderr, "vectors must have same length\n");
     59    gprint (GP_ERR, "vectors must have same length\n");
    6060    return (FALSE);
    6161  }
    6262  if (xvec[0].Nelements != zvec[0].Nelements) {
    63     fprintf (stderr, "vectors must have same length\n");
     63    gprint (GP_ERR, "vectors must have same length\n");
    6464    return (FALSE);
    6565  }
    6666  if (Weight && xvec[0].Nelements != dzvec[0].Nelements) {
    67     fprintf (stderr, "vectors must have same length\n");
     67    gprint (GP_ERR, "vectors must have same length\n");
    6868    return (FALSE);
    6969  }
    … …  
    160160    }
    161161
    162     fprintf (stderr, "matrix:\n");
     162    gprint (GP_ERR, "matrix:\n");
    163163    for (k = 0; k < wterm; k++) {
    164164        for (K = 0; K < wterm; K++) {
    165             fprintf (stderr, "%f ", c[k][K]);
    166         }
    167         fprintf (stderr, "\n");
     165            gprint (GP_ERR, "%f ", c[k][K]);
     166        }
     167        gprint (GP_ERR, "\n");
    168168    }
    169169
    170170    gaussj (c, wterm, b, 1);
    171171
    172     fprintf (stderr, "inverse:\n");
     172    gprint (GP_ERR, "inverse:\n");
    173173    for (k = 0; k < wterm; k++) {
    174174        for (K = 0; K < wterm; K++) {
    175             fprintf (stderr, "%f ", c[k][K]);
    176         }
    177         fprintf (stderr, "\n");
     175            gprint (GP_ERR, "%f ", c[k][K]);
     176        }
     177        gprint (GP_ERR, "\n");
    178178    }
    179179
    … …  
    182182      for (i = ny = 0; ny < nterm; ny++) {
    183183        for (nx = 0; nx < nterm - ny; nx++, i++) {
    184           fprintf (stderr, "x^%d y^%d: %g\n", nx, ny, b[i][0]);
     184          gprint (GP_ERR, "x^%d y^%d: %g\n", nx, ny, b[i][0]);
    185185        }
    186186      }
    … …  
    228228    maxsigma = ClipNSigma * sigma;
    229229
    230     if (VERBOSE) fprintf (stderr, "mean: %g, sigma: %g, maxsigma: %g\n", mean, sigma, maxsigma);
     230    if (VERBOSE) gprint (GP_ERR, "mean: %g, sigma: %g, maxsigma: %g\n", mean, sigma, maxsigma);
    231231
    232232    /* mask outlier points */
    … …  
    245245      }
    246246    }
    247     if (VERBOSE) fprintf (stderr, "pass: %d, Nmask: %d\n", N, Nmask);
    248   }
    249 
    250   if (!Quiet) fprintf (stderr, "z = ");
     247    if (VERBOSE) gprint (GP_ERR, "pass: %d, Nmask: %d\n", N, Nmask);
     248  }
     249
     250  if (!Quiet) gprint (GP_ERR, "z = ");
    251251  for (N = ny = 0; ny < nterm; ny++) {
    252252    for (nx = 0; nx < nterm - ny; nx++, N++) {
    253253      sprintf (name, "CX%dY%d", nx, ny);
    254254      set_variable (name, b[N][0]);
    255       if (!Quiet) fprintf (stderr, "%f x^%d y^%d  ", b[N][0], nx, ny);
     255      if (!Quiet) gprint (GP_ERR, "%f x^%d y^%d  ", b[N][0], nx, ny);
    256256    }
    257257  }
    … …  
    259259  set_variable (name, (double) order);
    260260 
    261   if (!Quiet) fprintf (stderr, "\n");
     261  if (!Quiet) gprint (GP_ERR, "\n");
    262262
    263263  /* free internal data */

  • trunk/Ohana/src/opihi/cmd.data/gaussdeviate.c

    r3894 r7917  
    2525
    2626 usage:
    27   fprintf (stderr, "USAGE: gaussdeviate (vector) Npts mean sigma\n");
     27  gprint (GP_ERR, "USAGE: gaussdeviate (vector) Npts mean sigma\n");
    2828  return (FALSE);
    2929   
    … …  
    5656
    5757 usage:
    58   fprintf (stderr, "USAGE: gaussintegral Npts mean sigma\n");
     58  gprint (GP_ERR, "USAGE: gaussintegral Npts mean sigma\n");
    5959  return (FALSE);
    6060   

  • trunk/Ohana/src/opihi/cmd.data/gaussj.c

    r2598 r7917  
    5151
    5252 usage:
    53   fprintf (stderr, "USAGE: gaussj A B\n");
    54   fprintf (stderr, "  solves Ax = B, returns 1/A in A and x in B\n");
    55   fprintf (stderr, "  A must be square, B same dimensions\n");
     53  gprint (GP_ERR, "USAGE: gaussj A B\n");
     54  gprint (GP_ERR, "  solves Ax = B, returns 1/A in A and x in B\n");
     55  gprint (GP_ERR, "  A must be square, B same dimensions\n");
    5656  return (FALSE);
    5757   

  • trunk/Ohana/src/opihi/cmd.data/grid.c

    r2843 r7917  
    2525
    2626  if (argc > 1) {
    27     fprintf (stderr, "USAGE: grid [-n graph]\n");
     27    gprint (GP_ERR, "USAGE: grid [-n graph]\n");
    2828    return (FALSE);
    2929  }

  • trunk/Ohana/src/opihi/cmd.data/gridify.c

    r7080 r7917  
    1717
    1818  if (argc != 11) {
    19     fprintf (stderr, "USAGE: gridify x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
     19    gprint (GP_ERR, "USAGE: gridify x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
    2020    return (FALSE);
    2121  }

  • trunk/Ohana/src/opihi/cmd.data/histogram.c

    r2598 r7917  
    88
    99  if ((argc != 6) && (argc != 5)) {
    10     fprintf (stderr, "USAGE: hist invec outvec start end [delta]\n");
     10    gprint (GP_ERR, "USAGE: hist invec outvec start end [delta]\n");
    1111    return (FALSE);
    1212  }
    … …  
    1818 
    1919  if ((start == end) || (delta == 0)) {
    20     fprintf (stderr, "error in value: %f to %f, %f\n", start, end, delta);
     20    gprint (GP_ERR, "error in value: %f to %f, %f\n", start, end, delta);
    2121    return (FALSE);
    2222  }

  • trunk/Ohana/src/opihi/cmd.data/imcut.c

    r2843 r7917  
    1010
    1111  if (argc != 8) {
    12     fprintf (stderr, "USAGE: cut <buffer> <X vector> <Y vector> xs ys xe ye\n");
     12    gprint (GP_ERR, "USAGE: cut <buffer> <X vector> <Y vector> xs ys xe ye\n");
    1313    return (FALSE);
    1414  }
    … …  
    5353
    5454 usage:
    55   fprintf (stderr, "USAGE: circstats <buffer> x y radius\n");
     55  gprint (GP_ERR, "USAGE: circstats <buffer> x y radius\n");
    5656  return (FALSE);
    5757
    5858 range:
    59   fprintf (stderr, "ERROR: coordinates out of range\n");
     59  gprint (GP_ERR, "ERROR: coordinates out of range\n");
    6060  return (FALSE);
    6161
    6262 missed:
    63   fprintf (stderr, "ERROR: buffer not found\n");
     63  gprint (GP_ERR, "ERROR: buffer not found\n");
    6464  return (FALSE);
    6565}

  • trunk/Ohana/src/opihi/cmd.data/imhist.c

    r4399 r7917  
    3434
    3535  if (argc != 4) {
    36     fprintf (stderr, "USAGE: histogram <buffer> <x> <y> [-region sx sy nx ny] [-range min max]\n");
     36    gprint (GP_ERR, "USAGE: histogram <buffer> <x> <y> [-region sx sy nx ny] [-range min max]\n");
    3737    return (FALSE);
    3838  }
    … …  
    4949      (sx+nx > buf[0].matrix.Naxis[0]) ||
    5050      (sy+ny > buf[0].matrix.Naxis[1])) {
    51     fprintf (stderr, "region out of range\n");
     51    gprint (GP_ERR, "region out of range\n");
    5252    return (FALSE);
    5353  }
    … …  
    6363  if ((max == 0) && (min == 0)) {
    6464    max = min = *((float *)(buf[0].matrix.buffer) + sy*buf[0].matrix.Naxis[0] + sx);
    65     fprintf (stderr, "sx: %d, sy: %d, first: %f\n", sx, sy, max);
     65    gprint (GP_ERR, "sx: %d, sy: %d, first: %f\n", sx, sy, max);
    6666    for (j = sy; j < sy + ny; j++) {
    6767      V = (float *)(buf[0].matrix.buffer) + j*buf[0].matrix.Naxis[0] + sx;
    … …  
    7373  }
    7474  dx = (max - min) / 1024.0;
    75   fprintf (stderr, "max %f, min %f, dx %f\n", max, min, dx);
     75  gprint (GP_ERR, "max %f, min %f, dx %f\n", max, min, dx);
    7676 
    7777  vec1[0].Nelements = 1025;

  • trunk/Ohana/src/opihi/cmd.data/imsmooth.c

    r2938 r7917  
    1717
    1818  if (argc != 3) {
    19     fprintf (stderr, "USAGE: imsmooth (input) sigma\n");
     19    gprint (GP_ERR, "USAGE: imsmooth (input) sigma\n");
    2020    return (FALSE);
    2121  }

  • trunk/Ohana/src/opihi/cmd.data/integrate.c

    r2843 r7917  
    1515
    1616  if (argc != 5) {
    17     fprintf (stderr, "USAGE: integrate <x> <y> start end\n");
     17    gprint (GP_ERR, "USAGE: integrate <x> <y> start end\n");
    1818    return (FALSE);
    1919  }
    … …  
    3939  set_variable ("sum", value);
    4040  set_variable ("range", range);
    41   if (VERBOSE) fprintf (GetOutfile(), "sum: %f\n", value);
     41  if (VERBOSE) gprint (GP_LOG, "sum: %f\n", value);
    4242  return (TRUE);
    4343}

  • trunk/Ohana/src/opihi/cmd.data/interpolate.c

    r5850 r7917  
    99  /** check basic syntax **/
    1010  if (argc != 5) {
    11     fprintf (stderr, "USAGE: interpolate Xi Yi Xo Yo\n");
    12     fprintf (stderr, "  Xi Yi - sorted reference vectors\n");
    13     fprintf (stderr, "  Xo    - output positions\n");
    14     fprintf (stderr, "  Yo    - output values\n");
     11    gprint (GP_ERR, "USAGE: interpolate Xi Yi Xo Yo\n");
     12    gprint (GP_ERR, "  Xi Yi - sorted reference vectors\n");
     13    gprint (GP_ERR, "  Xo    - output positions\n");
     14    gprint (GP_ERR, "  Yo    - output values\n");
    1515    return (FALSE);
    1616  }

  • trunk/Ohana/src/opihi/cmd.data/jpeg.c

    r5850 r7917  
    77 
    88  if ((N = get_argument (argc, argv, "--help"))) {
    9     fprintf (stderr, "USAGE: jpeg [-name file] [-g | -i] [-n device] [-ppm]\n");
     9    gprint (GP_ERR, "USAGE: jpeg [-name file] [-g | -i] [-n device] [-ppm]\n");
    1010    return (FALSE);
    1111  }

  • trunk/Ohana/src/opihi/cmd.data/kern.c

    r3261 r7917  
    1313
    1414  if (argc != 3) {
    15     fprintf (stderr, "USAGE: kern buffer (file)\n");
    16     fprintf (stderr, "USAGE: kern buffer (list)\n");
    17     fprintf (stderr, "USAGE: kern buffer -\n");
    18     fprintf (stderr, "kernel file contains a 3x3 matrix for convolution\n");
     15    gprint (GP_ERR, "USAGE: kern buffer (file)\n");
     16    gprint (GP_ERR, "USAGE: kern buffer (list)\n");
     17    gprint (GP_ERR, "USAGE: kern buffer -\n");
     18    gprint (GP_ERR, "kernel file contains a 3x3 matrix for convolution\n");
    1919    return (FALSE);
    2020  }
    … …  
    2727      status = scan_line (stdin, line);
    2828      if (status == EOF) {
    29         fprintf (stderr, "kernel should be a 3x3 matrix...\n");
     29        gprint (GP_ERR, "kernel should be a 3x3 matrix...\n");
    3030        return (FALSE);
    3131      }
    … …  
    4242    f = fopen (argv[2], "r");
    4343    if (f == NULL) {
    44       fprintf (stderr, "file not found: %s\n", argv[2]);
     44      gprint (GP_ERR, "file not found: %s\n", argv[2]);
    4545      return (FALSE);
    4646    }
    … …  
    4848      status = scan_line (f, line);
    4949      if (status == EOF) {
    50         fprintf (stderr, "kernel should be a 3x3 matrix...\n");
     50        gprint (GP_ERR, "kernel should be a 3x3 matrix...\n");
    5151        fclose (f);
    5252      }
    … …  
    6060  }
    6161  if (atoi (list) != 9) {
    62     fprintf (stderr, "kernel should be a 3x3 matrix...\n");
     62    gprint (GP_ERR, "kernel should be a 3x3 matrix...\n");
    6363    return (FALSE);
    6464  }
    … …  
    6868    list = get_variable (line);
    6969    if (list == (char *) NULL) {
    70       fprintf (stderr, "kernel should be a 3x3 matrix...\n");
     70      gprint (GP_ERR, "kernel should be a 3x3 matrix...\n");
    7171      return (FALSE);
    7272    }
    … …  
    7777
    7878 have_kernel:
    79   fprintf (stderr, "working...");
     79  gprint (GP_ERR, "working...");
    8080 
    8181  /* create output buffer */
    … …  
    9090  for (n = 0; n < 3; n++) {
    9191    for (m = 0; m < 3; m++) {
    92       fprintf (stderr, "%d", n*3 + m + 1);
     92      gprint (GP_ERR, "%d", n*3 + m + 1);
    9393      val = kernel[n][m];
    9494      ob = out_buff + NX + 1;
    … …  
    9999    }
    100100  }
    101   fprintf (stderr, "(done)\n");
     101  gprint (GP_ERR, "(done)\n");
    102102
    103103  free (in_buff);

  • trunk/Ohana/src/opihi/cmd.data/keyword.c

    r7080 r7917  
    7676
    7777  if (!((argc == 3) || (!N && argc == 4))) {
    78     fprintf (stderr, "USAGE: keyword <buffer> (KEYWORD) [variable] [-d] [-w(mode) value]\n");
    79     fprintf (stderr, " -w modes: \n");
    80     fprintf (stderr, "  -w  - string\n");
    81     fprintf (stderr, "  -wf - float\n");
    82     fprintf (stderr, "  -wd - int\n");
    83     fprintf (stderr, "  -wb - boolean\n");
    84     fprintf (stderr, "  -wc - comment\n");
    85     fprintf (stderr, "  -ws - full string comment\n");
     78    gprint (GP_ERR, "USAGE: keyword <buffer> (KEYWORD) [variable] [-d] [-w(mode) value]\n");
     79    gprint (GP_ERR, " -w modes: \n");
     80    gprint (GP_ERR, "  -w  - string\n");
     81    gprint (GP_ERR, "  -wf - float\n");
     82    gprint (GP_ERR, "  -wd - int\n");
     83    gprint (GP_ERR, "  -wb - boolean\n");
     84    gprint (GP_ERR, "  -wc - comment\n");
     85    gprint (GP_ERR, "  -ws - full string comment\n");
    8686    return (FALSE);
    8787  }
    … …  
    103103    case BOOLEAN:
    104104      if (strcasecmp (line, "T") && strcasecmp (line, "TRUE") && strcasecmp (line, "F") && strcasecmp (line, "FALSE")) {
    105         fprintf (stderr, "syntax error in boolean value\n");
     105        gprint (GP_ERR, "syntax error in boolean value\n");
    106106        return (FALSE);
    107107      }
    … …  
    130130      set_variable (argv[3], value);
    131131    else
    132       fprintf (GetOutfile(), "%s: %f\n", argv[2], value);
     132      gprint (GP_LOG, "%s: %f\n", argv[2], value);
    133133    return (TRUE);
    134134  }
    … …  
    140140      set_str_variable (argv[3], line);
    141141    else
    142       fprintf (GetOutfile(), "%s: %s\n", argv[2], line);
     142      gprint (GP_LOG, "%s: %s\n", argv[2], line);
    143143    return (TRUE);
    144144  }   
    … …  
    150150    set_str_variable (argv[3], line);
    151151  else
    152     fprintf (GetOutfile(), "%s: %s\n", argv[2], line);
     152    gprint (GP_LOG, "%s: %s\n", argv[2], line);
    153153  return (TRUE);
    154154
    155155 failure:
    156   if (!soft) fprintf (stderr, "keyword %s not found\n", argv[2]);
     156  if (!soft) gprint (GP_ERR, "keyword %s not found\n", argv[2]);
    157157  return (soft);
    158158}

  • trunk/Ohana/src/opihi/cmd.data/labels.c

    r5850 r7917  
    99
    1010  if (get_argument (argc, argv, "-h")) {
    11     fprintf (stderr, "label options: \n");
    12     fprintf (stderr, " -x : bottom-center\n");
    13     fprintf (stderr, " +x : top-center\n");
    14     fprintf (stderr, " -y : right-side\n");
    15     fprintf (stderr, " +y : left-side\n\n");
     11    gprint (GP_ERR, "label options: \n");
     12    gprint (GP_ERR, " -x : bottom-center\n");
     13    gprint (GP_ERR, " +x : top-center\n");
     14    gprint (GP_ERR, " -y : right-side\n");
     15    gprint (GP_ERR, " +y : left-side\n\n");
    1616
    17     fprintf (stderr, " -ul : upper-left corner\n");
    18     fprintf (stderr, " -ll : lower-left corner\n");
    19     fprintf (stderr, " -ur : upper-right corner\n");
    20     fprintf (stderr, " -lr : lower-right corner\n\n");
     17    gprint (GP_ERR, " -ul : upper-left corner\n");
     18    gprint (GP_ERR, " -ll : lower-left corner\n");
     19    gprint (GP_ERR, " -ur : upper-right corner\n");
     20    gprint (GP_ERR, " -lr : lower-right corner\n\n");
    2121
    22     fprintf (stderr, " -fn (font) (size) : set font and size\n");
    23     fprintf (stderr, "   (font) : courier, helvetica, times, symbol\n\n");
    24     fprintf (stderr, " label special characters:\n");
    25     fprintf (stderr, " ^ : superscript\n");
    26     fprintf (stderr, " _ : subscript\n");
    27     fprintf (stderr, " | : default script \n");
    28     fprintf (stderr, " &c, &h, &t, &s : set font\n\n");
     22    gprint (GP_ERR, " -fn (font) (size) : set font and size\n");
     23    gprint (GP_ERR, "   (font) : courier, helvetica, times, symbol\n\n");
     24    gprint (GP_ERR, " label special characters:\n");
     25    gprint (GP_ERR, " ^ : superscript\n");
     26    gprint (GP_ERR, " _ : subscript\n");
     27    gprint (GP_ERR, " | : default script \n");
     28    gprint (GP_ERR, " &c, &h, &t, &s : set font\n\n");
    2929    return (FALSE);
    3030  }
    … …  
    8888
    8989  if (argc != 1) {
    90     fprintf (stderr, "USAGE: labels [-x] [-y] [+x] [+y] [-ul] [-ur] [-ll] [-lr]\n");
     90    gprint (GP_ERR, "USAGE: labels [-x] [-y] [+x] [+y] [-ul] [-ur] [-ll] [-lr]\n");
    9191    return (FALSE);
    9292  }

  • trunk/Ohana/src/opihi/cmd.data/limits.c

    r5850 r7917  
    2525
    2626  if (argc == 1) {
    27     fprintf (stderr, "limits: %f %f %f %f [-a] [-n Xgraph]\n",
     27    gprint (GP_ERR, "limits: %f %f %f %f [-a] [-n Xgraph]\n",
    2828             graphmode.xmin, graphmode.xmax,
    2929             graphmode.ymin, graphmode.ymax);
    … …  
    6161  }
    6262
    63   fprintf (stderr, "USAGE: limits [xrange] [yrange]\n");
    64   fprintf (stderr, " [range] may be either [min max] or a vector\n");
     63  gprint (GP_ERR, "USAGE: limits [xrange] [yrange]\n");
     64  gprint (GP_ERR, " [range] may be either [min max] or a vector\n");
    6565  return (FALSE);
    6666
    6767 error:
    68   fprintf (stderr, "error in vectors\n");
     68  gprint (GP_ERR, "error in vectors\n");
    6969  return (FALSE);
    7070

  • trunk/Ohana/src/opihi/cmd.data/line.c

    r7080 r7917  
    3333
    3434  if (argc != 3) {
    35     fprintf (stderr, "USAGE: plot <x> <y>\n");
     35    gprint (GP_ERR, "USAGE: plot <x> <y>\n");
    3636    return (FALSE);
    3737  }
    … …  
    5151  if ((vecy = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    5252  if (vecy[0].Nelements != vecy[0].Nelements) {
    53     fprintf (stderr, "vectors %s and %s not the same length\n", argv[1], argv[2]);
     53    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[2]);
    5454    return (FALSE);
    5555  }

  • trunk/Ohana/src/opihi/cmd.data/list_header.c

    r7080 r7917  
    1818
    1919  if (argc != 2) {
    20     fprintf (stderr, "USAGE: header <buffer> [-w filename]\n");
     20    gprint (GP_ERR, "USAGE: header <buffer> [-w filename]\n");
    2121    return (FALSE);
    2222  }
    … …  
    2727    f = fopen (filename, "r");
    2828    if (f == (FILE *) NULL) {
    29       fprintf (stderr, "file %s not found\n", filename);
     29      gprint (GP_ERR, "file %s not found\n", filename);
    3030      return (FALSE);
    3131    }
    … …  
    6767    Nbytes = fwrite (p, sizeof(char), nbytes, f);
    6868    if (Nbytes != nbytes) {
    69       fprintf (stderr, "warning: not all printed...\n");
     69      gprint (GP_ERR, "warning: not all printed...\n");
    7070    }
    7171    free (p);
    … …  
    7878
    7979}
     80
     81/* XXX this function is not written in the context of the output file/buffer */

  • trunk/Ohana/src/opihi/cmd.data/load.c

    r5846 r7917  
    2929
    3030  if (argc != 3) {
    31     fprintf (stderr, "USAGE: load (overlay) <filename>\n [-c] [-n]");
    32     fprintf (stderr, "  -c: read overlay in celestial coords\n");
     31    gprint (GP_ERR, "USAGE: load (overlay) <filename>\n [-c] [-n]");
     32    gprint (GP_ERR, "  -c: read overlay in celestial coords\n");
    3333    return (FALSE);
    3434  }
    … …  
    4040  }
    4141  if (f == NULL) {
    42     fprintf (stderr, "can't find file %s\n", argv[2]);
     42    gprint (GP_ERR, "can't find file %s\n", argv[2]);
    4343    return (FALSE);
    4444  }
    … …  
    7979    case 3:
    8080      if (strcmp (type, "TEXT")) {
    81         fprintf (stderr, "syntax error in line:\n   %s\n", line);
     81        gprint (GP_ERR, "syntax error in line:\n   %s\n", line);
    8282        continue;
    8383      }
    … …  
    133133  free (overlay);
    134134
    135   fprintf (stderr, "loaded %d objects\n", Noverlay);
     135  gprint (GP_ERR, "loaded %d objects\n", Noverlay);
    136136
    137137  if (f != stdin) {

  • trunk/Ohana/src/opihi/cmd.data/mcreate.c

    r7080 r7917  
    77
    88  if (argc != 4) {
    9     fprintf (stderr, "USAGE: mcreate <buffer> Nx Ny\n");
     9    gprint (GP_ERR, "USAGE: mcreate <buffer> Nx Ny\n");
    1010    return (FALSE);
    1111  }

  • trunk/Ohana/src/opihi/cmd.data/medacc.c

    r2598 r7917  
    99
    1010  if ((argc != 6) && (argc != 7)) {
    11     fprintf (stderr, "USAGE: medacc <value> <vector> <key> start end [delta]\n");
     11    gprint (GP_ERR, "USAGE: medacc <value> <vector> <key> start end [delta]\n");
    1212    return (FALSE);
    1313  }
    … …  
    1616  if ((key = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    1717  if (val[0].Nelements != key[0].Nelements) {
    18     fprintf (stderr, "key and value don't match\n");
     18    gprint (GP_ERR, "key and value don't match\n");
    1919    return (FALSE);
    2020  }

  • trunk/Ohana/src/opihi/cmd.data/mget.c

    r2598 r7917  
    99
    1010  if (argc != 5) {
    11     fprintf (stderr, "USAGE: mget <buffer> <vector> <-x/-y> <N>\n");
     11    gprint (GP_ERR, "USAGE: mget <buffer> <vector> <-x/-y> <N>\n");
    1212    return (FALSE);
    1313  }
    … …  
    1717
    1818  if (strcasecmp (argv[3], "-x") && strcasecmp (argv[3], "-y")) {
    19     fprintf (stderr, "USAGE: mget <buffer> <vector> <-x/-y> <N>\n");
     19    gprint (GP_ERR, "USAGE: mget <buffer> <vector> <-x/-y> <N>\n");
    2020    return (FALSE);
    2121  }
    … …  
    2727  Nset = atof (argv[4]);
    2828  if (Nset < 0) {
    29     fprintf (stderr, "selection out of range\n");
     29    gprint (GP_ERR, "selection out of range\n");
    3030    return (FALSE);
    3131  }
    … …  
    3535    REALLOCATE (vec[0].elements, float, Npix);
    3636    if (Nset >= Ny) {
    37       fprintf (stderr, "row out of range\n");
     37      gprint (GP_ERR, "row out of range\n");
    3838      return (FALSE);
    3939    }
    … …  
    4848    REALLOCATE (vec[0].elements, float, Npix);
    4949    if (Nset >= Nx) {
    50       fprintf (stderr, "column out of range\n");
     50      gprint (GP_ERR, "column out of range\n");
    5151      return (FALSE);
    5252    }

  • trunk/Ohana/src/opihi/cmd.data/minterpolate.c

    r7080 r7917  
    1919
    2020  if (argc != 4) {
    21     fprintf (stderr, "USAGE: minterpolate <from> <to> scale [-extrapolate]\n");
     21    gprint (GP_ERR, "USAGE: minterpolate <from> <to> scale [-extrapolate]\n");
    2222    return (FALSE);
    2323  }

  • trunk/Ohana/src/opihi/cmd.data/mset.c

    r2598 r7917  
    99
    1010  if (argc != 5) {
    11     fprintf (stderr, "USAGE: mset <buffer> <vector> <-x/-y> <N>\n");
     11    gprint (GP_ERR, "USAGE: mset <buffer> <vector> <-x/-y> <N>\n");
    1212    return (FALSE);
    1313  }
    … …  
    1717
    1818  if (strcasecmp (argv[3], "-x") && strcasecmp (argv[3], "-y")) {
    19     fprintf (stderr, "USAGE: mset <buffer> <vector> <-x/-y> <N>\n");
     19    gprint (GP_ERR, "USAGE: mset <buffer> <vector> <-x/-y> <N>\n");
    2020    return (FALSE);
    2121  }
    … …  
    2828  Nset = atof (argv[4]);
    2929  if (Nset < 0) {
    30     fprintf (stderr, "selection out of range\n");
     30    gprint (GP_ERR, "selection out of range\n");
    3131    return (FALSE);
    3232  }
    … …  
    3434  if (xdir) {
    3535    if (Nx != Npix) {
    36       fprintf (stderr, "dimensions don't match\n");
     36      gprint (GP_ERR, "dimensions don't match\n");
    3737      return (FALSE);
    3838    }
    3939    if (Nset >= Ny) {
    40       fprintf (stderr, "row out of range\n");
     40      gprint (GP_ERR, "row out of range\n");
    4141      return (FALSE);
    4242    }
    … …  
    4949  } else {
    5050    if (Ny != Npix) {
    51       fprintf (stderr, "dimensions don't match\n");
     51      gprint (GP_ERR, "dimensions don't match\n");
    5252      return (FALSE);
    5353    }
    5454    if (Nset >= Nx) {
    55       fprintf (stderr, "column out of range\n");
     55      gprint (GP_ERR, "column out of range\n");
    5656      return (FALSE);
    5757    }

  • trunk/Ohana/src/opihi/cmd.data/peak.c

    r6642 r7917  
    1515
    1616  if ((argc != 5) && (argc != 3)) {
    17     fprintf (stderr, "USAGE: peak <x> <y> [start end]\n");
     17    gprint (GP_ERR, "USAGE: peak <x> <y> [start end]\n");
    1818    return (FALSE);
    1919  }
    … …  
    5050  set_variable ("peaknum", imax);
    5151
    52   if (!QUIET) fprintf (GetOutfile(), "peak %f @ %f (%d)\n", ymax, xmax, imax);
     52  if (!QUIET) gprint (GP_LOG, "peak %f @ %f (%d)\n", ymax, xmax, imax);
    5353
    5454  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/periodogram.c

    r6642 r7917  
    1717
    1818  if (argc != 7) {
    19     fprintf (stderr, "USAGE: periodogram (time) (flux) (minP) (maxP) (period) (power)\n");
     19    gprint (GP_ERR, "USAGE: periodogram (time) (flux) (minP) (maxP) (period) (power)\n");
    2020    return (FALSE);
    2121  }
    … …  
    4646  var = var / (Npt - 1);
    4747
    48   if (VERBOSE) fprintf (stderr, "mean: %f, var: %f, minT: %f, maxT: %f\n", mean, var, minT, maxT);
     48  if (VERBOSE) gprint (GP_ERR, "mean: %f, var: %f, minT: %f, maxT: %f\n", mean, var, minT, maxT);
    4949
    5050  dTime = maxT - minT;
    5151  if (dTime == 0) {
    52     fprintf (stderr, "ERROR: time range is zero\n");
     52    gprint (GP_ERR, "ERROR: time range is zero\n");
    5353    return (FALSE);
    5454  }
    … …  
    101101    ratio = 1 + 0.1*P/dTime;
    102102
    103     if (VERBOSE) fprintf (stderr, "tau: %f, P: %f, ratio: %f, dTime: %f, nextP: %f\n", tau, P, ratio, dTime, P*ratio);
     103    if (VERBOSE) gprint (GP_ERR, "tau: %f, P: %f, ratio: %f, dTime: %f, nextP: %f\n", tau, P, ratio, dTime, P*ratio);
    104104
    105105    P *= ratio;

  • trunk/Ohana/src/opihi/cmd.data/plot.c

    r7080 r7917  
    3333
    3434  if (argc != 3) {
    35     fprintf (stderr, "USAGE: plot <x> <y> [style]\n");
     35    gprint (GP_ERR, "USAGE: plot <x> <y> [style]\n");
    3636    return (FALSE);
    3737  }
    … …  
    5151  if ((yvec = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    5252  if (xvec[0].Nelements != yvec[0].Nelements) {
    53     fprintf (stderr, "vectors %s and %s not the same length\n", argv[1], argv[2]);
     53    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[2]);
    5454    return (FALSE);
    5555  }

  • trunk/Ohana/src/opihi/cmd.data/point.c

    r5846 r7917  
    3232
    3333  if (argc != 7) {
    34     fprintf (stderr, "USAGE: point (overlay) TYPE x y dx dy [-c]\n");
     34    gprint (GP_ERR, "USAGE: point (overlay) TYPE x y dx dy [-c]\n");
    3535    return (FALSE);
    3636  }

  • trunk/Ohana/src/opihi/cmd.data/ps.c

    r5850 r7917  
    5858
    5959help:
    60   fprintf (stderr, "USAGE: ps [-name file.ps] [-g | -i] [-n device] [-raw] [-scale]\n");
     60  gprint (GP_ERR, "USAGE: ps [-name file.ps] [-g | -i] [-n device] [-raw] [-scale]\n");
    6161  return (FALSE);
    6262}

  • trunk/Ohana/src/opihi/cmd.data/queuedelete.c

    r4703 r7917  
    66
    77  if (argc != 2) {
    8     fprintf (stderr, "USAGE: queuedelete (name)\n");
     8    gprint (GP_ERR, "USAGE: queuedelete (name)\n");
    99    return (FALSE);
    1010  }
    … …  
    1212  queue = FindQueue (argv[1]);
    1313  if (queue == NULL) {
    14     fprintf (stderr, "ERROR: queue %s not found\n", argv[1]);
     14    gprint (GP_ERR, "ERROR: queue %s not found\n", argv[1]);
    1515    return (FALSE);
    1616  }

  • trunk/Ohana/src/opihi/cmd.data/queueinit.c

    r4703 r7917  
    66
    77  if (argc != 2) {
    8     fprintf (stderr, "USAGE: queueinit (name)\n");
     8    gprint (GP_ERR, "USAGE: queueinit (name)\n");
    99    return (FALSE);
    1010  }

  • trunk/Ohana/src/opihi/cmd.data/queuelist.c

    r4703 r7917  
    44 
    55  if (argc != 1) {
    6     fprintf (stderr, "USAGE: queuelist\n");
     6    gprint (GP_ERR, "USAGE: queuelist\n");
    77    return (FALSE);
    88  }

  • trunk/Ohana/src/opihi/cmd.data/queuepop.c

    r6249 r7917  
    2727
    2828  if (argc != 2) {
    29     fprintf (stderr, "USAGE: queuepop (queue) [-var variable] [-key N value]\n");
     29    gprint (GP_ERR, "USAGE: queuepop (queue) [-var variable] [-key N value]\n");
    3030    return (FALSE);
    3131  }
    … …  
    3434  queue = FindQueue (argv[1]);
    3535  if (queue == NULL) {
    36     fprintf (stderr, "ERROR: queue %s not found\n", argv[1]);
     36    gprint (GP_ERR, "ERROR: queue %s not found\n", argv[1]);
    3737    return (FALSE);
    3838  }
    … …  
    4646  if (var == NULL) {
    4747      if (line == NULL) {
    48           fprintf (stderr, "queue %s is empty or match not found\n", argv[1]);
     48          gprint (GP_ERR, "queue %s is empty or match not found\n", argv[1]);
    4949          return (FALSE);
    5050      } else {
    51           fprintf (stderr, "%s\n", line);
     51          gprint (GP_ERR, "%s\n", line);
    5252          return (TRUE);
    5353      }

  • trunk/Ohana/src/opihi/cmd.data/queueprint.c

    r4703 r7917  
    66
    77  if (argc != 2) {
    8     fprintf (stderr, "USAGE: queueprint (name)\n");
     8    gprint (GP_ERR, "USAGE: queueprint (name)\n");
    99    return (FALSE);
    1010  }
    … …  
    1212  queue = FindQueue (argv[1]);
    1313  if (queue == NULL) {
    14     fprintf (stderr, "ERROR: queue %s not found\n", argv[1]);
     14    gprint (GP_ERR, "ERROR: queue %s not found\n", argv[1]);
    1515    return (FALSE);
    1616  }
    1717
    18   PrintQueue (GetOutfile(), queue);
     18  PrintQueue (queue);
    1919  return (TRUE);
    2020}

  • trunk/Ohana/src/opihi/cmd.data/queuepush.c

    r4703 r7917  
    2626
    2727  if (argc != 3) {
    28     fprintf (stderr, "USAGE: queuepush (queue) (value) [-key N] [-uniq] [-replace]\n");
     28    gprint (GP_ERR, "USAGE: queuepush (queue) (value) [-key N] [-uniq] [-replace]\n");
    2929    return (FALSE);
    3030  }

  • trunk/Ohana/src/opihi/cmd.data/queuesize.c

    r4703 r7917  
    1515
    1616  if (argc != 2) {
    17     fprintf (stderr, "USAGE: queuesize (name) [-var variable]\n");
     17    gprint (GP_ERR, "USAGE: queuesize (name) [-var variable]\n");
    1818    return (FALSE);
    1919  }
    … …  
    2121  queue = FindQueue (argv[1]);
    2222  if (queue == NULL) {
    23     fprintf (stderr, "ERROR: queue %s not found\n", argv[1]);
     23    gprint (GP_ERR, "ERROR: queue %s not found\n", argv[1]);
    2424    return (FALSE);
    2525  }
    2626
    2727  if (var == (char *) NULL) {
    28     fprintf (stderr, "Nlines: %d\n", queue[0].Nlines);
     28    gprint (GP_ERR, "Nlines: %d\n", queue[0].Nlines);
    2929    return (TRUE);
    3030  }

  • trunk/Ohana/src/opihi/cmd.data/radial.c

    r4689 r7917  
    7070
    7171  if (!Quiet) {
    72     fprintf (GetOutfile(), "     mean     stdev       min       max    Npix     Total\n");
    73     fprintf (GetOutfile(), "%9.4g %9.4g %9.4g %9.4g %7.0f %9.4g\n", Mean, Stdev, min, max, Npix, Sum);
     72    gprint (GP_LOG, "     mean     stdev       min       max    Npix     Total\n");
     73    gprint (GP_LOG, "%9.4g %9.4g %9.4g %9.4g %7.0f %9.4g\n", Mean, Stdev, min, max, Npix, Sum);
    7474  }
    7575
    … …  
    8484
    8585 usage:
    86   fprintf (stderr, "USAGE: circstats <buffer> x y radius\n");
     86  gprint (GP_ERR, "USAGE: circstats <buffer> x y radius\n");
    8787  return (FALSE);
    8888
    8989 range:
    90   fprintf (stderr, "ERROR: coordinates out of range\n");
     90  gprint (GP_ERR, "ERROR: coordinates out of range\n");
    9191  return (FALSE);
    9292
    9393 missed:
    94   fprintf (stderr, "ERROR: buffer not found\n");
     94  gprint (GP_ERR, "ERROR: buffer not found\n");
    9595  return (FALSE);
    9696}

  • trunk/Ohana/src/opihi/cmd.data/rd.c

    r7080 r7917  
    4242
    4343  if (extend && ccdsel) {
    44     fprintf (stderr, "only specify one of -n and -x\n");
     44    gprint (GP_ERR, "only specify one of -n and -x\n");
    4545    return (FALSE);
    4646  }
    4747
    4848  if (argc != 3) {
    49     fprintf (stderr, "USAGE: rd <buffer> <filename> [-head] [-plane N] [-n ccdid] [-x extnum]\n");
     49    gprint (GP_ERR, "USAGE: rd <buffer> <filename> [-head] [-plane N] [-n ccdid] [-x extnum]\n");
    5050    return (FALSE);
    5151  }
    … …  
    5454  f = fopen (argv[2], "r");
    5555  if (f == (FILE *) NULL) {
    56     fprintf (stderr, "file %s not found\n", argv[2]);
     56    gprint (GP_ERR, "file %s not found\n", argv[2]);
    5757    return (FALSE);
    5858  }
    … …  
    7575    Nskip = gfits_read_Xheader (argv[2], &buf[0].header, Nextend);
    7676    if (!Nskip) {
    77       fprintf (stderr, "entry in %s not found\n", argv[2]);
     77      gprint (GP_ERR, "entry in %s not found\n", argv[2]);
    7878      DeleteBuffer (buf);
    7979      return (FALSE);
    … …  
    108108    f = fopen (argv[2], "r");
    109109    if (f == (FILE *) NULL) {
    110       fprintf (stderr, "file %s not found\n", argv[2]);
     110      gprint (GP_ERR, "file %s not found\n", argv[2]);
    111111      DeleteBuffer (buf);
    112112      return (FALSE);
    … …  
    122122    CCDKeyword = get_variable ("CCDKEYWORD");
    123123    if (CCDKeyword == (char *) NULL) {
    124       fprintf (stderr, "CCDKEYWORD variable is not set; ");
    125       fprintf (stderr, "using EXTNAME as default\n");
     124      gprint (GP_ERR, "CCDKEYWORD variable is not set; ");
     125      gprint (GP_ERR, "using EXTNAME as default\n");
    126126      CCDKeyword = strcreate ("EXTNAME");
    127127    }
    … …  
    130130      Nskip = gfits_read_Xheader (argv[2], &buf[0].header, i);
    131131      if (!Nskip) {
    132         fprintf (stderr, "extension %s in %s not found\n", ccdid, argv[2]);
     132        gprint (GP_ERR, "extension %s in %s not found\n", ccdid, argv[2]);
    133133        DeleteBuffer (buf);
    134134        free (CCDKeyword);
    … …  
    136136      }
    137137      if (!gfits_scan (&buf[0].header, CCDKeyword, "%s", 1, ID)) {
    138         fprintf (stderr, "%s not in header\n", CCDKeyword);
     138        gprint (GP_ERR, "%s not in header\n", CCDKeyword);
    139139        DeleteBuffer (buf);
    140140        free (CCDKeyword);
    … …  
    177177    f = fopen (argv[2], "r");
    178178    if (f == (FILE *) NULL) {
    179       fprintf (stderr, "file %s not found\n", argv[2]);
     179      gprint (GP_ERR, "file %s not found\n", argv[2]);
    180180      DeleteBuffer (buf);
    181181      return (FALSE);
    … …  
    203203    if (Nplane > 0) {
    204204      if (plane > Nplane) {
    205         fprintf (stderr, "-plane is too large: %d total planes\n", Nplane);
     205        gprint (GP_ERR, "-plane is too large: %d total planes\n", Nplane);
    206206        DeleteBuffer (buf);
    207207        return (FALSE);
    … …  
    217217
    218218  if (!status) {
    219     fprintf (stderr, "problem reading file, buffer not opened\n");
     219    gprint (GP_ERR, "problem reading file, buffer not opened\n");
    220220    DeleteBuffer (buf);
    221221    return (FALSE);
    … …  
    232232  buf[0].bzero  = buf[0].header.bzero;     /* store the original values */
    233233  buf[0].unsign = buf[0].header.unsign;
    234   fprintf (GetOutfile(), "read %d bytes from %s into buffer %s\n",
     234  gprint (GP_LOG, "read %d bytes from %s into buffer %s\n",
    235235           buf[0].header.size + buf[0].matrix.size, argv[2], argv[1]);
    236236

  • trunk/Ohana/src/opihi/cmd.data/rdseg.c

    r7080 r7917  
    1010
    1111  if (argc != 7) {
    12     fprintf (stderr, "USAGE: rdseg <buffer> <filename> x y nx ny\n");
     12    gprint (GP_ERR, "USAGE: rdseg <buffer> <filename> x y nx ny\n");
    1313    return (FALSE);
    1414  }
    … …  
    2121  f = fopen (argv[2], "r");
    2222  if (f == (FILE *) NULL) {
    23     fprintf (stderr, "file %s not found\n", argv[2]);
     23    gprint (GP_ERR, "file %s not found\n", argv[2]);
    2424    return (FALSE);
    2525  }
    … …  
    4747
    4848  if (!status) {
    49     fprintf (stderr, "problem reading file, buffer not opened\n");
     49    gprint (GP_ERR, "problem reading file, buffer not opened\n");
    5050    DeleteBuffer (buf);
    5151    return (FALSE);
    … …  
    6262  buf[0].bzero  = buf[0].header.bzero;     /* store the original values */
    6363  buf[0].unsign = buf[0].header.unsign;
    64   fprintf (GetOutfile(), "read %d bytes from %s into buffer %s\n",
     64  gprint (GP_LOG, "read %d bytes from %s into buffer %s\n",
    6565           buf[0].header.size + buf[0].matrix.size, argv[2], argv[1]);
    6666

  • trunk/Ohana/src/opihi/cmd.data/read_vectors.c

    r7080 r7917  
    77
    88  if (argc < 2) {
    9     fprintf (stderr, "USAGE: datafile (filename)\n");
     9    gprint (GP_ERR, "USAGE: datafile (filename)\n");
    1010    return (FALSE);
    1111  }
    … …  
    1515  f = fopen (filename, "r");
    1616  if (f == (FILE *) NULL) {
    17     fprintf (stderr, "failed to open file %s\n", argv[1]);
     17    gprint (GP_ERR, "failed to open file %s\n", argv[1]);
    1818    return (FALSE);
    1919  }
    … …  
    4848
    4949  if ((argc < 3) || !(argc % 2)) {
    50     fprintf (stderr, "USAGE: read name N name N ...\n");
     50    gprint (GP_ERR, "USAGE: read name N name N ...\n");
    5151    return (FALSE);
    5252  }
    … …  
    5454
    5555  if (f == (FILE *) NULL) {
    56     fprintf (stderr, "no open file for read\n");
     56    gprint (GP_ERR, "no open file for read\n");
    5757    return (FALSE);
    5858  }
    … …  
    6565  for (i = 0; i < Nvec; i++) {
    6666    if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) {
    67       fprintf (stderr, "USAGE: read name N name N ...\n");
     67      gprint (GP_ERR, "USAGE: read name N name N ...\n");
    6868      free (vec);
    6969      free (col);
    … …  
    7373    for (j = 0; j < strlen (colstr); j++) {
    7474      if (!isdigit(colstr[j])) {
    75         fprintf (stderr, "USAGE: read name N name N ...\n");
     75        gprint (GP_ERR, "USAGE: read name N name N ...\n");
    7676        free (vec);
    7777        free (col);
    … …  
    157157
    158158  if (argc < 2) {
    159     fprintf (stderr, "USAGE: read -fits extension name name ...\n");
    160     fprintf (stderr, "  ('extension' may be a name or number)\n");
     159    gprint (GP_ERR, "USAGE: read -fits extension name name ...\n");
     160    gprint (GP_ERR, "  ('extension' may be a name or number)\n");
    161161    return (FALSE);
    162162  }

  • trunk/Ohana/src/opihi/cmd.data/rebin.c

    r7080 r7917  
    3333
    3434  if (argc != 4) {
    35     fprintf (stderr, "USAGE: rebin <from> <to> scale \n");
    36     fprintf (stderr, "  negative integer scale expands image\n");
     35    gprint (GP_ERR, "USAGE: rebin <from> <to> scale \n");
     36    gprint (GP_ERR, "  negative integer scale expands image\n");
    3737    return (FALSE);
    3838  }
    … …  
    6363    }     
    6464  }
    65   if (VERBOSE) fprintf (GetOutfile(), "rebin %s to %s (%d,%d to %d,%d)\n", argv[1], argv[2], in[0].header.Naxis[0], in[0].header.Naxis[1], nx, ny);
     65  if (VERBOSE) gprint (GP_LOG, "rebin %s to %s (%d,%d to %d,%d)\n", argv[1], argv[2], in[0].header.Naxis[0], in[0].header.Naxis[1], nx, ny);
    6666
    6767  Nx = in[0].header.Naxis[0];
    … …  
    171171   
    172172    /* normalization is broken.  repair please */
    173     if (Normalize) { fprintf (stderr, "normalize not enabled for fractional scaling\n"); }
     173    if (Normalize) { gprint (GP_ERR, "normalize not enabled for fractional scaling\n"); }
    174174
    175175    if (scale < 0) scale = 1.0 / fabs(scale);

  • trunk/Ohana/src/opihi/cmd.data/resize.c

    r5846 r7917  
    3030
    3131  if (argc != 3) {
    32     fprintf (stderr, "USAGE: resize NX NY [-n] [-g | -i]\n");
     32    gprint (GP_ERR, "USAGE: resize NX NY [-n] [-g | -i]\n");
    3333    return (FALSE);
    3434  }

  • trunk/Ohana/src/opihi/cmd.data/roll.c

    r2598 r7917  
    88
    99  if (argc != 4) {
    10     fprintf (stderr, "USAGE: roll <buffer> dx dy\n");
     10    gprint (GP_ERR, "USAGE: roll <buffer> dx dy\n");
    1111    return (FALSE);
    1212  }
    … …  
    1717  dy = atof (argv[3]);
    1818  if (dy != 0) {
    19     fprintf (stderr, "only x rolls implemented for now\n");
     19    gprint (GP_ERR, "only x rolls implemented for now\n");
    2020  }
    2121

  • trunk/Ohana/src/opihi/cmd.data/rotate.c

    r7080 r7917  
    2323
    2424  if (argc != 3) {
    25     fprintf (stderr, "USAGE: rotate <buffer> <angle>\n");
     25    gprint (GP_ERR, "USAGE: rotate <buffer> <angle>\n");
    2626    return (FALSE);
    2727  }
    … …  
    2929
    3030  if ((atof (argv[1]) < -180) || (atof (argv[1]) > 180)) {
    31     fprintf (stderr, "valid rotate angle between -180 and +180 degrees\n");
     31    gprint (GP_ERR, "valid rotate angle between -180 and +180 degrees\n");
    3232    return (FALSE);
    3333  }
    … …  
    9595    X1 = NY - Yo;
    9696    Y1 = Xo;
    97     fprintf (stderr, "%f %f -> %f %f\n", Xo, Yo, X1, Y1);
     97    gprint (GP_ERR, "%f %f -> %f %f\n", Xo, Yo, X1, Y1);
    9898    gfits_modify (&buf[0].header, "CRPIX1", "%lf", 1, X1);
    9999    gfits_modify (&buf[0].header, "CRPIX2", "%lf", 1, Y1);
    … …  
    108108    PC21 = pc11;
    109109    PC22 = pc12;
    110     fprintf (stderr, "%f %f  ->  %f %f\n", pc11, pc12, PC11, PC12);
    111     fprintf (stderr, "%f %f  ->  %f %f\n", pc21, pc22, PC21, PC22);
     110    gprint (GP_ERR, "%f %f  ->  %f %f\n", pc11, pc12, PC11, PC12);
     111    gprint (GP_ERR, "%f %f  ->  %f %f\n", pc21, pc22, PC21, PC22);
    112112    gfits_modify (&buf[0].header, "PC001001", "%le", 1, PC11);
    113113    gfits_modify (&buf[0].header, "PC001002", "%le", 1, PC12);
    … …  
    228228  SinAngle = sin (angle*RAD_DEG);
    229229 
    230   fprintf (stderr, "rotating: %f %f %f\n", angle, CosAngle, SinAngle);
     230  gprint (GP_ERR, "rotating: %f %f %f\n", angle, CosAngle, SinAngle);
    231231
    232232  Lx = NX*fabs(CosAngle) + NY*fabs(SinAngle);
    … …  
    235235  dY = MAX(0,-NX*SinAngle);
    236236  /*
    237   fprintf (stderr, "%f %f  -->  ", Xo, Yo);
     237  gprint (GP_ERR, "%f %f  -->  ", Xo, Yo);
    238238  X1 = Xo*CosAngle - Yo*SinAngle + dX;
    239239  Y1 =  Xo*SinAngle + Yo*CosAngle + dY;
    240   fprintf (stderr, "%f %f\n", X1, Y1);
     240  gprint (GP_ERR, "%f %f\n", X1, Y1);
    241241  */
    242242

  • trunk/Ohana/src/opihi/cmd.data/save.c

    r5846 r7917  
    2121
    2222  if (argc != 3) {
    23     fprintf (stderr, "USAGE: save (overlay) <filename> [-c]\n");
    24     fprintf (stderr, "  -c: write contour in celestial coords\n");
     23    gprint (GP_ERR, "USAGE: save (overlay) <filename> [-c]\n");
     24    gprint (GP_ERR, "  -c: write contour in celestial coords\n");
    2525    return (FALSE);
    2626  }

  • trunk/Ohana/src/opihi/cmd.data/section.c

    r5850 r7917  
    2525  if (argc == 1) {
    2626    KapaGetSection (Xgraph, "*");
    27     fprintf (stderr, "USAGE: section name [x y dx dy]\n");
     27    gprint (GP_ERR, "USAGE: section name [x y dx dy]\n");
    2828    return (TRUE);
    2929  }
    … …  
    4949    return (TRUE);
    5050  }
    51   fprintf (stderr, "USAGE: section name [x y dx dy]\n");
     51  gprint (GP_ERR, "USAGE: section name [x y dx dy]\n");
    5252  return (FALSE);
    5353}

  • trunk/Ohana/src/opihi/cmd.data/select.c

    r3922 r7917  
    1212  /** check basic syntax **/
    1313  if ((argc != 8) || strcmp(argv[2], "=") || strcmp (argv[4], "if") || strcmp (argv[6], "else")) {
    14     fprintf (stderr, "SYNTAX: select vec = vec if (logic expression) else vec\n");
     14    gprint (GP_ERR, "SYNTAX: select vec = vec if (logic expression) else vec\n");
    1515    return (FALSE);
    1616  }

  • trunk/Ohana/src/opihi/cmd.data/set.c

    r3922 r7917  
    88  /** check basic form for line **/
    99  if ((argc < 3) || strcmp(argv[2], "=")) {
    10     fprintf (stderr, "%s = (matrix expression)\n", argv[0]);
     10    gprint (GP_ERR, "%s = (matrix expression)\n", argv[0]);
    1111    return (FALSE);
    1212  }
    … …  
    2828        DeleteNamedVector (out);
    2929        free (out);
    30         fprintf (stderr, "invalid output vector name\n");
     30        gprint (GP_ERR, "invalid output vector name\n");
    3131        return (FALSE);
    3232      }
    … …  
    3838        DeleteNamedBuffer (out);
    3939        free (out);
    40         fprintf (stderr, "invalid output matrix name\n");
     40        gprint (GP_ERR, "invalid output matrix name\n");
    4141        return (FALSE);
    4242      }

  • trunk/Ohana/src/opihi/cmd.data/shift.c

    r2843 r7917  
    1616
    1717  if (argc != 4) {
    18     fprintf (stderr, "USAGE: shift <buffer> dx dy\n");
     18    gprint (GP_ERR, "USAGE: shift <buffer> dx dy\n");
    1919    return (FALSE);
    2020  }
    … …  
    3636
    3737  if ((dx > buf[0].matrix.Naxis[0]) || (dy > buf[0].matrix.Naxis[1])) {
    38     fprintf (stderr, "shifting data out of image\n");
     38    gprint (GP_ERR, "shifting data out of image\n");
    3939    return (FALSE);
    4040  }
    … …  
    9191  }
    9292
    93   fprintf (stderr, "%f %f\n", fdx, fdy);
     93  gprint (GP_ERR, "%f %f\n", fdx, fdy);
    9494  if ((fdx > 0) || (fdy > 0)) {
    9595    double f00, f01, f10, f11;

  • trunk/Ohana/src/opihi/cmd.data/sort.c

    r4689 r7917  
    88
    99  if (argc < 2) {
    10     fprintf (stderr, "USAGE: sort (vector) [vectors ...] \n");
    11     fprintf (stderr, "  first vector is sort key for others\n");
     10    gprint (GP_ERR, "USAGE: sort (vector) [vectors ...] \n");
     11    gprint (GP_ERR, "  first vector is sort key for others\n");
    1212    return (FALSE);
    1313  }
    … …  
    2020  for (i = 0; i < Nvec; i++) {
    2121    if ((vec[i] = SelectVector (argv[i + 1], OLDVECTOR, FALSE)) == NULL) {
    22       fprintf (stderr, "USAGE: sort vector vector ...\n");
     22      gprint (GP_ERR, "USAGE: sort vector vector ...\n");
    2323      free (vec);
    2424      return (FALSE);   
    … …  
    2929      if (Nval != vec[i][0].Nelements) {
    3030        free (vec);
    31         fprintf (stderr, "vectors must all be same length\n");
     31        gprint (GP_ERR, "vectors must all be same length\n");
    3232        return (FALSE);
    3333      }

  • trunk/Ohana/src/opihi/cmd.data/spline_apply.c

    r7080 r7917  
    1313
    1414  if (argc != 7) {
    15     fprintf (stderr, "USAGE: spline_apply <Y> <Y2> <out> (x/y) Nx Ny\n");
     15    gprint (GP_ERR, "USAGE: spline_apply <Y> <Y2> <out> (x/y) Nx Ny\n");
    1616    return (FALSE);
    1717  }

  • trunk/Ohana/src/opihi/cmd.data/spline_construct.c

    r7080 r7917  
    88
    99  if (argc != 4) {
    10     fprintf (stderr, "USAGE: spline_construct <in> <out> (x/y)\n");
     10    gprint (GP_ERR, "USAGE: spline_construct <in> <out> (x/y)\n");
    1111    return (FALSE);
    1212  }

  • trunk/Ohana/src/opihi/cmd.data/stats.c

    r4689 r7917  
    3030
    3131  if (argc != 6) {
    32     fprintf (stderr, "USAGE: stats <buffer> sx sy nx ny\n");
     32    gprint (GP_ERR, "USAGE: stats <buffer> sx sy nx ny\n");
    3333    return (FALSE);
    3434  }
    … …  
    4545      (sx+nx > buf[0].matrix.Naxis[0]) ||
    4646      (sy+ny > buf[0].matrix.Naxis[1])) {
    47     fprintf (stderr, "region out of range\n");
     47    gprint (GP_ERR, "region out of range\n");
    4848    return (FALSE);
    4949  }
    … …  
    9494 
    9595  if (!Quiet) {
    96     fprintf (GetOutfile(), "  mean    stdev    min     max   median   Npix   Total\n");
    97     fprintf (GetOutfile(), "%7.4g %7.4g %7.4g %7.4g %7.4g %7.0f %7.4g\n", N1, sqrt (N2/Npix - N1*N1),
     96    gprint (GP_LOG, "  mean    stdev    min     max   median   Npix   Total\n");
     97    gprint (GP_LOG, "%7.4g %7.4g %7.4g %7.4g %7.4g %7.0f %7.4g\n", N1, sqrt (N2/Npix - N1*N1),
    9898             min, max, median, Npix, Npix*N1);
    9999  }

  • trunk/Ohana/src/opihi/cmd.data/style.c

    r7080 r7917  
    88
    99  if (argc > 1) {
    10     fprintf (stderr, "USAGE: style [-n Ngraph] [-x plot style] [-c color] [-pt point type] [-lt line type] [-lw line width] [-sz size]\n");
     10    gprint (GP_ERR, "USAGE: style [-n Ngraph] [-x plot style] [-c color] [-pt point type] [-lt line type] [-lw line width] [-sz size]\n");
    1111    return (FALSE);
    1212  }

  • trunk/Ohana/src/opihi/cmd.data/subraster.c

    r7080 r7917  
    1111
    1212  if (argc != 11) {
    13     fprintf (stderr, "USAGE: extract <from> <to> sx sy nx ny Sx Sy Nx Ny\n");
     13    gprint (GP_ERR, "USAGE: extract <from> <to> sx sy nx ny Sx Sy Nx Ny\n");
    1414    return (FALSE);
    1515  }
    … …  
    3030
    3131  if ((Sy + ny > Ny) || (Sx + nx > Nx)) {
    32     fprintf (stderr, "mismatch between source and dest regions\n");
    33     fprintf (stderr, "%d + %d > %d or %d + %d > %d\n", Sy, ny, Ny, Sx, nx, Nx);
     32    gprint (GP_ERR, "mismatch between source and dest regions\n");
     33    gprint (GP_ERR, "%d + %d > %d or %d + %d > %d\n", Sy, ny, Ny, Sx, nx, Nx);
    3434    return (FALSE);
    3535  }
    … …  
    3939      (sx > ibuf[0].matrix.Naxis[0]) ||
    4040      (sy > ibuf[0].matrix.Naxis[1])) {
    41     fprintf (stderr, "region outside of source image\n");
     41    gprint (GP_ERR, "region outside of source image\n");
    4242    return (FALSE);
    4343  }
    4444
    4545  if ((Sx + nx > Nx) || (Sy + ny > Ny)) {
    46     fprintf (stderr, "source region larger than dest region\n");
     46    gprint (GP_ERR, "source region larger than dest region\n");
    4747    return (FALSE);
    4848  }
    4949  if ((Sx < 0) || (Sy < 0)) {
    50     fprintf (stderr, "dest region out of range\n");
     50    gprint (GP_ERR, "dest region out of range\n");
    5151    return (FALSE);
    5252  }

  • trunk/Ohana/src/opihi/cmd.data/subset.c

    r3922 r7917  
    1313
    1414  if ((argc < 6) || strcmp(argv[2], "=") || strcmp (argv[4], "if")) {
    15     fprintf (stderr, "SYNTAX: subset vec = vec if (logic expression)\n");
     15    gprint (GP_ERR, "SYNTAX: subset vec = vec if (logic expression)\n");
    1616    return (FALSE);
    1717  }

  • trunk/Ohana/src/opihi/cmd.data/svd.c

    r7080 r7917  
    5959  status = svdcmp (U, W, V, Nx, Ny);
    6060  if (!status) {
    61     fprintf (stderr, "error running svdcmp\n");
     61    gprint (GP_ERR, "error running svdcmp\n");
    6262    return (FALSE);
    6363  }
    … …  
    6565
    6666 usage:
    67   fprintf (stderr, "USAGE: svd A = U w Vt\n");
     67  gprint (GP_ERR, "USAGE: svd A = U w Vt\n");
    6868  return (FALSE);
    6969 

  • trunk/Ohana/src/opihi/cmd.data/swapbytes.c

    r2598 r7917  
    88
    99  if (argc != 2) {
    10     fprintf (stderr, "USAGE: swapbytes <buffer>\n");
     10    gprint (GP_ERR, "USAGE: swapbytes <buffer>\n");
    1111    return (FALSE);
    1212  }
    … …  
    1717  ny = buf[0].matrix.Naxis[1];
    1818
    19   fprintf (stderr, "npix: %d\n", nx*ny);
     19  gprint (GP_ERR, "npix: %d\n", nx*ny);
    2020
    2121  V = buf[0].matrix.buffer;

  • trunk/Ohana/src/opihi/cmd.data/teststats.c

    r2598 r7917  
    3131
    3232  if (argc != 2) {
    33     fprintf (stderr, "USAGE: teststats (vector)\n");
     33    gprint (GP_ERR, "USAGE: teststats (vector)\n");
    3434    return (FALSE);
    3535  }
    … …  
    9898
    9999  if (!Quiet) {
    100     fprintf (stderr, "mean: %f, stdev: %f, min: %f, max: %f, median: %f, mode: %f, Npts: %d\n",
     100    gprint (GP_ERR, "mean: %f, stdev: %f, min: %f, max: %f, median: %f, mode: %f, Npts: %d\n",
    101101             mean, stdev, min, max, median, mode, N);
    102102  }

  • trunk/Ohana/src/opihi/cmd.data/textline.c

    r5850 r7917  
    4141
    4242  if (argc != 4) {
    43     fprintf (stderr, "USAGE: text x y (line) [-fn (font) size] [-rot angle]\n");
     43    gprint (GP_ERR, "USAGE: text x y (line) [-fn (font) size] [-rot angle]\n");
    4444    return (FALSE);
    4545  }
    4646
    4747  if (strlen (argv[3]) > 127) {
    48     fprintf (stderr, "labels currently limited to 127 chars\n");
     48    gprint (GP_ERR, "labels currently limited to 127 chars\n");
    4949    return (FALSE);
    5050  }

  • trunk/Ohana/src/opihi/cmd.data/tv.c

    r5846 r7917  
    3131
    3232  if ((argc != 2) && (argc != 4)) {
    33     fprintf (stderr, "USAGE: tv <buffer> [zero range] [-n Nimage] [-log] [-kill]\n");
     33    gprint (GP_ERR, "USAGE: tv <buffer> [zero range] [-n Nimage] [-log] [-kill]\n");
    3434    return (FALSE);
    3535  }

  • trunk/Ohana/src/opihi/cmd.data/tvcontour.c

    r5846 r7917  
    7171
    7272  if ((argc != 4) && (argc != 5)) {
    73     fprintf (stderr, "USAGE: contour <buffer> (overlay) level [Npix]\n");
     73    gprint (GP_ERR, "USAGE: contour <buffer> (overlay) level [Npix]\n");
    7474    return (FALSE);
    7575  }
    … …  
    8888  Ny = buf[0].header.Naxis[1]/Npix;
    8989  if (Npix != 1) {
    90     fprintf (GetOutfile(), "rebin by a factor of %d (%d,%d)\n", Npix, Nx, Ny);
     90    gprint (GP_LOG, "rebin by a factor of %d (%d,%d)\n", Npix, Nx, Ny);
    9191    ALLOCATE (matrix, float, Nx*Ny);
    9292    bzero (matrix, Nx*Ny*sizeof(float));
    … …  
    104104    }
    105105  } else {
    106     fprintf (stderr, "using scale of 1\n");
     106    gprint (GP_ERR, "using scale of 1\n");
    107107    matrix = (float *)(buf[0].matrix.buffer);
    108108  }
    … …  
    119119  d11 = (level - *v10);
    120120  for (j = 1; j < Ny; j++) {
    121     if (!(j%10)) fprintf (stderr, ".");
     121    if (!(j%10)) gprint (GP_ERR, ".");
    122122    for (i = 1; i < Nx; i++, v00++, v01++, v10++, v11++) {
    123123
    … …  
    281281
    282282  if (Npix != 1) free (matrix);
    283   fprintf (stderr, "\n");
     283  gprint (GP_ERR, "\n");
    284284  return (TRUE);
    285285}

  • trunk/Ohana/src/opihi/cmd.data/tvgrid.c

    r5846 r7917  
    2424 
    2525  if (argc != 3) {
    26     fprintf (stderr, "USAGE: tvgrid (overlay) (buffer)\n");
    27     fprintf (stderr, " (overlay) may be: red, green, blue, yellow\n");
     26    gprint (GP_ERR, "USAGE: tvgrid (overlay) (buffer)\n");
     27    gprint (GP_ERR, " (overlay) may be: red, green, blue, yellow\n");
    2828    return (FALSE);
    2929  }
    … …  
    3434  XY_to_RD (&ra0, &dec0, 0.0, 0.0, &coords);
    3535  XY_to_RD (&ra1, &dec1, (double)buf[0].header.Naxis[0], (double)buf[0].header.Naxis[1], &coords);
    36   fprintf (stderr, "%f %f  %f %f\n", ra0, dec0, ra1, dec1);
     36  gprint (GP_ERR, "%f %f  %f %f\n", ra0, dec0, ra1, dec1);
    3737 
    3838  Noverlay = 0;
    … …  
    6464  ndig1 = 3 + log10(MAX(dec0, dec1)) + ndig2;
    6565  sprintf (format, "%%%d.%df", ndig1, ndig2);
    66   fprintf (stderr, "format: %s..\n", format);
     66  gprint (GP_ERR, "format: %s..\n", format);
    6767
    6868  NX = buf[0].header.Naxis[0];
    … …  
    118118  ndig1 = 3 + log10(MAX(ra0, ra1)) + ndig2;
    119119  sprintf (format, "%%%d.%df", ndig1, ndig2);
    120   fprintf (stderr, "format: %s..\n", format);
     120  gprint (GP_ERR, "format: %s..\n", format);
    121121
    122122  dDEC = MAX (fabs(dec1 - dec0) / 100.0, 0.1);

  • trunk/Ohana/src/opihi/cmd.data/ungridify.c

    r2876 r7917  
    1111
    1212  if (argc != 9) {
    13     fprintf (stderr, "USAGE: ungridify buffer Xmin Xmax Ymin Ymax x y z\n");
     13    gprint (GP_ERR, "USAGE: ungridify buffer Xmin Xmax Ymin Ymax x y z\n");
    1414    return (FALSE);
    1515  }
    … …  
    5050  }
    5151  if (n != Nx*Ny) {
    52     fprintf (stderr, "error in ungrid: %d vs %d (%d x %d)\n", n, Nx*Ny, Nx, Ny);
     52    gprint (GP_ERR, "error in ungrid: %d vs %d (%d x %d)\n", n, Nx*Ny, Nx, Ny);
    5353  }
    5454  vx[0].Nelements = vy[0].Nelements = vz[0].Nelements = n;

  • trunk/Ohana/src/opihi/cmd.data/uniq.c

    r2598 r7917  
    88
    99  if (argc != 3) {
    10     fprintf (stderr, "USAGE: uniq (in) (out)\n");
     10    gprint (GP_ERR, "USAGE: uniq (in) (out)\n");
    1111    return (FALSE);
    1212  }

  • trunk/Ohana/src/opihi/cmd.data/unsign.c

    r2598 r7917  
    55  if (argc == 1) {
    66    if (FT_UNSIGN_MODE)
    7       fprintf (stderr, "mode is now UNSIGNED int \n");
     7      gprint (GP_ERR, "mode is now UNSIGNED int \n");
    88    else
    9       fprintf (stderr, "mode is now SIGNED int \n");
     9      gprint (GP_ERR, "mode is now SIGNED int \n");
    1010    return (TRUE);
    1111  }
    … …  
    2424  }
    2525
    26   fprintf (stderr, "USAGE: unsign [0/1]\n");
     26  gprint (GP_ERR, "USAGE: unsign [0/1]\n");
    2727  return (FALSE);
    2828}

  • trunk/Ohana/src/opihi/cmd.data/vbin.c

    r5850 r7917  
    2525
    2626  if (argc != 4) {
    27     fprintf (stderr, "USAGE: vbin <input> <output> scale \n");
    28     fprintf (stderr, "  (use interpolate to expand)\n");
     27    gprint (GP_ERR, "USAGE: vbin <input> <output> scale \n");
     28    gprint (GP_ERR, "  (use interpolate to expand)\n");
    2929    return (FALSE);
    3030  }
    … …  
    3535  scale  = atof (argv[3]);
    3636  if ((int)(scale) != scale) {
    37     fprintf (stderr, "integer binning only, please\n");
     37    gprint (GP_ERR, "integer binning only, please\n");
    3838    return (FALSE);
    3939  }

  • trunk/Ohana/src/opihi/cmd.data/vclip.c

    r4689 r7917  
    2727
    2828  if ((argc != 6) && (!(DO_INF || DO_NAN))) {
    29     fprintf (stderr, "USAGE: vclip (vector) [min Vmin max Vmax] [-inf val] [-nan val]\n");
     29    gprint (GP_ERR, "USAGE: vclip (vector) [min Vmin max Vmax] [-inf val] [-nan val]\n");
    3030    return (FALSE);
    3131  }

  • trunk/Ohana/src/opihi/cmd.data/vcontour.c

    r5846 r7917  
    6262  Vector *xvec, *yvec, *zvec;
    6363
    64   fprintf (stderr, "vcontour not working yet\n");
     64  gprint (GP_ERR, "vcontour not working yet\n");
    6565  return (FALSE);
    6666
    6767  if (argc != 7) {
    68     fprintf (stderr, "USAGE: vcontour x y z Xc Yc (level)\n");
     68    gprint (GP_ERR, "USAGE: vcontour x y z Xc Yc (level)\n");
    6969    return (FALSE);
    7070  }
    … …  
    109109  d11 = (level - *v10);
    110110  for (j = 1; j < Ny; j++) {
    111     if (!(j%10)) fprintf (stderr, ".");
     111    if (!(j%10)) gprint (GP_ERR, ".");
    112112    for (i = 1; i < Nx; i++, v00++, v01++, v10++, v11++) {
    113113
    … …  
    275275
    276276  if (Npix != 1) free (matrix);
    277   fprintf (stderr, "\n");
     277  gprint (GP_ERR, "\n");
    278278}

  • trunk/Ohana/src/opihi/cmd.data/vgauss.c

    r4303 r7917  
    77  c = get_variable (A); \
    88  if (c == NULL) { \
    9     fprintf (stderr, "missing fit parameter A\n"); \
     9    gprint (GP_ERR, "missing fit parameter A\n"); \
    1010    return (FALSE); \
    1111  } \
    … …  
    3131
    3232  if (argc != 5) {
    33     fprintf (stderr, "USAGE: vgauss <x> <y> <dy> (out)\n");
    34     fprintf (stderr, " uses guesses: C0 (mean), C1 (sigma), C2 (norm), C3 (sky)\n");
     33    gprint (GP_ERR, "USAGE: vgauss <x> <y> <dy> (out)\n");
     34    gprint (GP_ERR, " uses guesses: C0 (mean), C1 (sigma), C2 (norm), C3 (sky)\n");
    3535    return (FALSE);
    3636  }
    … …  
    6464    dchisq = ochisq - chisq;
    6565    ochisq = chisq;
    66     if (!Quiet) fprintf (stderr, "dchisq: %f, Ndof: %d\n", dchisq, Npts - Npar);
     66    if (!Quiet) gprint (GP_ERR, "dchisq: %f, Ndof: %d\n", dchisq, Npts - Npar);
    6767  } 
    68   if (!Quiet) fprintf (stderr, "%d iterations\n", i);
     68  if (!Quiet) gprint (GP_ERR, "%d iterations\n", i);
    6969
    7070  for (i = 0; i < Npts; i++) {
    … …  
    7979    sprintf (name, "C%d", i);
    8080    set_variable (name, par[i]);
    81     if (!Quiet) fprintf (stderr, "%d  %f  %f\n", i, par[i], sqrt(covar[i][i]));
     81    if (!Quiet) gprint (GP_ERR, "%d  %f  %f\n", i, par[i], sqrt(covar[i][i]));
    8282    sprintf (name, "dC%d", i);
    8383    set_variable (name, sqrt(covar[i][i]));

  • trunk/Ohana/src/opihi/cmd.data/vgrid.c

    r7080 r7917  
    1111
    1212  if (argc != 11) {
    13     fprintf (stderr, "USAGE: vgrid x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
     13    gprint (GP_ERR, "USAGE: vgrid x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
    1414    return (FALSE);
    1515  }

  • trunk/Ohana/src/opihi/cmd.data/vload.c

    r5846 r7917  
    2323    remove_argument (N, &argc, argv);
    2424    if (!type) {
    25       fprintf (stderr, "unknown Kii point type %s\n", argv[N]);
     25      gprint (GP_ERR, "unknown Kii point type %s\n", argv[N]);
    2626      return (FALSE);
    2727    }
    … …  
    3636
    3737  if (argc != 4) {
    38     fprintf (stderr, "USAGE: vload (overlay) (xvec) (yvec) [-n]\n");
     38    gprint (GP_ERR, "USAGE: vload (overlay) (xvec) (yvec) [-n]\n");
    3939    return (FALSE);
    4040  }
    … …  
    4949  if ((vecy = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    5050  if (vecx[0].Nelements != vecy[0].Nelements) {
    51     fprintf (stderr, "mismatched vector lengths\n");
     51    gprint (GP_ERR, "mismatched vector lengths\n");
    5252    return (FALSE);
    5353  }

  • trunk/Ohana/src/opihi/cmd.data/vpop.c

    r2598 r7917  
    77
    88  if (argc != 2) {
    9     fprintf (stderr, "USAGE: vpop (vector)\n");
    10     fprintf (stderr, "  remove first element of vector\n");
     9    gprint (GP_ERR, "USAGE: vpop (vector)\n");
     10    gprint (GP_ERR, "  remove first element of vector\n");
    1111    return (FALSE);
    1212  }

  • trunk/Ohana/src/opihi/cmd.data/vroll.c

    r2598 r7917  
    88
    99  if (argc != 2) {
    10     fprintf (stderr, "USAGE: vroll (vector)\n");
    11     fprintf (stderr, "  roll vector elements (first goes to end)\n");
     10    gprint (GP_ERR, "USAGE: vroll (vector)\n");
     11    gprint (GP_ERR, "  roll vector elements (first goes to end)\n");
    1212    return (FALSE);
    1313  }

  • trunk/Ohana/src/opihi/cmd.data/vsmooth.c

    r3893 r7917  
    1616
    1717  if (argc != 3) {
    18     fprintf (stderr, "USAGE: vsmooth (input) sigma\n");
     18    gprint (GP_ERR, "USAGE: vsmooth (input) sigma\n");
    1919    return (FALSE);
    2020  }

  • trunk/Ohana/src/opihi/cmd.data/vstat.c

    r4689 r7917  
    3232
    3333  if (argc != 2) {
    34     fprintf (stderr, "USAGE: vstat (vector)\n");
     34    gprint (GP_ERR, "USAGE: vstat (vector)\n");
    3535    return (FALSE);
    3636  }
    … …  
    9999skip:
    100100  if (!Quiet) {
    101     fprintf (stderr, "mean: %g, stdev: %g, min: %g, max: %g, median: %g, mode: %g, Npts: %d\n",
     101    gprint (GP_ERR, "mean: %g, stdev: %g, min: %g, max: %g, median: %g, mode: %g, Npts: %d\n",
    102102             mean, stdev, min, max, median, mode, N);
    103103  }

  • trunk/Ohana/src/opihi/cmd.data/wd.c

    r7080 r7917  
    5252    if (!strcasecmp (argv[N], "f") || !strcasecmp (argv[N], "false")) outUnsign = FALSE;
    5353    if (outUnsign == -1) {
    54       fprintf (stderr, "-unsign options: t, f, true, false\n");
     54      gprint (GP_ERR, "-unsign options: t, f, true, false\n");
    5555      return (FALSE);
    5656    }
    … …  
    6060
    6161  if (argc != 3) {
    62     fprintf (stderr, "USAGE: wd <buffer> <filename> [-bitpix N] [-bscale X] [-bzero X] [-newplane]\n");
     62    gprint (GP_ERR, "USAGE: wd <buffer> <filename> [-bitpix N] [-bscale X] [-bzero X] [-newplane]\n");
    6363    return (FALSE);
    6464  }
    … …  
    115115    f = fopen (argv[2], "r+");
    116116    if (f == NULL) {
    117       fprintf (stderr, "failed to write file\n");
     117      gprint (GP_ERR, "failed to write file\n");
    118118      status = FALSE;
    119119      goto done1;
    … …  
    124124    status = fwrite (Xhead.buffer, 1, Xhead.size, f);
    125125    if (status != Xhead.size) {
    126       fprintf (stderr, "ERROR: failed writing data to image header\n");
     126      gprint (GP_ERR, "ERROR: failed writing data to image header\n");
    127127      status = FALSE;
    128128      goto done1;
    … …  
    144144    fclose (f);
    145145    if (status != temp_header.size) {
    146       fprintf (stderr, "failed to write file\n");
     146      gprint (GP_ERR, "failed to write file\n");
    147147      status = FALSE;
    148148      goto done1;
    … …  
    150150    /* write the matrix buffer (automatically goes to end of file */
    151151    if (!gfits_write_matrix (argv[2], &temp_matrix)) {
    152       fprintf (stderr, "failed to write file\n");
     152      gprint (GP_ERR, "failed to write file\n");
    153153      status = FALSE;
    154154      goto done1;
    … …  
    164164  /* the actual write-to-disk goes here */
    165165  if (!gfits_write_header (argv[2], &temp_header)) {
    166     fprintf (stderr, "failed to write header\n");
     166    gprint (GP_ERR, "failed to write header\n");
    167167    gfits_free_header (&temp_header);
    168168    gfits_free_matrix (&temp_matrix);
    … …  
    171171 
    172172  if (!gfits_write_matrix (argv[2], &temp_matrix)) {
    173     fprintf (stderr, "failed to write matrix\n");
     173    gprint (GP_ERR, "failed to write matrix\n");
    174174    gfits_free_header (&temp_header);
    175175    gfits_free_matrix (&temp_matrix);

  • trunk/Ohana/src/opihi/cmd.data/write_vectors.c

    r6642 r7917  
    1818
    1919  if (argc < 3) {
    20     fprintf (stderr, "USAGE: write [-f \"format\"] file vector vector ...\n");
     20    gprint (GP_ERR, "USAGE: write [-f \"format\"] file vector vector ...\n");
    2121    return (FALSE);
    2222  }
    … …  
    2525  f = fopen (argv[1], "w");
    2626  if (f == (FILE *) NULL) {
    27     fprintf (stderr, "can't open file for write\n");
     27    gprint (GP_ERR, "can't open file for write\n");
    2828    return (FALSE);
    2929  }
    … …  
    3232  Nvec = (argc - 2);
    3333  if (Nvec < 1) {
    34       fprintf (stderr, "USAGE: write (file) vector vector ...\n");
     34      gprint (GP_ERR, "USAGE: write (file) vector vector ...\n");
    3535      fclose (f);
    3636      return (FALSE);
    … …  
    4141  for (i = 0; i < Nvec; i++) {
    4242    if ((vec[i] = SelectVector (argv[i + 2], OLDVECTOR, FALSE)) == NULL) {
    43       fprintf (stderr, "unknown vector %s\n", argv[i+2]);
    44       fprintf (stderr, "USAGE: write (file) vector vector ...\n");
     43      gprint (GP_ERR, "unknown vector %s\n", argv[i+2]);
     44      gprint (GP_ERR, "USAGE: write (file) vector vector ...\n");
    4545      free (vec);
    4646      fclose (f);
    … …  
    5353  for (i = 0; i < Nvec; i++) {
    5454    if (vec[0][0].Nelements != Ne) {
    55       fprintf (stderr, "error: vectors must all be the same size\n");
     55      gprint (GP_ERR, "error: vectors must all be the same size\n");
    5656      free (vec);
    5757      fclose (f);
    … …  
    8686    p1 = strchr (p0, '%');
    8787    if (p1 == (char *) NULL) {
    88       fprintf (stderr, "mismatch between format and values\n");
     88      gprint (GP_ERR, "mismatch between format and values\n");
    8989      free (fmttype);
    9090      for (i = 0; i < Nvec; i++) free (fmtlist[i]);
    … …  
    109109        break;
    110110      default:
    111         fprintf (stderr, "syntax error in format (only e,f,d,c,x allowed)\n");
     111        gprint (GP_ERR, "syntax error in format (only e,f,d,c,x allowed)\n");
    112112        return (FALSE);
    113113    }

  • trunk/Ohana/src/opihi/cmd.data/zap.c

    r2843 r7917  
    1616
    1717  if (argc != 6) {
    18     fprintf (stderr, "USAGE: zap <buffer> sx sy nx ny [-v value]\n");
     18    gprint (GP_ERR, "USAGE: zap <buffer> sx sy nx ny [-v value]\n");
    1919    return (FALSE);
    2020  }
    … …  
    3838
    3939 error:
    40   fprintf (stderr, "region out of range\n");
     40  gprint (GP_ERR, "region out of range\n");
    4141  return (FALSE);
    4242}

  • trunk/Ohana/src/opihi/cmd.data/zplot.c

    r2843 r7917  
    1818
    1919  if (argc != 6) {
    20     fprintf (stderr, "USAGE: zplot <x> <y> <z> min max\n");
     20    gprint (GP_ERR, "USAGE: zplot <x> <y> <z> min max\n");
    2121    return (FALSE);
    2222  }
    … …  
    3030  if ((zvec = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    3131  if (xvec[0].Nelements != yvec[0].Nelements) {
    32     fprintf (stderr, "vectors %s and %s not the same length\n", argv[1], argv[2]);
     32    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[2]);
    3333    return (FALSE);
    3434  }
    3535  if (xvec[0].Nelements != zvec[0].Nelements) {
    36     fprintf (stderr, "vectors %s and %s not the same length\n", argv[1], argv[3]);
     36    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[3]);
    3737    return (FALSE);
    3838  }
Note: See TracChangeset for help on using the changeset viewer.