IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 7917 for trunk/Ohana/src/opihi


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
Files:
1 added
365 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/cmd.astro/biassub.c

    r4689 r7917  
    2121
    2222  if (argc != 7) {
    23     fprintf (stderr, "USAGE: biassub <buffer> sx sy nx ny dir [-v N V]\n");
    24     fprintf (stderr, "  optional storage of vector and sequence in N and V\n");
     23    gprint (GP_ERR, "USAGE: biassub <buffer> sx sy nx ny dir [-v N V]\n");
     24    gprint (GP_ERR, "  optional storage of vector and sequence in N and V\n");
    2525    return (FALSE);
    2626  }
    … …  
    3333  dir = atof (argv[6]);
    3434  if ((dir != 0) && (dir != 1)) {
    35     fprintf (stderr, " dir must be either 0 (x) or 1 (y)\n");
     35    gprint (GP_ERR, " dir must be either 0 (x) or 1 (y)\n");
    3636    return (FALSE);
    3737  }
    … …  
    4545    nlong = nx;
    4646  }   
    47   fprintf (GetOutfile(), "start: %d %d  size: %d %d\n", sx, sy, nx, ny);
     47  gprint (GP_LOG, "start: %d %d  size: %d %d\n", sx, sy, nx, ny);
    4848
    4949    if ((sx < 0) || (sy < 0) ||
    5050      (sx+nx > buf[0].matrix.Naxis[0]) ||
    5151      (sy+ny > buf[0].matrix.Naxis[1])) {
    52     fprintf (stderr, "region out of range\n");
     52    gprint (GP_ERR, "region out of range\n");
    5353    return (FALSE);
    5454  }

  • trunk/Ohana/src/opihi/cmd.astro/cgrid.c

    r7080 r7917  
    2020
    2121  if (argc != 1) {
    22     fprintf (stderr, "USAGE: cgrid [style]\n");
     22    gprint (GP_ERR, "USAGE: cgrid [style]\n");
    2323    return (FALSE);
    2424  }

  • trunk/Ohana/src/opihi/cmd.astro/coords.c

    r3460 r7917  
    4343  if (!strcmp(&coords.ctype[4], "-WRP")) {
    4444    if (MOSAIC == NULL) {
    45       fprintf (stderr, "must supply mosaic for WRP coords\n");
     45      gprint (GP_ERR, "must supply mosaic for WRP coords\n");
    4646      return (FALSE);
    4747    }
    … …  
    5353  if (mode == SKY) {
    5454    XY_to_RD (&R, &D, X, Y, &coords);
    55     fprintf (GetOutfile(), "%10.6f %10.6f\n", R, D);
     55    gprint (GP_LOG, "%10.6f %10.6f\n", R, D);
    5656    set_variable ("RA", R);
    5757    set_variable ("DEC", D);
    … …  
    6161  if (mode == PIXEL) {
    6262    RD_to_XY (&X, &Y, R, D, &coords);
    63     fprintf (GetOutfile(), "%7.2f %7.2f\n", X, Y);
     63    gprint (GP_LOG, "%7.2f %7.2f\n", X, Y);
    6464    set_variable ("Xc", X);
    6565    set_variable ("Yc", Y);
    … …  
    6969
    7070 syntax:
    71   fprintf (stderr, "USAGE: coords [buffer] (-c R D) / (-p X Y)\n");
    72   fprintf (stderr, "only one of -p or -c can be used\n");
     71  gprint (GP_ERR, "USAGE: coords [buffer] (-c R D) / (-p X Y)\n");
     72  gprint (GP_ERR, "only one of -p or -c can be used\n");
    7373 escape:
    7474  if (MOSAIC != NULL) free (MOSAIC);

  • trunk/Ohana/src/opihi/cmd.astro/cplot.c

    r7391 r7917  
    1111
    1212  if (argc != 3) {
    13     fprintf (stderr, "USAGE: cplot <ra> <dec> [style]\n");
     13    gprint (GP_ERR, "USAGE: cplot <ra> <dec> [style]\n");
    1414    return (FALSE);
    1515  }
    … …  
    2424
    2525  if (xvec[0].Nelements != yvec[0].Nelements) {
    26     fprintf (stderr, "vectors are not the same length\n");
     26    gprint (GP_ERR, "vectors are not the same length\n");
    2727    return (FALSE);
    2828  }

  • trunk/Ohana/src/opihi/cmd.astro/csystem.c

    r2598 r7917  
    1313   
    1414  if (argc != 5) {
    15     fprintf (stderr, "USAGE: csystems [C/G/E/H] [C/G/E/H] X Y\n");
     15    gprint (GP_ERR, "USAGE: csystems [C/G/E/H] [C/G/E/H] X Y\n");
    1616    return (FALSE);
    1717  }
    … …  
    2222    switch (argv[2][0]) {
    2323    case 'C':
    24       fprintf (stderr, "same coordinate system\n");
     24      gprint (GP_ERR, "same coordinate system\n");
    2525      return (TRUE);
    2626      break;
    … …  
    5151      break;
    5252    case 'G':
    53       fprintf (stderr, "error: conversions between galactic and ecliptic not implemented\n");
     53      gprint (GP_ERR, "error: conversions between galactic and ecliptic not implemented\n");
    5454      return (FALSE);
    5555      phi = -62.6*RAD_DEG;
    … …  
    7373      break;
    7474    case 'E':
    75       fprintf (stderr, "error: conversions between galactic and ecliptic not implemented\n");
     75      gprint (GP_ERR, "error: conversions between galactic and ecliptic not implemented\n");
    7676      return (FALSE);
    7777      gettimeofday (&now, (struct timezone *) NULL);
    … …  
    9191
    9292  if (xvec[0].Nelements != yvec[0].Nelements) {
    93     fprintf (stderr, "vectors %s and %s not the same length\n", argv[3], argv[4]);
     93    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[3], argv[4]);
    9494    return (FALSE);
    9595  }

  • trunk/Ohana/src/opihi/cmd.astro/ctimes.c

    r2843 r7917  
    1616
    1717  if (argc != 3) {
    18     fprintf (stderr, "USAGE: ctimes [-ref (value) / -abs (date)] [-var name]\n");
     18    gprint (GP_ERR, "USAGE: ctimes [-ref (value) / -abs (date)] [-var name]\n");
    1919    return (FALSE);
    2020  }
    … …  
    3535      free (Variable);
    3636    } else {
    37       fprintf (stderr, "time: %s\n", date);
     37      gprint (GP_ERR, "time: %s\n", date);
    3838    }
    3939
    … …  
    4444
    4545    if (strcmp (argv[1], "-abs")) {
    46       fprintf (stderr, "syntax error\n");
     46      gprint (GP_ERR, "syntax error\n");
    4747      return (FALSE);
    4848    }
    4949
    5050    if (!str_to_time (argv[2], &time)) {
    51       fprintf (stderr, "syntax error\n");
     51      gprint (GP_ERR, "syntax error\n");
    5252      return (FALSE);
    5353    }
    … …  
    6060      return (TRUE);
    6161    }
    62     fprintf (stderr, "time: %f\n", value);
     62    gprint (GP_ERR, "time: %f\n", value);
    6363    return (TRUE);
    6464  }

  • trunk/Ohana/src/opihi/cmd.astro/cval.c

    r2598 r7917  
    99
    1010  if (argc != 7) {
    11     fprintf (stderr, "USAGE: cval <buffer> x y dx dy sky\n");
     11    gprint (GP_ERR, "USAGE: cval <buffer> x y dx dy sky\n");
    1212    return (FALSE);
    1313  }
    … …  
    2828      (sx+nx > buf[0].matrix.Naxis[0]) ||
    2929      (sy+ny > buf[0].matrix.Naxis[1])) {
    30     fprintf (stderr, "region out of range\n");
     30    gprint (GP_ERR, "region out of range\n");
    3131    return (FALSE);
    3232  }
    … …  
    4545  }
    4646
    47   fprintf (stderr, "cval: %f  sn: %f\n", cval, sqrt(sn));
     47  gprint (GP_ERR, "cval: %f  sn: %f\n", cval, sqrt(sn));
    4848
    4949  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/czplot.c

    r7080 r7917  
    1212
    1313  if (argc != 6) {
    14     fprintf (stderr, "USAGE: czplot <x> <y> <z> min max\n");
     14    gprint (GP_ERR, "USAGE: czplot <x> <y> <z> min max\n");
    1515    return (FALSE);
    1616  }
    … …  
    2828
    2929  if (xvec[0].Nelements != yvec[0].Nelements) {
    30     fprintf (stderr, "vectors %s and %s not the same length\n", argv[1], argv[2]);
     30    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[2]);
    3131    return (FALSE);
    3232  }
    3333  if (xvec[0].Nelements != zvec[0].Nelements) {
    34     fprintf (stderr, "vectors %s and %s not the same length\n", argv[1], argv[3]);
     34    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[3]);
    3535    return (FALSE);
    3636  }

  • trunk/Ohana/src/opihi/cmd.astro/drizzle.c

    r4689 r7917  
    2727
    2828  if (argc != 5) {
    29     fprintf (stderr, "USAGE: transform <from> <to> <weight> (Nlinear)\n");
    30     fprintf (stderr, "  output buffer must exist with target astrometry header\n");
    31     fprintf (stderr, "  Nlinear is the pixel scale for linear astrometric transformation\n");
     29    gprint (GP_ERR, "USAGE: transform <from> <to> <weight> (Nlinear)\n");
     30    gprint (GP_ERR, "  output buffer must exist with target astrometry header\n");
     31    gprint (GP_ERR, "  Nlinear is the pixel scale for linear astrometric transformation\n");
    3232    return (FALSE);
    3333  }
    … …  
    4343  /* for the moment, disable WRP / DIS */
    4444  if (!strcmp(&coords_in.ctype[4], "-WRP") || !strcmp(&coords_out.ctype[4], "-WRP")) {
    45     fprintf (stderr, "WRP mode not implemented for astrom\n");
     45    gprint (GP_ERR, "WRP mode not implemented for astrom\n");
    4646    return (FALSE);
    4747  }
    … …  
    5050  scale_out = sqrt(fabs(coords_out.cdelt1*coords_out.cdelt2*(coords_out.pc1_1*coords_out.pc2_2 - coords_out.pc1_2*coords_out.pc2_1)));
    5151 
    52   fprintf (stderr, "%f - %f\n", scale_in, scale_out);
     52  gprint (GP_ERR, "%f - %f\n", scale_in, scale_out);
    5353
    5454  if (scale_in > scale_out) {

  • trunk/Ohana/src/opihi/cmd.astro/fixwrap.c

    r6678 r7917  
    88
    99  if (argc != 3) {
    10     fprintf (stderr, "USAGE: fixwrap <in> (rowfix)\n");
     10    gprint (GP_ERR, "USAGE: fixwrap <in> (rowfix)\n");
    1111    return (FALSE);
    1212  }

  • trunk/Ohana/src/opihi/cmd.astro/flux.c

    r2843 r7917  
    1212
    1313  if (argc != 3) {
    14     fprintf (stderr, "USAGE: flux <buffer> (region)\n");
     14    gprint (GP_ERR, "USAGE: flux <buffer> (region)\n");
    1515    return (FALSE);
    1616  }
    … …  
    2020  f = fopen (argv[2], "r");
    2121  if (f == (FILE *) NULL) {
    22     fprintf (stderr, "file %s not found\n", argv[2]);
     22    gprint (GP_ERR, "file %s not found\n", argv[2]);
    2323    return (FALSE);
    2424  }
    … …  
    4646    bb[i] = hypot (bx[i], by[i]) * SIGN (bx[i]*by[i+1] - bx[i+1]*by[i]);
    4747  }
    48   fprintf (stderr, "%f %f %f %f\n", bb[0], bb[1], bb[2], bb[3]);
     48  gprint (GP_ERR, "%f %f %f %f\n", bb[0], bb[1], bb[2], bb[3]);
    4949
    5050  /* this only works for convex contours --
    … …  
    7070  signal (SIGINT, oldsignal);
    7171
    72   fprintf (GetOutfile(), "flux: %f\n", flux);
     72  gprint (GP_LOG, "flux: %f\n", flux);
    7373  set_variable ("FLUX", flux);
    7474  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/gauss.c

    r5850 r7917  
    3333 
    3434  if ((argc != 2) && (argc != 3)) {
    35     fprintf (stderr, "USAGE: gauss Npix [Nspots] [-border N] [-sat cnts]\n");
     35    gprint (GP_ERR, "USAGE: gauss Npix [Nspots] [-border N] [-sat cnts]\n");
    3636    return (FALSE);
    3737  }
    3838 
    3939  if (Ximage < 1) {
    40     fprintf (stderr, "no active TV\n");
     40    gprint (GP_ERR, "no active TV\n");
    4141    return (FALSE);
    4242  }

  • trunk/Ohana/src/opihi/cmd.astro/getvel.c

    r7080 r7917  
    1313
    1414  if (argc != 5) {
    15     fprintf (stderr, "USAGE: rotcurve buf X Y curve.txt\n");
     15    gprint (GP_ERR, "USAGE: rotcurve buf X Y curve.txt\n");
    1616    return (FALSE);
    1717  }
    … …  
    1919  f = fopen (argv[4], "r");
    2020  if (f == (FILE *) NULL) {
    21     fprintf (stderr, "can't find rotation curve data file %s\n", argv[4]);
     21    gprint (GP_ERR, "can't find rotation curve data file %s\n", argv[4]);
    2222    return (FALSE);
    2323  }
    … …  
    4545  while (L >= 360) {L -= 360.0;}
    4646  while (L < 0.0)  {L += 360.0;}
    47   fprintf (stderr, "L: %f\n", L);
     47  gprint (GP_ERR, "L: %f\n", L);
    4848
    4949  cl = cos (L*RAD_DEG);
    … …  
    5959  for (n = 0; (n < Ncurve) && (wr < W[n]); n++);
    6060  if ((n == 0) || (n == Ncurve)) {
    61     fprintf (stderr, "velocity out of reasonable range\n");
    62     fprintf (stderr, "%f %f %f %f\n", V, wr, W[0], W[Ncurve-1]);
     61    gprint (GP_ERR, "velocity out of reasonable range\n");
     62    gprint (GP_ERR, "%f %f %f %f\n", V, wr, W[0], W[Ncurve-1]);
    6363    return (TRUE);
    6464  }
    … …  
    6666  fr = (Ro/r);
    6767  if (r < fabs(Rs)) { /* can't be on rotation curve */
    68     fprintf (stderr, "velocity out of reasonable range\n");
    69     fprintf (stderr, "%f %f %f %f %f %f %f\n", V, wr, W[0], W[Ncurve-1], r, fr, Rs);
     68    gprint (GP_ERR, "velocity out of reasonable range\n");
     69    gprint (GP_ERR, "%f %f %f %f %f %f %f\n", V, wr, W[0], W[Ncurve-1], r, fr, Rs);
    7070    return (TRUE);
    7171  }
    … …  
    7575    d = Ro*cl + sqrt(r*r - Rs*Rs);
    7676 
    77   fprintf (stderr, "dist: %f, vel: %f\n", d, V);
     77  gprint (GP_ERR, "dist: %f, vel: %f\n", d, V);
    7878
    7979  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/imfit.c

    r4689 r7917  
    6565    qrgauss_setup (argv[N]);
    6666    if (fitfunc == NULL) {
    67       fprintf (stderr, "unknown function %s\n", argv[N]);
     67      gprint (GP_ERR, "unknown function %s\n", argv[N]);
    6868      return (FALSE);
    6969    }
    … …  
    7272
    7373  if (argc != 6) {
    74     fprintf (stderr, "USAGE: imfit <buffer> sx sy nx ny\n");
     74    gprint (GP_ERR, "USAGE: imfit <buffer> sx sy nx ny\n");
    7575    return (FALSE);
    7676  }
    … …  
    170170  if (VERBOSE) {
    171171    for (i = 0; i < Npar; i++) {
    172       fprintf (stderr, "%g ", par[i]);
     172      gprint (GP_ERR, "%g ", par[i]);
    173173    }
    174     fprintf (stderr, "\n");
     174    gprint (GP_ERR, "\n");
    175175  }
    176176
    … …  
    186186
    187187range:
    188   fprintf (stderr, "region out of range\n");
     188  gprint (GP_ERR, "region out of range\n");
    189189  return (FALSE);
    190190}

  • trunk/Ohana/src/opihi/cmd.astro/imsub.c

    r3144 r7917  
    3030    qrgauss_setup (argv[N]);
    3131    if (fitfunc == NULL) {
    32       fprintf (stderr, "unknown function %s\n", argv[N]);
     32      gprint (GP_ERR, "unknown function %s\n", argv[N]);
    3333      return (FALSE);
    3434    }
    … …  
    3737
    3838  if (argc != 6) {
    39     fprintf (stderr, "USAGE: imfit <buffer> sx sy nx ny\n");
     39    gprint (GP_ERR, "USAGE: imfit <buffer> sx sy nx ny\n");
    4040    return (FALSE);
    4141  }
    … …  
    7474
    7575range:
    76   fprintf (stderr, "region out of range\n");
     76  gprint (GP_ERR, "region out of range\n");
    7777  return (FALSE);
    7878}

  • trunk/Ohana/src/opihi/cmd.astro/medianmap.c

    r7080 r7917  
    3131
    3232  if (argc != 5) {
    33     fprintf (stderr, "USAGE: medianmap (in) (out) Nx Ny [-range min max]\n");
    34     fprintf (stderr, "       Nx, Ny specify dimensions of output image\n");
    35     fprintf (stderr, "       min, max specify fractional range for sorted average\n");
     33    gprint (GP_ERR, "USAGE: medianmap (in) (out) Nx Ny [-range min max]\n");
     34    gprint (GP_ERR, "       Nx, Ny specify dimensions of output image\n");
     35    gprint (GP_ERR, "       min, max specify fractional range for sorted average\n");
    3636    return (FALSE);
    3737  }

  • trunk/Ohana/src/opihi/cmd.astro/mkgauss.c

    r2843 r7917  
    2121
    2222  if ((argc < 3) || (argc > 5)) {
    23     fprintf (stderr, "USAGE: mkgauss (buffer) (sigma) [[sy/sx] angle]\n");
     23    gprint (GP_ERR, "USAGE: mkgauss (buffer) (sigma) [[sy/sx] angle]\n");
    2424    return (FALSE);
    2525  }

  • trunk/Ohana/src/opihi/cmd.astro/multifit.c

    r2598 r7917  
    1111
    1212  if (argc != 2) {
    13     fprintf (stderr, "USAGE: multifit (Norder)\n");
     13    gprint (GP_ERR, "USAGE: multifit (Norder)\n");
    1414    return (FALSE);
    1515  }
    … …  
    170170 
    171171 escape:
    172   fprintf (stderr, "syntax error\n");
     172  gprint (GP_ERR, "syntax error\n");
    173173  return (FALSE);
    174174 

  • trunk/Ohana/src/opihi/cmd.astro/objload.c

    r7680 r7917  
    2727
    2828  if (argc != 3) {
    29     fprintf (stderr, "USAGE: objload (overlay) <filename>\n");
     29    gprint (GP_ERR, "USAGE: objload (overlay) <filename>\n");
    3030    return (FALSE);
    3131  }
    … …  
    3333  f = fopen (argv[2], "r");
    3434  if (f == (FILE *) NULL) {
    35     fprintf (stderr, "ERROR: can't find object file %s\n", argv[2]);
     35    gprint (GP_ERR, "ERROR: can't find object file %s\n", argv[2]);
    3636    return (FALSE);
    3737  }
    … …  
    6969  free (line);
    7070
    71   fprintf (stderr, "loaded %d objects\n", Noverlay);
     71  gprint (GP_ERR, "loaded %d objects\n", Noverlay);
    7272  return (TRUE);
    7373}

  • trunk/Ohana/src/opihi/cmd.astro/outline.c

    r5846 r7917  
    1414
    1515  if (argc != 9) {
    16     fprintf (stderr, "USAGE: outline x y dx dy dxy Io (buffer) Npar\n");
     16    gprint (GP_ERR, "USAGE: outline x y dx dy dxy Io (buffer) Npar\n");
    1717    return (FALSE);
    1818  }
    … …  
    4343
    4444  chisq = outline_chi (Io, in, buf[0].matrix.Naxis[0], buf[0].matrix.Naxis[1], &frac);
    45   fprintf (stderr, "chisq (1): %f\n", chisq);
     45  gprint (GP_ERR, "chisq (1): %f\n", chisq);
    4646 
    4747  for (j = 0; j < 15; j++) {
    … …  
    6363          chisq = nchisq;
    6464        }
    65         fprintf (stderr, "frac: %f  %f %f   %f\n", frac, par[2], par[3], chisq);
     65        gprint (GP_ERR, "frac: %f  %f %f   %f\n", frac, par[2], par[3], chisq);
    6666      }
    6767    }
    … …  
    112112        }       
    113113        /*
    114         fprintf (stderr, "try: %d  %f   ", i, chisq);
     114        gprint (GP_ERR, "try: %d  %f   ", i, chisq);
    115115        for (k = 0; k < 5; k++) {
    116           fprintf (stderr, "%f ", par[k]);
     116          gprint (GP_ERR, "%f ", par[k]);
    117117        }
    118         fprintf (stderr, "\n");
     118        gprint (GP_ERR, "\n");
    119119        */
    120120        ochisq = chisq;
    … …  
    130130    }
    131131
    132     fprintf (stderr, "try: %d  %f   ", j, chisq);
     132    gprint (GP_ERR, "try: %d  %f   ", j, chisq);
    133133    for (i = 0; i < 5; i++) {
    134       fprintf (stderr, "%f ", par[i]);
    135     }
    136     fprintf (stderr, "\n          ");
     134      gprint (GP_ERR, "%f ", par[i]);
     135    }
     136    gprint (GP_ERR, "\n          ");
    137137    for (i = 0; i < 5; i++) {
    138       fprintf (stderr, "%f ", dpar[i]);
    139     }
    140     fprintf (stderr, "\n");
     138      gprint (GP_ERR, "%f ", dpar[i]);
     139    }
     140    gprint (GP_ERR, "\n");
    141141    dchi -= chisq;
    142142

  • trunk/Ohana/src/opihi/cmd.astro/outline2.c

    r5846 r7917  
    1818
    1919  if (argc != 9) {
    20     fprintf (stderr, "USAGE: outline x y dx dy dxy Io dIo (buffer)\n");
     20    gprint (GP_ERR, "USAGE: outline x y dx dy dxy Io dIo (buffer)\n");
    2121    return (FALSE);
    2222  }
    … …  
    7878
    7979  if (Npts == 0) {
    80     fprintf (stderr, "no valid points in box, try again\n");
     80    gprint (GP_ERR, "no valid points in box, try again\n");
    8181    free (xs);
    8282    free (ys);
    … …  
    8787  plot_outline ();
    8888  chisq = outline_chi (Io, in);
    89   fprintf (stderr, "starting chisq: %f for %d pts\n", chisq, Npts);
     89  gprint (GP_ERR, "starting chisq: %f for %d pts\n", chisq, Npts);
    9090
    9191# if (1)
    … …  
    139139    }
    140140
    141     fprintf (stderr, "try: %d  %f   ", j, chisq);
     141    gprint (GP_ERR, "try: %d  %f   ", j, chisq);
    142142    for (i = 0; i < 5; i++) {
    143       fprintf (stderr, "%f ", par[i]);
    144     }
    145     fprintf (stderr, "\n          ");
     143      gprint (GP_ERR, "%f ", par[i]);
     144    }
     145    gprint (GP_ERR, "\n          ");
    146146    for (i = 0; i < 5; i++) {
    147       fprintf (stderr, "%f ", dpar[i]);
    148     }
    149     fprintf (stderr, "\n");
     147      gprint (GP_ERR, "%f ", dpar[i]);
     148    }
     149    gprint (GP_ERR, "\n");
    150150    dchi -= chisq;
    151151

  • trunk/Ohana/src/opihi/cmd.astro/polar.c

    r7080 r7917  
    1212
    1313  if (argc != 4) {
    14     fprintf (stderr, "USAGE: polar in out\n");
     14    gprint (GP_ERR, "USAGE: polar in out\n");
    1515    return (FALSE);
    1616  }
    … …  
    2525  ny = mask[0].matrix.Naxis[1];
    2626  if ((Nx != nx) && (Ny != ny)) {
    27     fprintf (stderr, "output and mask must have same dimensions\n");
     27    gprint (GP_ERR, "output and mask must have same dimensions\n");
    2828    return (FALSE);
    2929  }

  • trunk/Ohana/src/opihi/cmd.astro/precess.c

    r2598 r7917  
    1515  in_epoch = out_epoch = 2000.0;
    1616  if (argc != 5) {
    17     fprintf (stderr, "USAGE:  precess (from) (to) RA DEC \n");
    18     fprintf (stderr, "   you may use B for B1950.0 or J for J2000.0\n");
     17    gprint (GP_ERR, "USAGE:  precess (from) (to) RA DEC \n");
     18    gprint (GP_ERR, "   you may use B for B1950.0 or J for J2000.0\n");
    1919    return (FALSE);
    2020  }
    … …  
    5656  }
    5757
    58   fprintf (stderr, "converting from J%f to J%f\n", in_epoch, out_epoch);
     58  gprint (GP_ERR, "converting from J%f to J%f\n", in_epoch, out_epoch);
    5959
    6060  T = (out_epoch - in_epoch) / 100.0;
    … …  
    7777    if (RA < 0)
    7878      RA += 360;
    79     fprintf (GetOutfile(), "%f %f -> %f %f\n", A, D, RA, DEC);
     79    gprint (GP_LOG, "%f %f -> %f %f\n", A, D, RA, DEC);
    8080    return (TRUE);
    8181  }   
    … …  
    8686
    8787  if (xvec[0].Nelements != yvec[0].Nelements) {
    88     fprintf (stderr, "vectors %s and %s not the same length\n", argv[3], argv[4]);
     88    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[3], argv[4]);
    8989    return (FALSE);
    9090  }

  • trunk/Ohana/src/opihi/cmd.astro/profile.c

    r2598 r7917  
    1010
    1111  if (argc != 7) {
    12     fprintf (stderr, "USAGE: profile <buffer> <X vector> <Y vector> x y N\n");
     12    gprint (GP_ERR, "USAGE: profile <buffer> <X vector> <Y vector> x y N\n");
    1313    return (FALSE);
    1414  }
    … …  
    4747
    4848range_error:
    49   fprintf (stderr, "region out of range\n");
     49  gprint (GP_ERR, "region out of range\n");
    5050  return (FALSE);
    5151}

  • trunk/Ohana/src/opihi/cmd.astro/region.c

    r5850 r7917  
    3333
    3434  if ((argc != 4) && (argc != 5)) {
    35     fprintf (stderr, "USAGE: region Ra Dec Radius [projection] [orientation]\n");
    36     fprintf (stderr, " current: %f %f (%f x %f) (%s)\n",
     35    gprint (GP_ERR, "USAGE: region Ra Dec Radius [projection] [orientation]\n");
     36    gprint (GP_ERR, " current: %f %f (%f x %f) (%s)\n",
    3737             graphmode.coords.crval1, graphmode.coords.crval2,
    3838             fabs(graphmode.xmax - graphmode.xmin),

  • trunk/Ohana/src/opihi/cmd.astro/rotcurve.c

    r7080 r7917  
    2121
    2222  if (argc != 5) {
    23     fprintf (stderr, "USAGE: rotcurve in out mask curve.txt\n");
     23    gprint (GP_ERR, "USAGE: rotcurve in out mask curve.txt\n");
    2424    return (FALSE);
    2525  }
    … …  
    2727  f = fopen (argv[4], "r");
    2828  if (f == (FILE *) NULL) {
    29     fprintf (stderr, "can't find rotation curve data file %s\n", argv[4]);
     29    gprint (GP_ERR, "can't find rotation curve data file %s\n", argv[4]);
    3030    return (FALSE);
    3131  }
    … …  
    4545  ny = mask[0].matrix.Naxis[1];
    4646  if ((Nx != nx) && (Ny != ny)) {
    47     fprintf (stderr, "output and mask must have same dimensions\n");
     47    gprint (GP_ERR, "output and mask must have same dimensions\n");
    4848    return (FALSE);
    4949  }
    … …  
    7474  X = (L - Lo) / dL + Xo;
    7575  if ((X >= Nx) || (X < 0)) {
    76     fprintf (stderr, "X out of range\n");
     76    gprint (GP_ERR, "X out of range\n");
    7777    return (FALSE);
    7878  }
    79   fprintf (stderr, "L: %f (%d)\n", L, X);
     79  gprint (GP_ERR, "L: %f (%d)\n", L, X);
    8080
    8181  cl = cos (L*RAD_DEG);

  • trunk/Ohana/src/opihi/cmd.astro/scale.c

    r2598 r7917  
    66
    77  if (argc != 5) {
    8     fprintf (stderr, "USAGE: scale (buffer) (key) [-r/-w] (value)\n");
     8    gprint (GP_ERR, "USAGE: scale (buffer) (key) [-r/-w] (value)\n");
    99    return (FALSE);
    1010  } 
    … …  
    1313
    1414  if (strcasecmp (argv[2], "bzero") && strcasecmp (argv[2], "bscale")) {
    15     fprintf (stderr, "use bzero or bscale only\n");
     15    gprint (GP_ERR, "use bzero or bscale only\n");
    1616    return (FALSE);
    1717  }
    1818   
    1919  if (strcmp (argv[3], "-r") && strcmp (argv[3], "-w")) {
    20     fprintf (stderr, "use -r or -w only\n");
     20    gprint (GP_ERR, "use -r or -w only\n");
    2121    return (FALSE);
    2222  }

  • trunk/Ohana/src/opihi/cmd.astro/sexigesimal.c

    r2843 r7917  
    1818
    1919  if ((argc != 3) && (argc != 2)) {
    20     fprintf (stderr, "USAGE: sexigesimal (from) [to]\n");
     20    gprint (GP_ERR, "USAGE: sexigesimal (from) [to]\n");
    2121    return (FALSE);
    2222  }
    … …  
    2424  if (HMS) {
    2525    if (!dms_to_ddd (&value, argv[1])) {
    26       fprintf (stderr, "syntax error in input\n");
     26      gprint (GP_ERR, "syntax error in input\n");
    2727      return (FALSE);
    2828    }
    … …  
    3030      set_variable (argv[2], value);
    3131    } else {
    32       fprintf (GetOutfile(), "%10.6f\n", value);
     32      gprint (GP_LOG, "%10.6f\n", value);
    3333    }
    3434    return (TRUE);
    … …  
    3939      set_str_variable (argv[2], string);
    4040    } else {
    41       fprintf (GetOutfile(), "%s\n", string);
     41      gprint (GP_LOG, "%s\n", string);
    4242    }
    4343    return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/spec.c

    r4689 r7917  
    3434 
    3535  if (argc != 7) {
    36     fprintf (stderr, "USAGE: spec buffer x y1 y2 X Y [-Nlong N] [-Ngap N] [-Nrow N]\n");
     36    gprint (GP_ERR, "USAGE: spec buffer x y1 y2 X Y [-Nlong N] [-Ngap N] [-Nrow N]\n");
    3737    return (FALSE);
    3838  }
    3939 
    4040  if ((Nrow < 1) || (Nlong < 2) || (Ngap < 1) || (Nlong - Ngap < 2)) {
    41     fprintf (stderr, "bad values for options\n");
     41    gprint (GP_ERR, "bad values for options\n");
    4242    return (FALSE);
    4343  }
    … …  
    7979    }
    8080    X1 = SX / S;
    81     fprintf (stderr, "%4d %4d %5.1f ", j+y1, X1, sky);
     81    gprint (GP_ERR, "%4d %4d %5.1f ", j+y1, X1, sky);
    8282    /*    X1 = MAX (MIN (X1, Xo + 0.5+Ngap), Xo - 0.5+Ngap); */
    8383    V = (float *) (buf[0].matrix.buffer) + Nx*(y1 + j) + X1 - (int)(0.5*Nlong);
    … …  
    105105    xvec[0].elements[j] = j + y1;
    106106    yvec[0].elements[j] = F / R;
    107     fprintf (stderr, " %5.1f %7.1f  %6.2f\n", sky, sky2, (F/R));
     107    gprint (GP_ERR, " %5.1f %7.1f  %6.2f\n", sky, sky2, (F/R));
    108108  }   
    109109

  • trunk/Ohana/src/opihi/cmd.astro/star.c

    r2843 r7917  
    2323 
    2424  if ((argc != 4) && (argc != 5)) {
    25     fprintf (stderr, "USAGE: star (buffer) x y [dx] [-border N] [-sat cnts]\n");
     25    gprint (GP_ERR, "USAGE: star (buffer) x y [dx] [-border N] [-sat cnts]\n");
    2626    return (FALSE);
    2727  }

  • trunk/Ohana/src/opihi/cmd.astro/testfit.c

    r2598 r7917  
    1111
    1212  if (argc != 4) {
    13     fprintf (stderr, "USAGE: imfit <x> <y> <dy>\n");
     13    gprint (GP_ERR, "USAGE: imfit <x> <y> <dy>\n");
    1414    return (FALSE);
    1515  }
    … …  
    3737
    3838    chisq = mrqmin (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fgaussOD);
    39     fprintf (stderr, "chisq: %f, %f %f %f %f\n", chisq, par[0], par[1], par[2], par[3]);
     39    gprint (GP_ERR, "chisq: %f, %f %f %f %f\n", chisq, par[0], par[1], par[2], par[3]);
    4040
    4141  } 
    … …  
    4444
    4545  for (i = 0; i < Npar; i++) {
    46     fprintf (stderr, "%d  %f  %f\n", i, par[i], covar[i][i]);
     46    gprint (GP_ERR, "%d  %f  %f\n", i, par[i], covar[i][i]);
    4747  }
    4848
    … …  
    128128
    129129  if (argc != 6) {
    130     fprintf (stderr, "USAGE: imfit <buffer> sx sy nx ny\n");
     130    gprint (GP_ERR, "USAGE: imfit <buffer> sx sy nx ny\n");
    131131    return (FALSE);
    132132  }
    … …  
    143143      (sx+nx > buffers[Nbuf].matrix.Naxis[0]) ||
    144144      (sy+ny > buffers[Nbuf].matrix.Naxis[1])) {
    145     fprintf (stderr, "region out of range\n");
     145    gprint (GP_ERR, "region out of range\n");
    146146    return (FALSE);
    147147  }

  • trunk/Ohana/src/opihi/cmd.astro/transform.c

    r3404 r7917  
    1414
    1515  if (argc != 3) {
    16     fprintf (stderr, "USAGE: transform <from> <to>\n");
     16    gprint (GP_ERR, "USAGE: transform <from> <to>\n");
    1717    return (FALSE);
    1818  }
    … …  
    2626  /* for the moment, disable WRP / DIS */
    2727  if (!strcmp(&coords_in.ctype[4], "-WRP") || !strcmp(&coords_out.ctype[4], "-WRP")) {
    28     fprintf (stderr, "WRP mode not implemented for astrom\n");
     28    gprint (GP_ERR, "WRP mode not implemented for astrom\n");
    2929    return (FALSE);
    3030  }
    … …  
    4646
    4747  for (j = 0; j < in[0].header.Naxis[1]; j++) {
    48     fprintf (stderr, ".");
     48    gprint (GP_ERR, ".");
    4949    for (i = 0; i < in[0].header.Naxis[0]; i++, Vin++) {
    5050      for (dx = 0.0 + 0.5*frac; dx < 1.0 - 0.5*frac; dx += frac) {

  • trunk/Ohana/src/opihi/cmd.astro/warp.c

    r7039 r7917  
    2727
    2828  if (argc != 5) {
    29     fprintf (stderr, "USAGE: transform <from> <to> <weight> (Nlinear)\n");
    30     fprintf (stderr, "  output buffer must exist with target astrometry header\n");
    31     fprintf (stderr, "  Nlinear is the pixel scale for linear astrometric transformation\n");
     29    gprint (GP_ERR, "USAGE: transform <from> <to> <weight> (Nlinear)\n");
     30    gprint (GP_ERR, "  output buffer must exist with target astrometry header\n");
     31    gprint (GP_ERR, "  Nlinear is the pixel scale for linear astrometric transformation\n");
    3232    return (FALSE);
    3333  }
    … …  
    4343  /* for the moment, disable WRP / DIS */
    4444  if (!strcmp(&coords_in.ctype[4], "-WRP") || !strcmp(&coords_out.ctype[4], "-WRP")) {
    45     fprintf (stderr, "WRP mode not implemented for astrom\n");
     45    gprint (GP_ERR, "WRP mode not implemented for astrom\n");
    4646    return (FALSE);
    4747  }
    … …  
    5050  scale_out = sqrt(fabs(coords_out.cdelt1*coords_out.cdelt2*(coords_out.pc1_1*coords_out.pc2_2 - coords_out.pc1_2*coords_out.pc2_1)));
    5151 
    52   fprintf (stderr, "%f - %f\n", scale_in, scale_out);
     52  gprint (GP_ERR, "%f - %f\n", scale_in, scale_out);
    5353
    5454  if (scale_in > scale_out) {

  • trunk/Ohana/src/opihi/cmd.basic/break.c

    r2843 r7917  
    1111    if (!strcasecmp (argv[N], "off")) value = FALSE;
    1212    if (value == -1) {
    13       fprintf (stderr, "USAGE: break -auto [on / off]\n");
     13      gprint (GP_ERR, "USAGE: break -auto [on / off]\n");
    1414      if (auto_break)
    15         fprintf (stderr, "auto break on\n");
     15        gprint (GP_ERR, "auto break on\n");
    1616      else
    17         fprintf (stderr, "auto break off\n");
     17        gprint (GP_ERR, "auto break off\n");
    1818      return (FALSE);
    1919    }

  • trunk/Ohana/src/opihi/cmd.basic/cd.c

    r6266 r7917  
    77
    88  if (argc != 2) {
    9     fprintf (stderr, "USAGE: cd <path>\n");
     9    gprint (GP_ERR, "USAGE: cd <path>\n");
    1010    return (FALSE);
    1111  }
    … …  
    1414  if (!status) {
    1515    if ((cwd = getcwd (NULL, 64)) == NULL) {
    16       fprintf (stderr, "error getting cwd\n");
     16      gprint (GP_ERR, "error getting cwd\n");
    1717      return (FALSE);
    1818    }
    19     fprintf(GetOutfile(), "cwd: %s\n", cwd);
     19    gprint (GP_LOG, "cwd: %s\n", cwd);
    2020    ohana_memregister (cwd);
    2121    free (cwd);
    … …  
    2323  }
    2424
    25   fprintf (stderr, "error changing to %s\n", argv[1]);
     25  gprint (GP_ERR, "error changing to %s\n", argv[1]);
    2626  return (FALSE);
    2727
    … …  
    3333
    3434  if (argc != 1) {
    35     fprintf (stderr, "USAGE: pwd\n");
     35    gprint (GP_ERR, "USAGE: pwd\n");
    3636    return (FALSE);
    3737  }
    3838 
    3939  if ((cwd = getcwd(NULL, 64)) == NULL) {
    40     fprintf (stderr, "error getting cwd\n");
     40    gprint (GP_ERR, "error getting cwd\n");
    4141    return (FALSE);
    4242  }
    43   fprintf(GetOutfile(), "cwd: %s\n", cwd);
     43  gprint (GP_LOG, "cwd: %s\n", cwd);
    4444  ohana_memregister (cwd);
    4545  free (cwd);

  • trunk/Ohana/src/opihi/cmd.basic/date.c

    r2598 r7917  
    88
    99  if ((argc != 1) && (argc != 2)) {
    10     fprintf (stderr, "USAGE: date [variable]\n");
     10    gprint (GP_ERR, "USAGE: date [variable]\n");
    1111    return (FALSE);
    1212  }
    … …  
    1818
    1919  if (argc == 1) {
    20     fprintf (stderr, "%s\n", tstring);
     20    gprint (GP_ERR, "%s\n", tstring);
    2121  } else {
    2222    set_str_variable (argv[1], tstring);

  • trunk/Ohana/src/opihi/cmd.basic/echo.c

    r2598 r7917  
    66
    77  for (i = 1; i < argc; i++) {
    8     fprintf (GetOutfile(), "%s ", argv[i]);
     8    gprint (GP_LOG, "%s ", argv[i]);
    99  }
    10   fprintf (GetOutfile(), "\n");
     10  gprint (GP_LOG, "\n");
    1111  return (TRUE);
    1212}

  • trunk/Ohana/src/opihi/cmd.basic/file.c

    r2598 r7917  
    99
    1010  if (argc < 2) {
    11     fprintf (stderr, "USAGE: file (filename) [var]\n");
     11    gprint (GP_ERR, "USAGE: file (filename) [var]\n");
    1212    return (FALSE);
    1313  }
    … …  
    2323  } else {
    2424
    25     fprintf (stderr, "file %s is ", argv[1]);
    26     if (!vstat) fprintf (stderr, "not ");
    27     fprintf (stderr, "found\n");
     25    gprint (GP_ERR, "file %s is ", argv[1]);
     26    if (!vstat) gprint (GP_ERR, "not ");
     27    gprint (GP_ERR, "found\n");
    2828   
    2929  }

  • trunk/Ohana/src/opihi/cmd.basic/fprintf.c

    r4746 r7917  
    99
    1010  if (argc < 2) {
    11     fprintf (stderr, "USAGE: fprintf format value value ...\n");
     11    gprint (GP_ERR, "USAGE: fprintf format value value ...\n");
    1212    return (FALSE);
    1313  }
    … …  
    2424    p2 = strchr (p1, '%');
    2525    if (p2 == (char *) NULL) {
    26       fprintf (stderr, "mismatch between format and values\n");
     26      gprint (GP_ERR, "mismatch between format and values\n");
    2727      return (FALSE);
    2828    }
    2929    if (strlen(q) + p2 - p1 > NCHAR) {
    30       fprintf (stderr, "line too long");
     30      gprint (GP_ERR, "line too long");
    3131      return (FALSE);
    3232    }
    … …  
    5151        break;
    5252      default:
    53         fprintf (stderr, "syntax error in format (only e,f,s,d,c,x allowed)\n");
     53        gprint (GP_ERR, "syntax error in format (only e,f,s,d,c,x allowed)\n");
    5454        return (FALSE);
    5555    }
    5656    if (strlen(q) + strlen(tmp) > NCHAR) {
    57       fprintf (stderr, "line too long");
     57      gprint (GP_ERR, "line too long");
    5858      return (FALSE);
    5959    }
    … …  
    6464  p2 = strchr (p1, '%');
    6565  if (p2 != (char *) NULL) {
    66     fprintf (stderr, "mismatch between format and values\n");
     66    gprint (GP_ERR, "mismatch between format and values\n");
    6767    return (FALSE);
    6868  }
    … …  
    7070  p2 = p1 + strlen (p1);
    7171  if (strlen(q) + p2 - p1 > NCHAR) {
    72     fprintf (stderr, "line too long");
     72    gprint (GP_ERR, "line too long");
    7373    return (FALSE);
    7474  }
    7575  memcpy (q, p1, p2-p1);
    76   fprintf (GetOutfile(), "%s\n", line);
     76  gprint (GP_LOG, "%s\n", line);
    7777
    7878  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.basic/getchr.c

    r2598 r7917  
    88
    99  if ((argc != 3) && (argc != 4)) {
    10     fprintf (stderr, "USAGE: strchr (string) (char) [var]\n");
     10    gprint (GP_ERR, "USAGE: strchr (string) (char) [var]\n");
    1111    return (FALSE);
    1212  }
    … …  
    2323    set_int_variable (argv[3], pos);
    2424  } else {
    25     fprintf (stderr, "%d\n", pos);
     25    gprint (GP_ERR, "%d\n", pos);
    2626  }
    2727  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.basic/help.c

    r2598 r7917  
    88  helpdir = get_variable ("HELPDIR");
    99  if (helpdir == (char *) NULL) {
    10     fprintf (stderr, "variable HELPDIR not found\n");
     10    gprint (GP_ERR, "variable HELPDIR not found\n");
    1111    return (FALSE);
    1212  }
    … …  
    2222  f = fopen (file, "r");
    2323  if (f == NULL) {
    24     fprintf (stderr, "No help for: %s\n", argv[1]);
     24    gprint (GP_ERR, "No help for: %s\n", argv[1]);
    2525    return (FALSE);
    2626  }
    2727
    2828  while (scan_line (f, buff) != EOF)
    29     fprintf (stdout, "%s\n", buff);
     29    gprint (GP_LOG, "%s\n", buff);
    3030
    3131  fclose (f);

  • trunk/Ohana/src/opihi/cmd.basic/input.c

    r3907 r7917  
    99
    1010  if (argc != 2) {
    11     fprintf (stderr, "USAGE: input <filename>\n");
     11    gprint (GP_ERR, "USAGE: input <filename>\n");
    1212    return (FALSE);
    1313  }
    … …  
    1515  infile = fopen (argv[1], "r");
    1616  if (infile == NULL) {
    17     fprintf (stderr, "no file %s\n", argv[1]);
     17    gprint (GP_ERR, "no file %s\n", argv[1]);
    1818    return (FALSE);
    1919  }

  • trunk/Ohana/src/opihi/cmd.basic/list.c

    r4689 r7917  
    2323  if ((argc > 2) && (!strcmp (argv[2], "-split"))) {
    2424    if (argc == 3) {
    25       fprintf (stderr, "USAGE: list (root) -split (word) (word) ...\n");
     25      gprint (GP_ERR, "USAGE: list (root) -split (word) (word) ...\n");
    2626      return (FALSE);
    2727    }
    … …  
    3838
    3939  if (argc != 2) {
    40     fprintf (stderr, "USAGE: list (root) -- terminate with 'END'\n");
     40    gprint (GP_ERR, "USAGE: list (root) -- terminate with 'END'\n");
    4141    return (FALSE);
    4242  }
    … …  
    5656      Nread = fread (&val[Nbytes], 1, 1023, f);
    5757      if (Nread < 0) {
    58         fprintf (stderr, "error reading from command\n");
     58        gprint (GP_ERR, "error reading from command\n");
    5959        done = TRUE;
    6060      }
    … …  
    7474   
    7575    if (status) {
    76       fprintf (stderr, "warning: exit status of command %d\n", status);
     76      gprint (GP_ERR, "warning: exit status of command %d\n", status);
    7777    }
    7878     
    … …  
    109109    if (input == (char *) NULL) {
    110110      if (ThisList == 0)  {
    111         fprintf (stderr, "end list with 'END'\n");
     111        gprint (GP_ERR, "end list with 'END'\n");
    112112        continue;
    113113      } else {

  • trunk/Ohana/src/opihi/cmd.basic/list_help.c

    r2598 r7917  
    99  sprintf (filename, "/tmp/status.XXXXXX");
    1010  if ((fd = mkstemp (filename)) == -1) {
    11     fprintf (stderr, "error opening output\n");
     11    gprint (GP_ERR, "error opening output\n");
    1212    return (FALSE);
    1313  }

  • trunk/Ohana/src/opihi/cmd.basic/local.c

    r2843 r7917  
    1515
    1616  if (argc < 2) {
    17     fprintf (stderr, "USAGE: local (variable)\n");
     17    gprint (GP_ERR, "USAGE: local (variable)\n");
    1818    return (FALSE);
    1919  }

  • trunk/Ohana/src/opihi/cmd.basic/macro.c

    r4689 r7917  
    77
    88  if ((argc != 2) && (argc != 3) && (argc != 4)) {
    9     fprintf (stderr, "USAGE: macro (cmd)\n");
    10     fprintf (stderr, "  (cmd) can be one of:\n");
    11     fprintf (stderr, "    (name)         -- create macro (name)\n");
    12     fprintf (stderr, "    create (name)  -- create macro (name)\n");
    13     fprintf (stderr, "    delete (name)  -- delete macro (name)\n");
    14     fprintf (stderr, "    list   (name)  -- list macro (name)\n");
    15     fprintf (stderr, "    edit   (name)  -- edit macro (name) <not working yet!> *\n");
    16     fprintf (stderr, "    read   (name)  -- read macro(s) from file (name) <not working yet!> *\n");
    17     fprintf (stderr, "    write  (name)  -- write macro (name) to a file <not working yet!> *\n");
     9    gprint (GP_ERR, "USAGE: macro (cmd)\n");
     10    gprint (GP_ERR, "  (cmd) can be one of:\n");
     11    gprint (GP_ERR, "    (name)         -- create macro (name)\n");
     12    gprint (GP_ERR, "    create (name)  -- create macro (name)\n");
     13    gprint (GP_ERR, "    delete (name)  -- delete macro (name)\n");
     14    gprint (GP_ERR, "    list   (name)  -- list macro (name)\n");
     15    gprint (GP_ERR, "    edit   (name)  -- edit macro (name) <not working yet!> *\n");
     16    gprint (GP_ERR, "    read   (name)  -- read macro(s) from file (name) <not working yet!> *\n");
     17    gprint (GP_ERR, "    write  (name)  -- write macro (name) to a file <not working yet!> *\n");
    1818    return (FALSE);
    1919  }

  • trunk/Ohana/src/opihi/cmd.basic/memory.c

    r4449 r7917  
    4343
    4444usage:
    45   fprintf (stderr, "USAGE: memory (all/leaks)\n");
     45  gprint (GP_ERR, "USAGE: memory (all/leaks)\n");
    4646  return (FALSE);
    4747}

  • trunk/Ohana/src/opihi/cmd.basic/output.c

    r2598 r7917  
    55int output (int argc, char **argv) {
    66 
     7  int N;
     8  gpDest dest;
     9  IOBuffer *buffer;
     10
     11  dest = GP_LOG;
     12  if ((N = get_argument (argc, argv, "-err"))) {
     13    dest = GP_ERR;
     14    remove_argument (N, &argc, argv);
     15  }
     16
     17  if ((N = get_argument (argc, argv, "-buffer"))) {
     18    remove_argument (N, &argc, argv);
     19    gprintSetBuffer (dest);
     20    return (TRUE);
     21  }
     22   
     23  if ((N = get_argument (argc, argv, "-dump"))) {
     24    remove_argument (N, &argc, argv);
     25    buffer = gprintGetBuffer (dest);
     26    fprintf (STDERR, "buffer contents: \n");
     27    fwrite (buffer[0].buffer, 1, buffer[0].Nbuffer, stderr);
     28    fprintf (STDERR, "\n");
     29    return (TRUE);
     30  }
     31   
    732  if (argc != 2) {
    8     fprintf (stderr, "USAGE: output <filename>\n");
     33    gprint (GP_ERR, "USAGE: output <filename>\n");
    934    return (FALSE);
    1035  }
    1136
    12   fflush (outfile);
    13   if (outfile != stdout) fclose (outfile);
    14  
    15   /* we only use stdout, but let stderr be a synonym */
    16   outfile = stdout;
    17   if (strcmp (argv[1], "stdout") && strcmp (argv[1], "stderr")) {
    18     outfile = fopen (argv[1], "a");
    19   }
    20 
    21   if (outfile == NULL) {
    22     fprintf (stderr, "cannot open file %s\n", argv[1]);
    23     outfile = stdout;
    24   }
     37  gprintSetFile (dest, argv[1]);
    2538  return (TRUE);
    2639}
    … …  
    3346  outfile = stdout;
    3447}
     48
     49/* we could add the concept of saving the output to a buffer
     50   then dumping to the target of the output stream.  not sure
     51   what the command should look like... */

  • trunk/Ohana/src/opihi/cmd.basic/run_for.c

    r3907 r7917  
    1212
    1313  if ((argc != 4) && (argc != 5)) {
    14     fprintf (stderr, "USAGE: for (var) (start) (stop) [delta] -- terminate with 'END'\n");
     14    gprint (GP_ERR, "USAGE: for (var) (start) (stop) [delta] -- terminate with 'END'\n");
    1515    return (FALSE);
    1616  }
    … …  
    4040    if (input == (char *) NULL) {
    4141      if (ThisList == 0)  {
    42         fprintf (stderr, "end loop with 'END'\n");
     42        gprint (GP_ERR, "end loop with 'END'\n");
    4343        continue;
    4444      } else {
    45         fprintf (stderr, "misbalanced loop\n");
     45        gprint (GP_ERR, "misbalanced loop\n");
    4646        for (j = 0; j < loop.Nlines; j++) {
    4747          free (loop.line[j]);

  • trunk/Ohana/src/opihi/cmd.basic/run_if.c

    r4689 r7917  
    1212
    1313  if ((argc != 2) && (argc != 3)) {
    14     fprintf (stderr, "USAGE: if (conditional) [break], end with the word 'END'\n");
     14    gprint (GP_ERR, "USAGE: if (conditional) [break], end with the word 'END'\n");
    1515    return (FALSE);
    1616  }
    1717  if ((argc == 3) && strcmp (argv[2], "break")) {
    18     fprintf (stderr, "USAGE: if (conditional) [break], end with the word 'END'\n");
     18    gprint (GP_ERR, "USAGE: if (conditional) [break], end with the word 'END'\n");
    1919    return (FALSE);
    2020  }
    … …  
    5555
    5656    if ((ThisList == 0) && (input == (char *) NULL)) {
    57       fprintf (stderr, "end if-block with 'END'\n");
     57      gprint (GP_ERR, "end if-block with 'END'\n");
    5858      continue;
    5959    }
    6060    if ((ThisList >  0) && (input == (char *) NULL)) {
    61       fprintf (stderr, "missing 'END' in if-block\n");
     61      gprint (GP_ERR, "missing 'END' in if-block\n");
    6262      input = strcreate ("end");
    6363    }

  • trunk/Ohana/src/opihi/cmd.basic/run_while.c

    r3922 r7917  
    1111
    1212  if (argc != 2) {
    13     fprintf (stderr, "USAGE: while (condition)\n");
     13    gprint (GP_ERR, "USAGE: while (condition)\n");
    1414    return (FALSE);
    1515  }
    … …  
    3838    if (input == (char *) NULL) {
    3939      if (ThisList == 0)  {
    40         fprintf (stderr, "end 'while' loop with 'END'\n");
     40        gprint (GP_ERR, "end 'while' loop with 'END'\n");
    4141        continue;
    4242      } else {
    43         fprintf (stderr, "misbalanced 'while' loop\n");
     43        gprint (GP_ERR, "misbalanced 'while' loop\n");
    4444        for (j = 0; j < loop.Nlines; j++) {
    4545          free (loop.line[j]);

  • trunk/Ohana/src/opihi/cmd.basic/scan.c

    r2598 r7917  
    88
    99  if ((argc != 3) && (argc != 4)) {
    10     fprintf (stderr, "USAGE: scan <filename> <var> [N]\n");
     10    gprint (GP_ERR, "USAGE: scan <filename> <var> [N]\n");
    1111    return (FALSE);
    1212  }
    … …  
    1616    f = fopen (argv[1], "r");
    1717    if (f == (FILE *) NULL) {
    18       fprintf (stderr, "file %s not found\n", argv[1]);
     18      gprint (GP_ERR, "file %s not found\n", argv[1]);
    1919      return (FALSE);
    2020    }

  • trunk/Ohana/src/opihi/cmd.basic/sleep.c

    r2598 r7917  
    66
    77  if (argc < 2) {
    8     fprintf (stderr, "usage: sleep N\n");
     8    gprint (GP_ERR, "usage: sleep N\n");
    99    return (FALSE);
    1010  }

  • trunk/Ohana/src/opihi/cmd.basic/sprintf.c

    r2843 r7917  
    1111
    1212  if (argc < 3) {
    13     fprintf (stderr, "USAGE: sprintf var format value value ...\n");
     13    gprint (GP_ERR, "USAGE: sprintf var format value value ...\n");
    1414    return (FALSE);
    1515  }
    … …  
    2626    p2 = strchr (p1, '%');
    2727    if (p2 == (char *) NULL) {
    28       fprintf (stderr, "mismatch between format and values\n");
     28      gprint (GP_ERR, "mismatch between format and values\n");
    2929      return (FALSE);
    3030    }
    3131    if (strlen(q) + p2 - p1 > NCHAR) {
    32       fprintf (stderr, "line too long");
     32      gprint (GP_ERR, "line too long");
    3333      return (FALSE);
    3434    }
    … …  
    5353        break;
    5454      default:
    55         fprintf (stderr, "syntax error in format (only e,f,s,d,c,x allowed)\n");
     55        gprint (GP_ERR, "syntax error in format (only e,f,s,d,c,x allowed)\n");
    5656        return (FALSE);
    5757    }
    5858    if (strlen(q) + strlen(tmp) > NCHAR) {
    59       fprintf (stderr, "line too long");
     59      gprint (GP_ERR, "line too long");
    6060      return (FALSE);
    6161    }
    … …  
    6666  p2 = strchr (p1, '%');
    6767  if (p2 != (char *) NULL) {
    68     fprintf (stderr, "mismatch between format and values\n");
     68    gprint (GP_ERR, "mismatch between format and values\n");
    6969    return (FALSE);
    7070  }
    … …  
    7272  p2 = p1 + strlen (p1);
    7373  if (strlen(q) + p2 - p1 > NCHAR) {
    74     fprintf (stderr, "line too long");
     74    gprint (GP_ERR, "line too long");
    7575    return (FALSE);
    7676  }

  • trunk/Ohana/src/opihi/cmd.basic/strchr.c

    r2598 r7917  
    88
    99  if ((argc != 3) && (argc != 4)) {
    10     fprintf (stderr, "USAGE: strchr (string) (char) [var]\n");
     10    gprint (GP_ERR, "USAGE: strchr (string) (char) [var]\n");
    1111    return (FALSE);
    1212  }
    … …  
    2323    set_variable (argv[3], pos);
    2424  } else {
    25     fprintf (stderr, "%d\n", pos);
     25    gprint (GP_ERR, "%d\n", pos);
    2626  }
    2727  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.basic/strlen.c

    r2598 r7917  
    77
    88  if ((argc != 2) && (argc != 3)) {
    9     fprintf (stderr, "USAGE: strchr (string) [var]\n");
     9    gprint (GP_ERR, "USAGE: strchr (string) [var]\n");
    1010    return (FALSE);
    1111  }
    … …  
    1616    set_int_variable (argv[2], len);
    1717  } else {
    18     fprintf (stderr, "%d\n", len);
     18    gprint (GP_ERR, "%d\n", len);
    1919  }
    2020  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.basic/substr.c

    r2598 r7917  
    77
    88  if ((argc != 4) && (argc != 5)) {
    9     fprintf (stderr, "USAGE: substr (string) N1 N2 [var]\n");
     9    gprint (GP_ERR, "USAGE: substr (string) N1 N2 [var]\n");
    1010    return (FALSE);
    1111  }
    … …  
    3030    set_str_variable (argv[4], string);
    3131  } else {
    32     fprintf (stderr, "%s\n", string);
     32    gprint (GP_ERR, "%s\n", string);
    3333  }
    3434  free (string);

  • trunk/Ohana/src/opihi/cmd.basic/usleep.c

    r2598 r7917  
    66
    77  if (argc < 2) {
    8     fprintf (stderr, "usage: usleep N\n");
     8    gprint (GP_ERR, "usage: usleep N\n");
    99    return (FALSE);
    1010  }

  • trunk/Ohana/src/opihi/cmd.basic/wait.c

    r4689 r7917  
    77
    88  for (i = 1; i < argc; i++) {
    9     fprintf (stderr, "%s ", argv[i]);
     9    gprint (GP_ERR, "%s ", argv[i]);
    1010  }
    11   fprintf (stderr, "\n");
     11  gprint (GP_ERR, "\n");
    1212  scan_line (stdin, buff);
    1313  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.basic/which.c

    r2598 r7917  
    66 
    77  if (argc != 2) {
    8     fprintf (stderr, "USAGE: which <filename>\n");
     8    gprint (GP_ERR, "USAGE: which <filename>\n");
    99    return (FALSE);
    1010  }
    … …  
    1313  if (cmd == NULL) return (FALSE);
    1414
    15   fprintf (stderr, "%-25s -- %s\n", cmd[0].name, cmd[0].help);
     15  gprint (GP_ERR, "%-25s -- %s\n", cmd[0].name, cmd[0].help);
    1616  return (TRUE);
    1717

  • 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  }

  • trunk/Ohana/src/opihi/dimm/Camera.c

    r2598 r7917  
    1414      return (TRUE);
    1515    }
    16     fprintf (stderr, "retry...\n");
     16    gprint (GP_ERR, "retry...\n");
    1717  }
    1818 
    19   fprintf (stderr, "failed to init sbig camera on %d\n", port);
    20   fprintf (stderr, "%s\n", sbig_show_error (state));
     19  gprint (GP_ERR, "failed to init sbig camera on %d\n", port);
     20  gprint (GP_ERR, "%s\n", sbig_show_error (state));
    2121  return (FALSE);
    2222}
    … …  
    2424void DumpCameraInfo () {
    2525
    26       fprintf (stderr, "opened sbig camera:\n");
    27       fprintf (stderr, "linux_version: %f\n",      info.linux_version);
    28       fprintf (stderr, "nmbr_bad_columns: %d\n",   info.nmbr_bad_columns);
    29       fprintf (stderr, "imaging_abg_type: %d\n",   info.imaging_abg_type);
    30       fprintf (stderr, "serial_number: %s\n",      info.serial_number);
    31       fprintf (stderr, "firmware_version: %d\n",   info.firmware_version);
    32       fprintf (stderr, "camera_name: %s\n",        info.camera_name);
    33       fprintf (stderr, "nmbr_readout_modes: %d\n", info.camera_info[0].nmbr_readout_modes);
    34       fprintf (stderr, "mode: %d\n",               info.camera_info[0].readout_mode[0].mode);
    35       fprintf (stderr, "width: %d\n",              info.camera_info[0].readout_mode[0].width);
    36       fprintf (stderr, "height: %d\n",             info.camera_info[0].readout_mode[0].height);
    37       fprintf (stderr, "gain: %d\n",               info.camera_info[0].readout_mode[0].gain);
    38       fprintf (stderr, "pixel_width: %d\n",        info.camera_info[0].readout_mode[0].pixel_width);
    39       fprintf (stderr, "pixel_height: %d\n",       info.camera_info[0].readout_mode[0].pixel_height);
    40 
    41       fprintf (stderr, "ST5_AD_size: %d\n", info.ST5_AD_size);
    42       fprintf (stderr, "ST5_filter_type: %d\n", info.ST5_filter_type);
     26      gprint (GP_ERR, "opened sbig camera:\n");
     27      gprint (GP_ERR, "linux_version: %f\n",      info.linux_version);
     28      gprint (GP_ERR, "nmbr_bad_columns: %d\n",   info.nmbr_bad_columns);
     29      gprint (GP_ERR, "imaging_abg_type: %d\n",   info.imaging_abg_type);
     30      gprint (GP_ERR, "serial_number: %s\n",      info.serial_number);
     31      gprint (GP_ERR, "firmware_version: %d\n",   info.firmware_version);
     32      gprint (GP_ERR, "camera_name: %s\n",        info.camera_name);
     33      gprint (GP_ERR, "nmbr_readout_modes: %d\n", info.camera_info[0].nmbr_readout_modes);
     34      gprint (GP_ERR, "mode: %d\n",               info.camera_info[0].readout_mode[0].mode);
     35      gprint (GP_ERR, "width: %d\n",              info.camera_info[0].readout_mode[0].width);
     36      gprint (GP_ERR, "height: %d\n",             info.camera_info[0].readout_mode[0].height);
     37      gprint (GP_ERR, "gain: %d\n",               info.camera_info[0].readout_mode[0].gain);
     38      gprint (GP_ERR, "pixel_width: %d\n",        info.camera_info[0].readout_mode[0].pixel_width);
     39      gprint (GP_ERR, "pixel_height: %d\n",       info.camera_info[0].readout_mode[0].pixel_height);
     40
     41      gprint (GP_ERR, "ST5_AD_size: %d\n", info.ST5_AD_size);
     42      gprint (GP_ERR, "ST5_filter_type: %d\n", info.ST5_filter_type);
    4343}     
    4444
    … …  
    6262  state = sbig_set_cooling (&cool);
    6363  if (state < 0) {
    64     fprintf (stderr, "sbig error: %s\n", sbig_show_error (state));
     64    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state));
    6565    return (FALSE);
    6666  }
    … …  
    7676  state = sbig_get_status (&status);
    7777  if (state < 0) {
    78     fprintf (stderr, "sbig error: %s\n", sbig_show_error (state));
     78    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state));
    7979    return (-200.0);
    8080  }
    … …  
    9191  state = sbig_get_status (&status);
    9292  if (state < 0) {
    93     fprintf (stderr, "sbig error: %s\n", sbig_show_error (state));
    94     return (FALSE);
    95   }
    96 
    97   fprintf (stderr, "imaging_ccd_status: %d\n", status.imaging_ccd_status);
    98   fprintf (stderr, "tracking_ccd_status: %d\n", status.tracking_ccd_status);
    99   fprintf (stderr, "fan_on: %d\n", status.fan_on);
    100   fprintf (stderr, "shutter_state: %d\n", status.shutter_state);
    101   fprintf (stderr, "led_state: %d\n", status.led_state);
    102   fprintf (stderr, "shutter_edge: %d\n", status.shutter_edge);
    103   fprintf (stderr, "plus_x_relay: %d\n", status.plus_x_relay);
    104   fprintf (stderr, "minus_x_relay: %d\n", status.minus_x_relay);
    105   fprintf (stderr, "plus_y_relay: %d\n", status.plus_y_relay);
    106   fprintf (stderr, "minus_y_relay: %d\n", status.minus_y_relay);
    107   fprintf (stderr, "pulse_active: %d\n", status.pulse_active);
    108   fprintf (stderr, "temperature_regulation: %d\n", status.temperature_regulation);
    109   fprintf (stderr, "temperature_setpoint: %d\n", status.temperature_setpoint);
    110   fprintf (stderr, "cooling_power: %d\n", status.cooling_power);
    111   fprintf (stderr, "air_temperature: %d\n", status.air_temperature);
    112   fprintf (stderr, "ccd_temperature: %d\n", status.ccd_temperature);
     93    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state));
     94    return (FALSE);
     95  }
     96
     97  gprint (GP_ERR, "imaging_ccd_status: %d\n", status.imaging_ccd_status);
     98  gprint (GP_ERR, "tracking_ccd_status: %d\n", status.tracking_ccd_status);
     99  gprint (GP_ERR, "fan_on: %d\n", status.fan_on);
     100  gprint (GP_ERR, "shutter_state: %d\n", status.shutter_state);
     101  gprint (GP_ERR, "led_state: %d\n", status.led_state);
     102  gprint (GP_ERR, "shutter_edge: %d\n", status.shutter_edge);
     103  gprint (GP_ERR, "plus_x_relay: %d\n", status.plus_x_relay);
     104  gprint (GP_ERR, "minus_x_relay: %d\n", status.minus_x_relay);
     105  gprint (GP_ERR, "plus_y_relay: %d\n", status.plus_y_relay);
     106  gprint (GP_ERR, "minus_y_relay: %d\n", status.minus_y_relay);
     107  gprint (GP_ERR, "pulse_active: %d\n", status.pulse_active);
     108  gprint (GP_ERR, "temperature_regulation: %d\n", status.temperature_regulation);
     109  gprint (GP_ERR, "temperature_setpoint: %d\n", status.temperature_setpoint);
     110  gprint (GP_ERR, "cooling_power: %d\n", status.cooling_power);
     111  gprint (GP_ERR, "air_temperature: %d\n", status.air_temperature);
     112  gprint (GP_ERR, "ccd_temperature: %d\n", status.ccd_temperature);
    113113
    114114  return (TRUE);
    … …  
    131131  state = sbig_expose (&expose);
    132132  if (state < 0) {
    133     fprintf (stderr, "exposure error\n");
    134     fprintf (stderr, "%s\n", sbig_show_error (state));
     133    gprint (GP_ERR, "exposure error\n");
     134    gprint (GP_ERR, "%s\n", sbig_show_error (state));
    135135    return (FALSE);
    136136  }
    … …  
    138138  for (i = 0; i < expose.exposure_time + 10; ++i) {
    139139    state = sbig_get_status (&status);
    140     /* fprintf (stderr, "%d\n", state); */
    141     /* fprintf (stderr, "%d  %d\n", status.imaging_ccd_status, status.shutter_state); */
     140    /* gprint (GP_ERR, "%d\n", state); */
     141    /* gprint (GP_ERR, "%d  %d\n", status.imaging_ccd_status, status.shutter_state); */
    142142    /*    if (state == 0) return (TRUE); */
    143143    if (status.imaging_ccd_status == -SBIG_NO_EXPOSURE_IN_PROGRESS) return (TRUE);
    … …  
    146146      continue;
    147147    }
    148     fprintf (stderr, "exposure error\n");
    149     fprintf (stderr, "%s\n", sbig_show_error (state));
    150     return (FALSE);
    151   }
    152   fprintf (stderr, "exposure timeout\n");
     148    gprint (GP_ERR, "exposure error\n");
     149    gprint (GP_ERR, "%s\n", sbig_show_error (state));
     150    return (FALSE);
     151  }
     152  gprint (GP_ERR, "exposure timeout\n");
    153153  return (FALSE);
    154154}
    … …  
    158158static int readout_callback (float percent) {
    159159  /* return 1 to continue, 0 to abort */
    160   if (((int)(percent) % 10) == 0) { fprintf (stderr, "."); }
     160  if (((int)(percent) % 10) == 0) { gprint (GP_ERR, "."); }
    161161  readout_percent = percent;
    162162  if (readout_abort) return 0;
    … …  
    183183  readout.callback = readout_callback;
    184184   
    185   fprintf (stderr, "%d, %d : %d x %d\n", readout.x, readout.y, readout.width, readout.height);
     185  gprint (GP_ERR, "%d, %d : %d x %d\n", readout.x, readout.y, readout.width, readout.height);
    186186  sync ();
    187187  readout_abort = FALSE;
    188188  state = sbig_readout (&readout);
    189   fprintf (stderr, "\n");
    190   if (state < 0) {
    191     fprintf (stderr, "sbig error: %s\n", sbig_show_error (state));
     189  gprint (GP_ERR, "\n");
     190  if (state < 0) {
     191    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state));
    192192    return (FALSE);
    193193  }
    … …  
    203203  state = sbig_control (&control);
    204204  if (state < 0) {
    205     fprintf(stderr, "sbig error: %s\n", sbig_show_error (state));
     205    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state));
    206206    return (FALSE);
    207207  }
    … …  
    217217  state = sbig_control (&control);
    218218  if (state < 0) {
    219     fprintf(stderr, "sbig error: %s\n", sbig_show_error (state));
    220     return (FALSE);
    221   }
    222   return (TRUE);
    223 }
     219    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state));
     220    return (FALSE);
     221  }
     222  return (TRUE);
     223}

  • trunk/Ohana/src/opihi/dimm/Serial.c

    r2598 r7917  
    5353  serial.f = SerialOpen (serial.port);
    5454  if (serial.f <= 0) {
    55     fprintf (stderr, "Error opening serial port %s - error %d.\n", serial.port, serial.f);
     55    gprint (GP_ERR, "Error opening serial port %s - error %d.\n", serial.port, serial.f);
    5656    return (FALSE);
    5757  }
    … …  
    7777   fdesc = open (port, O_RDWR);
    7878   if (fdesc == -1) {
    79      if (SER_VERBOSE) fprintf(stderr, "Cannot open %s for read/write.\n", port);
     79     if (SER_VERBOSE) gprint (GP_ERR, "Cannot open %s for read/write.\n", port);
    8080     return OPENERR;
    8181   }
    … …  
    8787   locked = fcntl (fdesc, F_SETLK, &lock);
    8888   if (locked == -1) {
    89      fprintf (stderr, "can't lock serial line\n");
     89     gprint (GP_ERR, "can't lock serial line\n");
    9090     close (fdesc);
    9191     return OPENERR;
    … …  
    9494   /* Get the serial port's attributes... */
    9595   if (tcgetattr (fdesc, &term) == -1) {
    96       if (SER_VERBOSE) fprintf(stderr, "Port is not a tty\n");
     96      if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n");
    9797      return PORTERR;
    9898   }
    … …  
    133133   if (SER_VERBOSE) printf("Setting the serial port's baud rate.\n");
    134134   if (tcgetattr (fdesc, &term) == -1) {
    135       if (SER_VERBOSE) fprintf (stderr, "Port is not a tty\n");
     135      if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n");
    136136      return PORTERR;
    137137   }
    … …  
    174174   if (SER_VERBOSE) printf("Setting the serial port's parity.\n");
    175175   if (tcgetattr(fdesc, &term) == -1) {
    176       if (SER_VERBOSE) fprintf(stderr, "Port is not a tty\n");
     176      if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n");
    177177      return PORTERR;
    178178   }
    … …  
    202202   if (SER_VERBOSE) printf("Setting the serial port's data bit size.\n");
    203203   if (tcgetattr(fdesc, &term) == -1) {
    204       if (SER_VERBOSE) fprintf(stderr, "Port is not a tty\n");
     204      if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n");
    205205      return PORTERR;
    206206   }
    … …  
    241241   if (SER_VERBOSE) printf("Setting the serial port's stop bit.\n");
    242242   if (tcgetattr(fdesc, &term) == -1) {
    243       if (SER_VERBOSE) fprintf(stderr, "Port is not a tty\n");
     243      if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n");
    244244      return PORTERR;
    245245   }
    … …  
    274274  int done, Nread, Nin, NREAD;
    275275 
    276   if (SER_ECHO) fprintf (stderr, "command: %s\n", in);
     276  if (SER_ECHO) gprint (GP_ERR, "command: %s\n", in);
    277277
    278278  if (serial.f <= 0) {
    279     fprintf (stderr, "serial line closed\n");
     279    gprint (GP_ERR, "serial line closed\n");
    280280    if (out != (char **) NULL) {
    281281      *out = strcreate ("SERIAL OFF");
    … …  
    290290# if (0)
    291291  for (i = 0; i < strlen(in); i++) {
    292     fprintf (stderr, "%d %x\n", i, in[i]);
     292    gprint (GP_ERR, "%d %x\n", i, in[i]);
    293293  }
    294294# endif
    … …  
    297297  Nin = write (serial.f, in, strlen(in));
    298298  if (Nin != strlen(in)) {
    299     fprintf (stderr, "Serial Command not sent\n");
     299    gprint (GP_ERR, "Serial Command not sent\n");
    300300    return (FALSE);
    301301   }
    … …  
    316316    Nin = read (serial.f, &line[Nread], 256);
    317317# if (SER_DEBUG)
    318     fprintf (stderr, "%d ", Nin);
     318    gprint (GP_ERR, "%d ", Nin);
    319319# endif
    320320    if (Nin < 0) { /* error, check value */
    321       fprintf (stderr, "error?");
     321      gprint (GP_ERR, "error?");
    322322      continue;
    323323    }
    … …  
    335335  }
    336336
    337   if (SER_ECHO) fprintf (stderr, "answer: %s\n", line);
     337  if (SER_ECHO) gprint (GP_ERR, "answer: %s\n", line);
    338338
    339339  if (out == (char **) NULL) {

  • trunk/Ohana/src/opihi/dimm/Telescope.c

    r2598 r7917  
    7676  if (answer == (char *) NULL) return (FALSE);
    7777  if (strcmp (answer, "0")) {
    78     fprintf (stderr, "error: %s\n", answer);
     78    gprint (GP_ERR, "error: %s\n", answer);
    7979    return (FALSE);
    8080  }
    … …  
    135135  }
    136136  if (tsel < 0) {
    137     fprintf (stderr, "offset %f arcmin below minimum\n", distance);
     137    gprint (GP_ERR, "offset %f arcmin below minimum\n", distance);
    138138    return (FALSE);
    139139  }
    140140  if (tsel > SLEW_TIMEOUT) {
    141     fprintf (stderr, "offset %f arcmin above maximum\n", distance);
     141    gprint (GP_ERR, "offset %f arcmin above maximum\n", distance);
    142142    return (FALSE);
    143143  }
    144   fprintf (stderr, "offsetting %c for %f seconds\n", dir, tsel);
     144  gprint (GP_ERR, "offsetting %c for %f seconds\n", dir, tsel);
    145145 
    146146  sprintf (cmd, ":%s#", rcmd[rsel]);
    … …  
    181181  for (i = 0; i < NRATE; i++) if (!strcmp (rcmd[i], rate)) status = TRUE;
    182182  if (!status) {
    183     fprintf (stderr, "bad rate: %s\n", rate);
     183    gprint (GP_ERR, "bad rate: %s\n", rate);
    184184    return (FALSE);
    185185  }
    … …  
    234234
    235235  SerialCommand (":CM#", &answer, SER_TIMEOUT);
    236   fprintf (stderr, "result: %s\n", answer);
     236  gprint (GP_ERR, "result: %s\n", answer);
    237237  free (answer);
    238238  return (TRUE);
    … …  
    245245  char *str, line[32];
    246246
    247   fprintf (stderr, "careful, this causes problems\n");
     247  gprint (GP_ERR, "careful, this causes problems\n");
    248248  return (FALSE);
    249249

  • trunk/Ohana/src/opihi/dimm/altaz.c

    r2598 r7917  
    2525  latstr = get_variable ("LATITUDE");
    2626  if (latstr == (char *) NULL) {
    27     fprintf (stderr, "please define $LATITUDE\n");
     27    gprint (GP_ERR, "please define $LATITUDE\n");
    2828    return (FALSE);
    2929  }
    … …  
    5555  latstr = get_variable ("LATITUDE");
    5656  if (latstr == (char *) NULL) {
    57     fprintf (stderr, "please define $LATITUDE\n");
     57    gprint (GP_ERR, "please define $LATITUDE\n");
    5858    return (FALSE);
    5959  }
    … …  
    7979 
    8080 usage:
    81   fprintf (stderr, "USAGE: altaz -h (ha) (dec) (alt) (az)\n");
    82   fprintf (stderr, "USAGE: altaz -c (ha) (dec) (alt) (az)\n");
    83   fprintf (stderr, "       -h alt/az to ha/dec, -c ha/dec to alt/az\n");
    84   fprintf (stderr, "       returned values in variables provided\n");
     81  gprint (GP_ERR, "USAGE: altaz -h (ha) (dec) (alt) (az)\n");
     82  gprint (GP_ERR, "USAGE: altaz -c (ha) (dec) (alt) (az)\n");
     83  gprint (GP_ERR, "       -h alt/az to ha/dec, -c ha/dec to alt/az\n");
     84  gprint (GP_ERR, "       returned values in variables provided\n");
    8585  return (FALSE);
    8686

  • trunk/Ohana/src/opihi/dimm/camera.c

    r7080 r7917  
    3030
    3131    if (argc != 3) {
    32       fprintf (stderr, "USAGE: camera init (port)\n");
     32      gprint (GP_ERR, "USAGE: camera init (port)\n");
    3333      EXIT_STATUS (FALSE);
    3434    }
    … …  
    4444
    4545    if (argc != 3) {
    46       fprintf (stderr, "USAGE: camera expose (exptime)\n");
     46      gprint (GP_ERR, "USAGE: camera expose (exptime)\n");
    4747      EXIT_STATUS (FALSE);
    4848    }
    … …  
    5858
    5959    if (argc != 3) {
    60       fprintf (stderr, "USAGE: camera temp (temperature)\n");
     60      gprint (GP_ERR, "USAGE: camera temp (temperature)\n");
    6161      EXIT_STATUS (FALSE);
    6262    }
    … …  
    7272
    7373    if (argc != 2) {
    74       fprintf (stderr, "USAGE: camera status\n");
     74      gprint (GP_ERR, "USAGE: camera status\n");
    7575      EXIT_STATUS (FALSE);
    7676    }
    … …  
    8787
    8888    if ((argc != 7) && (argc != 3)) {
    89       fprintf (stderr, "USAGE: camera readout (buffer) x y dx dy\n");
     89      gprint (GP_ERR, "USAGE: camera readout (buffer) x y dx dy\n");
    9090      EXIT_STATUS (FALSE);
    9191    }
    … …  
    125125
    126126usage:
    127   fprintf (stderr, "camera init port\n");
    128   fprintf (stderr, "camera expose exptime\n");
    129   fprintf (stderr, "camera readout x y dx dy\n");
    130   fprintf (stderr, "camera temp set value\n");
    131   fprintf (stderr, "camera temp get var\n");
     127  gprint (GP_ERR, "camera init port\n");
     128  gprint (GP_ERR, "camera expose exptime\n");
     129  gprint (GP_ERR, "camera readout x y dx dy\n");
     130  gprint (GP_ERR, "camera temp set value\n");
     131  gprint (GP_ERR, "camera temp get var\n");
    132132  seteuid (UID);
    133133  return (FALSE);

  • trunk/Ohana/src/opihi/dimm/dimm.c

    r5919 r7917  
    3434/* standard welcome message */
    3535void welcome () {
    36   fprintf (stderr, "\n");
    37   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     36  gprint (GP_ERR, "\n");
     37  gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    3838}
    3939

  • trunk/Ohana/src/opihi/dimm/findstars.c

    r2598 r7917  
    1919
    2020  if (argc != 3) {
    21     fprintf (stderr, "USAGE: findstars (buffer) (threshold)\n");
     21    gprint (GP_ERR, "USAGE: findstars (buffer) (threshold)\n");
    2222    return (FALSE);
    2323  }
    … …  
    133133  *x = Sx / So;
    134134  *y = Sy / So;
    135   fprintf (stderr, "%f %f  %f %d\n", *x, *y, So, Npixlist);
     135  gprint (GP_ERR, "%f %f  %f %d\n", *x, *y, So, Npixlist);
    136136
    137137  No = vecx[0].Nelements;

  • trunk/Ohana/src/opihi/dimm/sbig/sp_ccdcontrol.c

    r2598 r7917  
    3636static int readout_callback(float percent)
    3737{
    38   fprintf(stderr, "progress: Reading %d x %d pixels (%d%%)\r",
     38  gprint (GP_ERR, "progress: Reading %d x %d pixels (%d%%)\r",
    3939          readout.width, readout.height, (int)percent);
    4040  /* return 1 to continue, 0 to abort */
    … …  
    6060
    6161  if(binmode<0 || binmode>3){
    62     fprintf(stderr, "Imaging binmode options: [0=1x1, *1=2x2, 2=3x3]\n");
     62    gprint (GP_ERR, "Imaging binmode options: [0=1x1, *1=2x2, 2=3x3]\n");
    6363    exit(EXIT_FAILURE);
    6464  }
    … …  
    7575    if (readout.width + x >
    7676        info.camera_info[expose.ccd].readout_mode[readout.binning].width) {
    77     fprintf(stderr, "Raster X or Width parameter out of range.\n");
     77    gprint (GP_ERR, "Raster X or Width parameter out of range.\n");
    7878    exit(EXIT_FAILURE);
    7979  }
    … …  
    8585    if (readout.height + y >
    8686        info.camera_info[expose.ccd].readout_mode[readout.binning].height) {
    87     fprintf(stderr, "Raster Y or Height parameter out of range.\n");
     87    gprint (GP_ERR, "Raster Y or Height parameter out of range.\n");
    8888    exit(EXIT_FAILURE);
    8989  }
    … …  
    9898  ret = sbig_expose(&expose);
    9999  if (ret < 0)
    100     fprintf(stderr, "sbig error: %s\n", sbig_show_error(ret));
     100    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret));
    101101 
    102   fprintf(stderr, "progress: Sleeping for %g seconds\r", 0.01*expose.exposure_time);
     102  gprint (GP_ERR, "progress: Sleeping for %g seconds\r", 0.01*expose.exposure_time);
    103103
    104104  if (expose.exposure_time > 100) {
    105105    for (i = 0; i < expose.exposure_time; i += 100) {
    106106      sbig_get_status(&status);
    107       fprintf(stderr, "progress: Exposure in progress; ccd_status=%d, shutter=%d (%d%%)\r",
     107      gprint (GP_ERR, "progress: Exposure in progress; ccd_status=%d, shutter=%d (%d%%)\r",
    108108              status.imaging_ccd_status, status.shutter_state,
    109109              i * 100 / expose.exposure_time);
    … …  
    114114 
    115115  /* wait for exposure to complete */
    116   fprintf(stderr, "progress: Waiting for controller                             (100%%)\r");
     116  gprint (GP_ERR, "progress: Waiting for controller                             (100%%)\r");
    117117
    118118  for (i = 0; i < 1000; ++i) {
    119119    ret = sbig_get_status(&status);
    120120    if (ret < 0) {
    121       fprintf(stderr, "sbig error: %s\n", sbig_show_error(ret));
     121      gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret));
    122122      break;
    123123    }
    124124    if (status.imaging_ccd_status != 3)
    125       fprintf(stderr, "logonly: ccd_status=%d\n", status.imaging_ccd_status);
     125      gprint (GP_ERR, "logonly: ccd_status=%d\n", status.imaging_ccd_status);
    126126
    127127    if (readout.ccd == 0) {
    … …  
    135135  }
    136136  if (i)
    137     fprintf(stderr, "warning: Exposure took an extra %g seconds\n", 0.050*i);
     137    gprint (GP_ERR, "warning: Exposure took an extra %g seconds\n", 0.050*i);
    138138
    139139  if (i == 1000)
    140     fprintf(stderr, "error: EXPOSURE DIDN'T FINISH!\n");
     140    gprint (GP_ERR, "error: EXPOSURE DIDN'T FINISH!\n");
    141141  else
    142     fprintf(stderr, "progress: Exposure complete                                  (100%%)\n");
     142    gprint (GP_ERR, "progress: Exposure complete                                  (100%%)\n");
    143143
    144144  readout.ccd = expose.ccd;
    … …  
    156156  sync();
    157157  if ((ret = sbig_readout(&readout)) < 0) {
    158     fprintf(stderr, "sbig error: %s\n", sbig_show_error(ret));
     158    gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret));
    159159    return;
    160160  }
    161161
    162   fprintf(stderr, "progress: Writing FITS data to stdout\n");
     162  gprint (GP_ERR, "progress: Writing FITS data to stdout\n");
    163163
    164164  if(write_fits(readout.width, readout.height, etime, binmode, buffer)==-1)
    165     fprintf(stderr, "error: Could not write FITS file to stdout.\n");
    166   fprintf(stderr, "progress: sp_ccdcontrol done.\n");
     165    gprint (GP_ERR, "error: Could not write FITS file to stdout.\n");
     166  gprint (GP_ERR, "progress: sp_ccdcontrol done.\n");
    167167}
    168168
    … …  
    184184
    185185  if (ret < 0) {
    186     fprintf(stderr, "error: sbig_get_status failed: %s\n", sbig_show_error(ret));
     186    gprint (GP_ERR, "error: sbig_get_status failed: %s\n", sbig_show_error(ret));
    187187    exit(EXIT_FAILURE);
    188188  }
    … …  
    262262    exit(EXIT_FAILURE);
    263263
    264   fprintf(stderr, "logonly: Wrote %d pixels, min=%g, max=%g\n", w*h, datamin, datamax);
     264  gprint (GP_ERR, "logonly: Wrote %d pixels, min=%g, max=%g\n", w*h, datamin, datamax);
    265265  sync();
    266266  return 0;
    … …  
    268268
    269269static void show_format(void){
    270   fprintf(stderr, "Format for sp_ccdcontrol, SkyProbe CCD controller:\n"
     270  gprint (GP_ERR, "Format for sp_ccdcontrol, SkyProbe CCD controller:\n"
    271271          "Writes FITS file to stdout, status messages to stderr.\n"
    272272          "NOTE: -port {hex} is an option for all forms of sp_ccdcontrol,\n"
    … …  
    310310    if (!strcmp(argv[i], "-port")) {
    311311      sscanf(argv[++i], "%x", &port);
    312       fprintf(stderr, "port override to 0x%x\n", port);
     312      gprint (GP_ERR, "port override to 0x%x\n", port);
    313313    }
    314314  }
    … …  
    322322                             */
    323323    if (ret == 0) break;
    324     fprintf(stderr,"logonly: sbig_init() failed: %s\n", sbig_show_error(ret));
     324    gprint (GP_ERR,"logonly: sbig_init() failed: %s\n", sbig_show_error(ret));
    325325    usleep(100000);
    326326  }
    327327  if (ret < 0) {
    328     fprintf(stderr, "error: cannot open camera, giving up\n");
     328    gprint (GP_ERR, "error: cannot open camera, giving up\n");
    329329    exit(EXIT_FAILURE);
    330330  }
    … …  
    336336    rmp = &info.camera_info[0].readout_mode[i];
    337337#ifdef DEBUG
    338     fprintf(stderr, "debug: ImagingCCD mode %d: w=%d h=%d "
     338    gprint (GP_ERR, "debug: ImagingCCD mode %d: w=%d h=%d "
    339339            "gain=%f "
    340340            "pw=%g ph=%g\n", rmp->mode, rmp->width,
    … …  
    349349    rmp = &info.camera_info[1].readout_mode[i];
    350350#ifdef DEBUG
    351     fprintf(stderr, "debug: TrackingCCD mode %d: w=%d h=%d "
     351    gprint (GP_ERR, "debug: TrackingCCD mode %d: w=%d h=%d "
    352352            "gain=%f "
    353353            "pw=%g ph=%g\n"
    … …  
    363363        if(argc>(i+1)) etime = atof(argv[++i]);
    364364        else
    365           fprintf(stderr, "No argument given to -etime\n");
     365          gprint (GP_ERR, "No argument given to -etime\n");
    366366      }
    367367    }
    368368    if(etime==-999.){
    369         fprintf(stderr, "Must specify exposure time.\n");
     369        gprint (GP_ERR, "Must specify exposure time.\n");
    370370        exit(EXIT_FAILURE);
    371371      }
    … …  
    376376          if(argc>(i+1)) binmode = atoi(argv[++i]);
    377377          else{
    378             fprintf(stderr, "No argument given for -binmode\n");
     378            gprint (GP_ERR, "No argument given for -binmode\n");
    379379            exit(EXIT_FAILURE);
    380380          }
    … …  
    388388          if (argc>(i+1)) shuttermode = atoi(argv[++i]);
    389389          else{
    390             fprintf(stderr, "No argument given for -shuttermode\n");
     390            gprint (GP_ERR, "No argument given for -shuttermode\n");
    391391            exit(EXIT_FAILURE);
    392392          }
    … …  
    407407          }
    408408          else{
    409             fprintf(stderr, "-raster requires 4 arguments: x y w h\n");
     409            gprint (GP_ERR, "-raster requires 4 arguments: x y w h\n");
    410410            exit(EXIT_FAILURE);
    411411          }
    … …  
    420420   
    421421    if(argc<3){
    422       fprintf(stderr, "Too few arguments for cool mode\n");
     422      gprint (GP_ERR, "Too few arguments for cool mode\n");
    423423      exit(EXIT_FAILURE);
    424424    }
    … …  
    426426   
    427427    if(coolmode<0 || coolmode>2){
    428       fprintf(stderr, "Cooling mode values allowed: [0 Off, 1 *On, 2 DirectDrive]\n");
     428      gprint (GP_ERR, "Cooling mode values allowed: [0 Off, 1 *On, 2 DirectDrive]\n");
    429429      exit(EXIT_FAILURE);
    430430    }
    … …  
    433433    if (cool.regulation == 2){
    434434      if(argc<4){
    435         fprintf(stderr, "Must specify cooling power (0-255)\n");
     435        gprint (GP_ERR, "Must specify cooling power (0-255)\n");
    436436        exit(EXIT_FAILURE);
    437437      }
    438438      coolpwr=atof(argv[3]);
    439439      if(coolpwr<0 || coolpwr>255){
    440         fprintf(stderr, "Cooling power must be 0-255.\n");
     440        gprint (GP_ERR, "Cooling power must be 0-255.\n");
    441441        exit(EXIT_FAILURE);
    442442      }
    … …  
    445445    else if (cool.regulation == 1) {
    446446      if(argc<4){
    447         fprintf(stderr, "Must specify temperature in deg C\n");
     447        gprint (GP_ERR, "Must specify temperature in deg C\n");
    448448        exit(EXIT_FAILURE);
    449449      }
    450450      cooltemp=atof(argv[3]);
    451451      if(cooltemp<-50 || cooltemp>20){
    452         fprintf(stderr, "Cooling temperature must be -50 to 20 deg C.\n");
     452        gprint (GP_ERR, "Cooling temperature must be -50 to 20 deg C.\n");
    453453        exit(EXIT_FAILURE);
    454454      }
    … …  
    460460    ret = sbig_set_cooling(&cool);
    461461    if (ret < 0){
    462       fprintf(stderr, "sbig error: %s\n", sbig_show_error(ret));
     462      gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret));
    463463    }
    464464  }else{
    465     fprintf(stderr, "Illegal command: '%s'\n", cmd);
     465    gprint (GP_ERR, "Illegal command: '%s'\n", cmd);
    466466    show_format();
    467467  }

  • trunk/Ohana/src/opihi/dimm/telescope.c

    r2598 r7917  
    99  if (!strcasecmp (argv[1], "init")) {
    1010    if (argc != 3) {
    11       fprintf (stderr, "USAGE: telescope init (port)\n");
     11      gprint (GP_ERR, "USAGE: telescope init (port)\n");
    1212      return (FALSE);
    1313    }
    1414    if (!SerialInit (argv[2])) return (FALSE);
    15     fprintf (stderr, "telescope on port %s\n", argv[2]);
     15    gprint (GP_ERR, "telescope on port %s\n", argv[2]);
    1616    return (TRUE);
    1717  }
    … …  
    2323
    2424    if (argc != 3) {
    25       fprintf (stderr, "USAGE: telescope cmd (string)\n");
     25      gprint (GP_ERR, "USAGE: telescope cmd (string)\n");
    2626      return (FALSE);
    2727    }
    2828    status = SerialCommand (argv[2], &answer, 10);
    29     fprintf (stderr, "status: %d\n", status);
     29    gprint (GP_ERR, "status: %d\n", status);
    3030    if (answer != (char *) NULL) {
    31       fprintf (stderr, "answer: ..%s..\n", answer);
     31      gprint (GP_ERR, "answer: ..%s..\n", answer);
    3232    }
    3333    return (TRUE);
    … …  
    4040
    4141    if (argc != 3) {
    42       fprintf (stderr, "USAGE: telescope cmd (string)\n");
     42      gprint (GP_ERR, "USAGE: telescope cmd (string)\n");
    4343      return (FALSE);
    4444    }
    … …  
    4646    line[1] = 0;
    4747    status = SerialCommand (line, &answer, 10);
    48     fprintf (stderr, "status: %d\n", status);
     48    gprint (GP_ERR, "status: %d\n", status);
    4949    if (answer != (char *) NULL) {
    50       fprintf (stderr, "answer: ..%s..\n", answer);
     50      gprint (GP_ERR, "answer: ..%s..\n", answer);
    5151    }
    5252    return (TRUE);
    … …  
    5959
    6060    if (argc != 4) {
    61       fprintf (stderr, "USAGE: telescope slew (ra) (dec)\n");
     61      gprint (GP_ERR, "USAGE: telescope slew (ra) (dec)\n");
    6262      return (FALSE);
    6363    }
    … …  
    8181
    8282    if (argc != 2) {
    83       fprintf (stderr, "USAGE: telescope coords\n");
     83      gprint (GP_ERR, "USAGE: telescope coords\n");
    8484      return (FALSE);
    8585    }
    8686
    8787    if (!getRD (&ra, &dec)) return (FALSE);
    88     fprintf (stderr, "%f %f\n", ra, dec);
     88    gprint (GP_ERR, "%f %f\n", ra, dec);
    8989    set_variable ("RA", ra);
    9090    set_variable ("DEC", dec);
    … …  
    103103
    104104    if (argc != 2) {
    105       fprintf (stderr, "USAGE: telescope altaz\n");
     105      gprint (GP_ERR, "USAGE: telescope altaz\n");
    106106      return (FALSE);
    107107    }
    108108
    109109    if (!getXY (&x, &y)) return (FALSE);
    110     fprintf (stderr, "%f %f\n", x, y);
     110    gprint (GP_ERR, "%f %f\n", x, y);
    111111    set_variable ("ALT", x);
    112112    set_variable ("AZ", y);
    … …  
    120120
    121121    if (argc != 2) {
    122       fprintf (stderr, "USAGE: telescope site\n");
     122      gprint (GP_ERR, "USAGE: telescope site\n");
    123123      return (FALSE);
    124124    }
    125125
    126126    if (!getSite (&lon, &lat, &LST)) return (FALSE);
    127     fprintf (stderr, "%f %f  %f\n", lon, lat, LST);
     127    gprint (GP_ERR, "%f %f  %f\n", lon, lat, LST);
    128128    set_variable ("LON", lon);
    129129    set_variable ("LAT", lat);
    … …  
    137137
    138138    if (argc != 5) {
    139       fprintf (stderr, "USAGE: telescope setsite (name) (longitude) (latitude)\n");
     139      gprint (GP_ERR, "USAGE: telescope setsite (name) (longitude) (latitude)\n");
    140140      return (FALSE);
    141141    }
    … …  
    152152
    153153    if (argc != 3) {
    154       fprintf (stderr, "USAGE: telescope settime (lst)\n");
     154      gprint (GP_ERR, "USAGE: telescope settime (lst)\n");
    155155      return (FALSE);
    156156    }
    … …  
    165165
    166166    if (argc != 3) {
    167       fprintf (stderr, "USAGE: telescope verbose (mode)\n");
     167      gprint (GP_ERR, "USAGE: telescope verbose (mode)\n");
    168168      return (FALSE);
    169169    }
    … …  
    180180
    181181    if (argc != 4) {
    182       fprintf (stderr, "USAGE: telescope setcoords (ra) (dec)\n");
     182      gprint (GP_ERR, "USAGE: telescope setcoords (ra) (dec)\n");
    183183      return (FALSE);
    184184    }
    … …  
    196196
    197197    if (argc != 4) {
    198       fprintf (stderr, "USAGE: telescope offset (direction) (distance)\n");
    199       fprintf (stderr, "  direction : x or y\n");
    200       fprintf (stderr, "  distance  : +arcmin or -arcmin\n");
     198      gprint (GP_ERR, "USAGE: telescope offset (direction) (distance)\n");
     199      gprint (GP_ERR, "  direction : x or y\n");
     200      gprint (GP_ERR, "  distance  : +arcmin or -arcmin\n");
    201201      return (FALSE);
    202202    }
    … …  
    212212
    213213    if (argc != 5) {
    214       fprintf (stderr, "USAGE: telescope toffset (direction) (rate) (duration)\n");
    215       fprintf (stderr, "example: telescope toffset x RC 1.5\n");
     214      gprint (GP_ERR, "USAGE: telescope toffset (direction) (rate) (duration)\n");
     215      gprint (GP_ERR, "example: telescope toffset x RC 1.5\n");
    216216      return (FALSE);
    217217    }
    … …  
    223223
    224224 usage:
    225   fprintf (stderr, "telescope init port - set serial port (eg, /dev/ttyS0)\n");
    226   fprintf (stderr, "telescope site - get site information\n");
    227   fprintf (stderr, "telescope altaz - g\n");
    228   fprintf (stderr, "telescope setcoords (ra) (dec)\n");
    229   fprintf (stderr, "telescope setsite (name) (longitute) (latitude)\n");
    230   fprintf (stderr, "telescope coords\n");
    231   fprintf (stderr, "telescope slew (ra) (dec)\n");
    232   fprintf (stderr, "telescope offset (direction) (duration)\n");
    233   fprintf (stderr, "telescope toffset (direction) (rate) (duration)\n");
     225  gprint (GP_ERR, "telescope init port - set serial port (eg, /dev/ttyS0)\n");
     226  gprint (GP_ERR, "telescope site - get site information\n");
     227  gprint (GP_ERR, "telescope altaz - g\n");
     228  gprint (GP_ERR, "telescope setcoords (ra) (dec)\n");
     229  gprint (GP_ERR, "telescope setsite (name) (longitute) (latitude)\n");
     230  gprint (GP_ERR, "telescope coords\n");
     231  gprint (GP_ERR, "telescope slew (ra) (dec)\n");
     232  gprint (GP_ERR, "telescope offset (direction) (duration)\n");
     233  gprint (GP_ERR, "telescope toffset (direction) (rate) (duration)\n");
    234234  return (FALSE);
    235235}

  • trunk/Ohana/src/opihi/dimm/version.c

    r7080 r7917  
    44int version (int argc, char **argv) {
    55
    6   fprintf (stderr, "%s\n", name);
     6  gprint (GP_ERR, "%s\n", name);
    77
    8   fprintf (stderr, "%s\n", opihi_version());
    9   fprintf (stderr, "%s\n", ohana_version());
    10   fprintf (stderr, "%s\n", gfits_version());
     8  gprint (GP_ERR, "%s\n", opihi_version());
     9  gprint (GP_ERR, "%s\n", ohana_version());
     10  gprint (GP_ERR, "%s\n", gfits_version());
    1111
    12   fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__);
     12  gprint (GP_ERR, "compiled on %s %s\n", __DATE__, __TIME__);
    1313  return (TRUE);
    1414}

  • trunk/Ohana/src/opihi/doc/ippc_commandserver.c

    r3419 r7917  
    4040
    4141  if (IPPC_DEFAULT_VERBOSITY > 1) {
    42     fprintf(stderr, "%s : THIS PROGRAM _IS_ A REMOTE EXPLOIT!!!\n", argv[0]);
     42    gprint (GP_ERR, "%s : THIS PROGRAM _IS_ A REMOTE EXPLOIT!!!\n", argv[0]);
    4343  }
    4444
    … …  
    7878  while(1) {
    7979    if (IPPC_DEFAULT_VERBOSITY > 1) {
    80       fprintf(stderr, "%s : pid: %d - waiting for connection...\n", argv[0], getpid());
     80      gprint (GP_ERR, "%s : pid: %d - waiting for connection...\n", argv[0], getpid());
    8181    }
    8282
    … …  
    8686    } else {
    8787      if (IPPC_DEFAULT_VERBOSITY > 1) {
    88         fprintf(stderr, "%s : pid: %d - kids: %d - child limit already reached, sleeping %ds...\n",
     88        gprint (GP_ERR, "%s : pid: %d - kids: %d - child limit already reached, sleeping %ds...\n",
    8989          argv[0], getpid(), kids, WAIT_FOR_KIDS);
    9090      }
    … …  
    9898    if (fork() == 0) {
    9999      if (IPPC_DEFAULT_VERBOSITY > 1) {
    100         fprintf(stderr, "%s : pid: %d - new kid number: %d\n", argv[0], getpid(), kids);
     100        gprint (GP_ERR, "%s : pid: %d - new kid number: %d\n", argv[0], getpid(), kids);
    101101      }
    102102
    … …  
    110110      if (ntohl(auth_token) != COMMAND_KEY) {
    111111        if (IPPC_DEFAULT_VERBOSITY > 1) {
    112           fprintf(stderr, "%s : pid: %d - invalid authentication key\n", argv[0], getpid());
     112          gprint (GP_ERR, "%s : pid: %d - invalid authentication key\n", argv[0], getpid());
    113113        }
    114114
    … …  
    124124 
    125125      if (IPPC_DEFAULT_VERBOSITY > 1) {
    126         fprintf(stderr, "%s : pid: %d - recieved: %s\n", argv[0], getpid(), buffer);
     126        gprint (GP_ERR, "%s : pid: %d - recieved: %s\n", argv[0], getpid(), buffer);
    127127      }
    128128 
    … …  
    131131      if (status != 0) {
    132132        if (IPPC_DEFAULT_VERBOSITY > 1) {
    133           fprintf(stderr, "%s : pid: %d - command failed - code: %d\n", argv[0], getpid(), status);
     133          gprint (GP_ERR, "%s : pid: %d - command failed - code: %d\n", argv[0], getpid(), status);
    134134        }
    135135        netSafe = htons(status);
    … …  
    137137      } else {
    138138        if (IPPC_DEFAULT_VERBOSITY > 1) {
    139           fprintf(stderr, "%s : pid: %d - command successful\n", argv[0], getpid());
     139          gprint (GP_ERR, "%s : pid: %d - command successful\n", argv[0], getpid());
    140140        }
    141141        netSafe = htons(status);

  • trunk/Ohana/src/opihi/doc/sample.c

    r2598 r7917  
    77
    88  for (i = 0; i <= argc; i++) {
    9     fprintf (stderr, "arg %2d: %s\n", i, argv[i]);
     9    gprint (GP_ERR, "arg %2d: %s\n", i, argv[i]);
    1010  }
    1111  while (argv[i] != NULL) {
    12     fprintf (stderr, "env %2d: %s\n", i, argv[i]);
     12    gprint (GP_ERR, "env %2d: %s\n", i, argv[i]);
    1313    i++;
    1414  }
    1515  while (fscanf (stdin, "%s", line) != EOF) {
    16     fprintf (stderr, "line: ...%s...\n", line);
     16    gprint (GP_ERR, "line: ...%s...\n", line);
    1717  }
    1818}

  • trunk/Ohana/src/opihi/dvo/ImageSelection.c

    r7680 r7917  
    2222    Ngraph = 0;
    2323    if (!GetGraphData (&graphsky, NULL, &Ngraph)) {
    24       fprintf (stderr, "region display not available\n");
     24      gprint (GP_ERR, "region display not available\n");
    2525      return (FALSE);
    2626    }

  • trunk/Ohana/src/opihi/dvo/LoadImages.c

    r7680 r7917  
    1717
    1818  if (!gfits_db_lock (&db, filename)) {
    19     fprintf (stderr, "error opening image catalog %s (1)\n", filename);
     19    gprint (GP_ERR, "error opening image catalog %s (1)\n", filename);
    2020    return (NULL);
    2121  }
    2222
    2323  if (db.dbstate == LCK_EMPTY) {
    24     fprintf (stderr, "note: image catalog is empty\n");
     24    gprint (GP_ERR, "note: image catalog is empty\n");
    2525    ALLOCATE (image, Image, 1);
    2626    *nimage = 1;

  • trunk/Ohana/src/opihi/dvo/addxtra.c

    r7680 r7917  
    4040
    4141  if (argc != 6) {
    42     fprintf (stderr, "USAGE: addxtra R D radius (type) (value)\n");
     42    gprint (GP_ERR, "USAGE: addxtra R D radius (type) (value)\n");
    4343    return (FALSE);
    4444  }

  • trunk/Ohana/src/opihi/dvo/aregion.c

    r7680 r7917  
    3838  }
    3939  if (NBigDec < 0) {
    40     fprintf (stderr, "dec out of range: %f\n", dec);
     40    gprint (GP_ERR, "dec out of range: %f\n", dec);
    4141  }
    4242   
    … …  
    6363
    6464  if (!done) {
    65     fprintf (stderr, "error in search: %f %f\n", ra, dec);
     65    gprint (GP_ERR, "error in search: %f %f\n", ra, dec);
    6666    exit (0);
    6767  }

  • trunk/Ohana/src/opihi/dvo/avextract.c

    r7680 r7917  
    9090
    9191usage:
    92   fprintf (stderr, "USAGE: avextract (value) [options]\n");
    93   fprintf (stderr, "  value: average.parameter or photcode\n");
     92  gprint (GP_ERR, "USAGE: avextract (value) [options]\n");
     93  gprint (GP_ERR, "  value: average.parameter or photcode\n");
    9494
    9595escape:

  • trunk/Ohana/src/opihi/dvo/badimages.c

    r7680 r7917  
    1414
    1515  if (argc != 3) {
    16     fprintf (stderr, "USAGE: badimages entry value\n");
    17     fprintf (stderr, "   OR: badimages -image N\n");
     16    gprint (GP_ERR, "USAGE: badimages entry value\n");
     17    gprint (GP_ERR, "   OR: badimages -image N\n");
    1818    return (FALSE);
    1919  }
    … …  
    3838    ptr = &image[entry].coords.crpix1;
    3939    for (i = 0; i < 22; i++) {
    40       fprintf (GetOutfile(), "%2d: %g\n", i, ptr[i]);
     40      gprint (GP_LOG, "%2d: %g\n", i, ptr[i]);
    4141    }
    4242    value = image[entry].coords.pc1_1*image[entry].coords.pc2_2 + image[entry].coords.pc1_2*image[entry].coords.pc2_1;
    43     fprintf (GetOutfile(), " x: %g\n", value);
     43    gprint (GP_LOG, " x: %g\n", value);
    4444    return (TRUE);
    4545  }
    … …  
    5757      value = image[i].coords.pc1_1*image[i].coords.pc2_2 + image[i].coords.pc1_2*image[i].coords.pc2_1;
    5858      if ((value > big) || (value < small)) {
    59         fprintf (GetOutfile(), "%5d %s: %d %g\n", i, image[i].name, image[i].tzero, value);
     59        gprint (GP_LOG, "%5d %s: %d %g\n", i, image[i].name, image[i].tzero, value);
    6060      }
    6161    }
    … …  
    6464      ptr = &image[i].coords.crpix1;
    6565      if ((ptr[entry] > big) || (ptr[entry] < small)) {
    66         fprintf (GetOutfile(), "%5d %s: %d %g\n", i, image[i].name, image[i].tzero, ptr[entry]);
     66        gprint (GP_LOG, "%5d %s: %d %g\n", i, image[i].name, image[i].tzero, ptr[entry]);
    6767      }
    6868    }

  • trunk/Ohana/src/opihi/dvo/calextract.c

    r7680 r7917  
    5858
    5959  for (Nr = 0; Nr < skylist[0].Nregions; Nr++) {
    60     if (Nr && !(Nr % 500)) { fprintf (stderr, "."); }
     60    if (Nr && !(Nr % 500)) { gprint (GP_ERR, "."); }
    6161
    6262    /* lock, load, unlock catalog */
    … …  
    7777    /* extract values, assign to vectors */
    7878    for (i = 0; i < catalog.Naverage; i++) {
    79       if (i && !(i % 10000)) { fprintf (stderr, ","); }
     79      if (i && !(i % 10000)) { gprint (GP_ERR, ","); }
    8080      m = catalog.average[i].offset;
    8181
    … …  
    130130 
    131131usage:
    132   fprintf (stderr, "USAGE: calextract F - F\n");
     132  gprint (GP_ERR, "USAGE: calextract F - F\n");
    133133  return (FALSE);
    134134

  • trunk/Ohana/src/opihi/dvo/calmextract.c

    r7680 r7917  
    7171
    7272  for (Nr = 0; Nr < skylist[0].Nregions; Nr++) {
    73     if (Nr && !(Nr % 500)) { fprintf (stderr, "."); }
     73    if (Nr && !(Nr % 500)) { gprint (GP_ERR, "."); }
    7474
    7575    /* lock, load, unlock catalog */
    … …  
    157157 
    158158usage:
    159   fprintf (stderr, "USAGE: dmags F - F : measure.param\n");
     159  gprint (GP_ERR, "USAGE: dmags F - F : measure.param\n");
    160160  return (FALSE);
    161161
    … …  
    178178  value = ExtractMeasures (code, mode, average, secfilt, measure, &N, param);
    179179  if (N != Nin) {
    180     fprintf (stderr, "error!\n");
     180    gprint (GP_ERR, "error!\n");
    181181    return (FALSE);
    182182  }

  • trunk/Ohana/src/opihi/dvo/catalog.c

    r7680 r7917  
    4949  NN = get_argument (argc, argv, "-n");
    5050  if (NN && Nn) {
    51     fprintf (stderr, "can't mix meas and miss scaling\n");
     51    gprint (GP_ERR, "can't mix meas and miss scaling\n");
    5252    return (FALSE);
    5353  }
    … …  
    163163 
    164164  if ((InRegion || (argc != 2)) && (!InRegion || (argc != 1))) {
    165     fprintf (stderr, "USAGE: catalog (filename / -all) [-m M M] [-n N N] [-g] [-a RA DEC MAG] \n");
     165    gprint (GP_ERR, "USAGE: catalog (filename / -all) [-m M M] [-n N N] [-g] [-a RA DEC MAG] \n");
    166166    return (FALSE);
    167167  }
    … …  
    185185      f = fopen (argv[1], "r");
    186186      if (f == (FILE *) NULL) {
    187         fprintf (stderr, "ERROR: can't open catalog file: %s\n", argv[1]);
     187        gprint (GP_ERR, "ERROR: can't open catalog file: %s\n", argv[1]);
    188188        return (FALSE);
    189189      }
    … …  
    225225      f = fopen (argv[1], "r");
    226226      if (f == (FILE *) NULL) {
    227         fprintf (stderr, "ERROR: can't open catalog file: %s\n", argv[1]);
     227        gprint (GP_ERR, "ERROR: can't open catalog file: %s\n", argv[1]);
    228228        return (FALSE);
    229229      }
    … …  
    274274      f = fopen (filename, "r");
    275275      if (f == (FILE *) NULL) {
    276         fprintf (stderr, "no stars in %s, skipping\n", filename);
     276        gprint (GP_ERR, "no stars in %s, skipping\n", filename);
    277277        continue;
    278278        /* return (FALSE); */

  • trunk/Ohana/src/opihi/dvo/catdir.c

    r7680 r7917  
    1313
    1414  if (argc != 2) {
    15     fprintf (stderr, "USAGE: catdir (name)\n");
    16     fprintf (stderr, "       (name) may be a path or 'default'\n");
     15    gprint (GP_ERR, "USAGE: catdir (name)\n");
     16    gprint (GP_ERR, "       (name) may be a path or 'default'\n");
    1717    current = GetCATDIR ();
    1818    if (current == NULL) {
    19       fprintf (stderr, "catdir not defined\n");
     19      gprint (GP_ERR, "catdir not defined\n");
    2020    } else {
    21       fprintf (stderr, "current: %s\n", current);
     21      gprint (GP_ERR, "current: %s\n", current);
    2222    }
    2323    return (FALSE);
    … …  
    3131
    3232  if (!status) {
    33     fprintf (stderr, "invalid / undefined CATDIR\n");
     33    gprint (GP_ERR, "invalid / undefined CATDIR\n");
    3434    return (FALSE);
    3535  }

  • trunk/Ohana/src/opihi/dvo/ccd.c

    r7680 r7917  
    121121
    122122usage:
    123   fprintf (stderr, "USAGE: ccd F - F : F - F\n");
     123  gprint (GP_ERR, "USAGE: ccd F - F : F - F\n");
    124124  return (FALSE);
    125125

  • trunk/Ohana/src/opihi/dvo/cmatch.c

    r7680 r7917  
    99
    1010  if (argc != 9) {
    11     fprintf (stderr, "USAGE: cmatch file radius (RA) (DEC) (Mag) (dRA) (dDEC) (dMag)\n");
    12     fprintf (stderr, "       match a set of object coordinates with a DVO db table\n");
     11    gprint (GP_ERR, "USAGE: cmatch file radius (RA) (DEC) (Mag) (dRA) (dDEC) (dMag)\n");
     12    gprint (GP_ERR, "       match a set of object coordinates with a DVO db table\n");
    1313    return (FALSE);
    1414  }
    1515
    1616  /*** this function is not well-defined.  re-assess it and re-code it ***/
    17   fprintf (stderr, "disabled for now\n");
     17  gprint (GP_ERR, "disabled for now\n");
    1818  return (FALSE);
    1919
    … …  
    4141  }
    4242  unlock_catalog (&catalog1);
    43   fprintf (stderr, "read %d stars from phot catalog file %s\n", catalog1.Naverage, filename);
     43  gprint (GP_ERR, "read %d stars from phot catalog file %s\n", catalog1.Naverage, filename);
    4444
    4545  /* this is for loading from a text file, presumably hstgsc or usno

  • trunk/Ohana/src/opihi/dvo/cmd.c

    r7680 r7917  
    119119
    120120usage:
    121   fprintf (stderr, "USAGE: cmd F - F : F\n");
     121  gprint (GP_ERR, "USAGE: cmd F - F : F\n");
    122122  return (FALSE);
    123123

  • trunk/Ohana/src/opihi/dvo/cmpRead.c

    r7680 r7917  
    3939
    4040escape:
    41   fprintf (stderr, "error reading file\n");
     41  gprint (GP_ERR, "error reading file\n");
    4242  *nstars = 0;
    4343  return (NULL);
    … …  
    8080        nbytes -= Nskip;
    8181        bzero (buffer + nbytes, Nskip);
    82         /* if (VERBOSE) fprintf (stderr, "deleted %d extra return chars\n", Nskip); */
     82        /* if (VERBOSE) gprint (GP_ERR, "deleted %d extra return chars\n", Nskip); */
    8383      }
    8484      c2 = strchr (c, '\n');
    … …  
    9393        nbytes -= Nskip;
    9494        bzero (buffer + nbytes, Nskip);
    95         /* if (VERBOSE) fprintf (stderr, "deleted line, %d extra chars\n", Nskip); */
     95        /* if (VERBOSE) gprint (GP_ERR, "deleted line, %d extra chars\n", Nskip); */
    9696      } else {
    9797        c = c2;

  • trunk/Ohana/src/opihi/dvo/cmpload.c

    r7680 r7917  
    3232
    3333  if (argc != 3) {
    34     fprintf (stderr, "USAGE: cmpload (overlay) <filename>\n");
     34    gprint (GP_ERR, "USAGE: cmpload (overlay) <filename>\n");
    3535    return (FALSE);
    3636  }
    3737
    3838  if (!gfits_read_header (argv[2], &header)) {
    39     fprintf (stderr, "ERROR: can't read header for %s\n", argv[2]);
     39    gprint (GP_ERR, "ERROR: can't read header for %s\n", argv[2]);
    4040    return (FALSE);
    4141  }
    … …  
    4444  gfits_scan (&header, "NSTARS", "%d", 1, &Nstar);
    4545  if (Nstar == 0) {
    46     fprintf (stderr, "ERROR: can't get NSTARS from header\n");
     46    gprint (GP_ERR, "ERROR: can't get NSTARS from header\n");
    4747    gfits_free_header (&header);
    4848    return (FALSE);
    … …  
    5151  f = fopen (argv[2], "r");
    5252  if (f == NULL) {
    53     fprintf (stderr, "ERROR: can't read data from %s\n", argv[2]);
     53    gprint (GP_ERR, "ERROR: can't read data from %s\n", argv[2]);
    5454    gfits_free_header (&header);
    5555    return (FALSE);
    … …  
    137137  free (buffer);
    138138
    139   fprintf (stderr, "loaded %d objects\n", Noverlay);
     139  gprint (GP_ERR, "loaded %d objects\n", Noverlay);
    140140  return (TRUE);
    141141}

  • trunk/Ohana/src/opihi/dvo/cmpread.c

    r7680 r7917  
    1616
    1717  if (argc != 3) {
    18     fprintf (stderr, "USAGE: cmpread field <filename>\n");
     18    gprint (GP_ERR, "USAGE: cmpread field <filename>\n");
    1919    return (FALSE);
    2020  }
    … …  
    3434  if (!strcasecmp (argv[1], "galmag"))  field = F_GALMAG;
    3535  if (field == F_NONE) {
    36     fprintf (stderr, "invalid cmp field: %s\n", argv[1]);
     36    gprint (GP_ERR, "invalid cmp field: %s\n", argv[1]);
    3737    return (FALSE);
    3838  }
    … …  
    4242  /* load FITS header */
    4343  if (!gfits_read_header (argv[2], &header)) {
    44     fprintf (stderr, "ERROR: can't read header for %s\n", argv[2]);
     44    gprint (GP_ERR, "ERROR: can't read header for %s\n", argv[2]);
    4545    return (FALSE);
    4646  }
    … …  
    4848  if ((field == F_RA) || (field == F_DEC)) {
    4949    if (!GetCoords (&coords, &header)) {
    50       fprintf (stderr, "can't get WCS info from header\n");
     50      gprint (GP_ERR, "can't get WCS info from header\n");
    5151      gfits_free_header (&header);
    5252      return (FALSE);
    … …  
    5757  f = fopen (argv[2], "r");
    5858  if (f == NULL) {
    59     fprintf (stderr, "ERROR: can't read data from %s\n", argv[2]);
     59    gprint (GP_ERR, "ERROR: can't read data from %s\n", argv[2]);
    6060    gfits_free_header (&header);
    6161    return (FALSE);
    … …  
    6565  /* find expected number of stars */
    6666  if (!gfits_scan (&header, "NSTARS", "%d", 1, &Nstars)) {
    67     fprintf (stderr, "ERROR: can't get NSTARS from header\n");
     67    gprint (GP_ERR, "ERROR: can't get NSTARS from header\n");
    6868    gfits_free_header (&header);
    6969    return (FALSE);
    … …  
    7474  gfits_scan (&header, "EXTEND",  "%t", 1, &extend);
    7575  if (extend) {
    76     fprintf (stderr, "reading from FITS cmp file %s\n", argv[2]);
     76    gprint (GP_ERR, "reading from FITS cmp file %s\n", argv[2]);
    7777    Nbytes = gfits_matrix_size (&header);
    7878    fseek (f, Nbytes, SEEK_CUR);
    … …  
    8080  } else {
    8181    /* allocate space for stars */
    82     fprintf (stderr, "reading from TEXT cmp file %s\n", argv[2]);
     82    gprint (GP_ERR, "reading from TEXT cmp file %s\n", argv[2]);
    8383    if (!gfits_scan (&header, "NSTARS", "%d", 1, &Nstars)) {
    84       fprintf (stderr, "ERROR: failed to find NSTARS\n");
     84      gprint (GP_ERR, "ERROR: failed to find NSTARS\n");
    8585      exit (1);
    8686    }
    … …  
    139139  free (stars);
    140140  gfits_free_header (&header);
    141   fprintf (stderr, "loaded %d objects\n", Nstars);
     141  gprint (GP_ERR, "loaded %d objects\n", Nstars);
    142142  return (TRUE);
    143143}

  • trunk/Ohana/src/opihi/dvo/compare.c

    r7680 r7917  
    2222
    2323    if (!(i % 100))
    24       fprintf (stderr, ".");
     24      gprint (GP_ERR, ".");
    2525   
    2626    if (dX <= -radius)

  • trunk/Ohana/src/opihi/dvo/ddmags.c

    r7680 r7917  
    7272    }
    7373    unlock_catalog (&catalog);
    74     // fprintf (stderr, "seaching %s with %d stars\n", catalog.filename, catalog.Naverage);
     74    // gprint (GP_ERR, "seaching %s with %d stars\n", catalog.filename, catalog.Naverage);
    7575    // ListPhotSelections ();
    7676
    … …  
    112112      if (M2 != NULL) free (M2);
    113113    }
    114     // fprintf (stderr, "selected %d stars\n", Npts);
     114    // gprint (GP_ERR, "selected %d stars\n", Npts);
    115115
    116116    if (catalog.average != NULL) free (catalog.average);
    … …  
    126126
    127127usage:
    128   fprintf (stderr, "USAGE: ddmags F - F : measure.param\n");
     128  gprint (GP_ERR, "USAGE: ddmags F - F : measure.param\n");
    129129
    130130escape:

  • trunk/Ohana/src/opihi/dvo/detrend.c

    r7680 r7917  
    2828    remove_argument (N, &argc, argv);
    2929    if (!str_to_time (argv[N], &tzero)) {
    30       fprintf (stderr, "syntax error\n");
     30      gprint (GP_ERR, "syntax error\n");
    3131      return (FALSE);
    3232    }
    3333    remove_argument (N, &argc, argv);
    3434    if (!str_to_dtime (argv[N], &trange)) {
    35       fprintf (stderr, "syntax error\n");
     35      gprint (GP_ERR, "syntax error\n");
    3636      return (FALSE);
    3737    }
    … …  
    4646    remove_argument (N, &argc, argv);
    4747    if (!str_to_time (argv[N], &tzero)) {
    48       fprintf (stderr, "syntax error\n");
     48      gprint (GP_ERR, "syntax error\n");
    4949      return (FALSE);
    5050    }
    5151    remove_argument (N, &argc, argv);
    5252    if (!str_to_time (argv[N], &tend)) {
    53       fprintf (stderr, "syntax error\n");
     53      gprint (GP_ERR, "syntax error\n");
    5454      return (FALSE);
    5555    }
    … …  
    6969    Type = get_image_type (argv[N]);
    7070    if (Type == T_UNDEF) {
    71       fprintf (stderr, "ERROR: invalid image type %s\n", argv[N]);
     71      gprint (GP_ERR, "ERROR: invalid image type %s\n", argv[N]);
    7272      return (FALSE);
    7373    }
    … …  
    9898
    9999  if (argc != 2) {
    100     fprintf (stderr, "USAGE: imrough (value)\n");
    101     return (FALSE);
    102   }
    103   fprintf (stderr, "  this function is not well-defined.  re-work and re-code\n");
     100    gprint (GP_ERR, "USAGE: imrough (value)\n");
     101    return (FALSE);
     102  }
     103  gprint (GP_ERR, "  this function is not well-defined.  re-work and re-code\n");
    104104  return (FALSE);
    105105 
    … …  
    114114  if (!strcasecmp (argv[1], "temp")) mode = TEMP;
    115115  if (mode == ZERO) {
    116     fprintf (stderr, "value may be one of the following:\n");
    117     fprintf (stderr, " exptime, sky, bias, fwhm, airmass, time\n");
     116    gprint (GP_ERR, "value may be one of the following:\n");
     117    gprint (GP_ERR, " exptime, sky, bias, fwhm, airmass, time\n");
    118118    return (FALSE);
    119119  }
    … …  
    123123  /* load in database header */
    124124  if (!gfits_read_header (DataBase, &header)) {
    125     fprintf (stderr, "ERROR: trouble reading database header\n");
     125    gprint (GP_ERR, "ERROR: trouble reading database header\n");
    126126    return (FALSE);
    127127  }
    … …  
    130130  f = fopen (DataBase, "r");
    131131  if (f == (FILE *) NULL) {
    132     fprintf (stderr, "ERROR: can't open Registration Database\n");
     132    gprint (GP_ERR, "ERROR: can't open Registration Database\n");
    133133    return (FALSE);
    134134  }
    … …  
    142142
    143143  if (status != Nimage) {
    144     fprintf (stderr, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     144    gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
    145145    gfits_free_header (&header);
    146146    free (pimage);
    … …  
    155155
    156156  GetTimeFormat (&TimeReference, &TimeFormat);
    157   fprintf (stderr, "%ld %d\n", TimeReference, TimeFormat);
     157  gprint (GP_ERR, "%ld %d\n", TimeReference, TimeFormat);
    158158
    159159  /* get data */

  • trunk/Ohana/src/opihi/dvo/dmagaves.c

    r7680 r7917  
    101101
    102102usage:
    103   fprintf (stderr, "USAGE: dmagaves F - F : average.param\n");
     103  gprint (GP_ERR, "USAGE: dmagaves F - F : average.param\n");
    104104  return (FALSE);
    105105

  • trunk/Ohana/src/opihi/dvo/dmagmeas.c

    r7680 r7917  
    122122
    123123usage:
    124   fprintf (stderr, "USAGE: dmagmeas F - F : measure.param\n");
     124  gprint (GP_ERR, "USAGE: dmagmeas F - F : measure.param\n");
    125125  return (FALSE);
    126126

  • trunk/Ohana/src/opihi/dvo/dmags.c

    r7680 r7917  
    122122
    123123usage:
    124   fprintf (stderr, "USAGE: dmags F - F : F\n");
    125   fprintf (stderr, "    F : any photcodes with matched qualifiers:\n");
    126   fprintf (stderr, "    pri: F:inst, F:cat, F:sys, F:rel, F:cal, F:ave, F:ref\n");
    127   fprintf (stderr, "    sec: F:inst, F:cat, F:sys, F:rel, F:cal, F:ave, F:ref\n");
    128   fprintf (stderr, "    dep: F:inst, F:cat, F:sys, F:rel, F:cal\n");
    129   fprintf (stderr, "    ref: F:cat\n");
     124  gprint (GP_ERR, "USAGE: dmags F - F : F\n");
     125  gprint (GP_ERR, "    F : any photcodes with matched qualifiers:\n");
     126  gprint (GP_ERR, "    pri: F:inst, F:cat, F:sys, F:rel, F:cal, F:ave, F:ref\n");
     127  gprint (GP_ERR, "    sec: F:inst, F:cat, F:sys, F:rel, F:cal, F:ave, F:ref\n");
     128  gprint (GP_ERR, "    dep: F:inst, F:cat, F:sys, F:rel, F:cal\n");
     129  gprint (GP_ERR, "    ref: F:cat\n");
    130130
    131131escape:

  • trunk/Ohana/src/opihi/dvo/dmt.c

    r7680 r7917  
    3232
    3333  if (argc != 3) {
    34     fprintf (stderr, "USAGE: dmags filter\n");
     34    gprint (GP_ERR, "USAGE: dmags filter\n");
    3535    return (FALSE);
    3636  }
    … …  
    4141
    4242  if ((code = GetPhotcodebyName (argv[1])) == NULL) {
    43     fprintf (stderr, "ERROR: photcode not found in photcode table\n");
     43    gprint (GP_ERR, "ERROR: photcode not found in photcode table\n");
    4444    return (FALSE);
    4545  }
    4646  if ((code[0].type != PHOT_SEC) && (code[0].type != PHOT_PRI)) {
    47     fprintf (stderr, "first filter must be a PRIMARY or SECONDARY photometry type\n");
     47    gprint (GP_ERR, "first filter must be a PRIMARY or SECONDARY photometry type\n");
    4848    return (FALSE);
    4949  }

  • trunk/Ohana/src/opihi/dvo/dvo.c

    r7680 r7917  
    1919
    2020  if (!SetCATDIR (NULL, FALSE)) {
    21     fprintf (stderr, "CATDIR is not defined\n");
     21    gprint (GP_ERR, "CATDIR is not defined\n");
    2222  }
    2323
    … …  
    3838/* standard welcome message */
    3939void welcome () {
    40   fprintf (stderr, "\n");
    41   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     40  gprint (GP_ERR, "\n");
     41  gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    4242}
    4343

  • trunk/Ohana/src/opihi/dvo/elixir.c

    r7680 r7917  
    3030 
    3131  if (argc != 2) {
    32     fprintf (stderr, "USAGE: elixir (elixir) [-time] [-live]\n");
     32    gprint (GP_ERR, "USAGE: elixir (elixir) [-time] [-live]\n");
    3333    return (FALSE);
    3434  }
    3535
    3636  if (!VarConfig (argv[1], "%s", ElixirBase)) {
    37     fprintf (stderr, "elixir %s not in config file\n", argv[1]);
     37    gprint (GP_ERR, "elixir %s not in config file\n", argv[1]);
    3838    return (FALSE);
    3939  }
    4040  sprintf (fifo, "%s.msg", ElixirBase);
    4141  if (!VarConfig ("FIFOS", "%s", fifodir)) {
    42     fprintf (stderr, "FIFOS not in config, using local /tmp\n");
     42    gprint (GP_ERR, "FIFOS not in config, using local /tmp\n");
    4343    strcpy (fifodir, "/tmp");
    4444  }
    … …  
    5151
    5252  if (!WriteMsg (fifo, message)) {
    53     fprintf (stderr, "can't access fifo %s\n", fifo);
     53    gprint (GP_ERR, "can't access fifo %s\n", fifo);
    5454    return (FALSE);
    5555  }
    5656
    5757  if (ReadMsg (msgfile, &answer)) {
    58     fprintf (stderr, "%s\n", answer);
     58    gprint (GP_ERR, "%s\n", answer);
    5959  }
    6060  unlink (msgfile);
    … …  
    9696  }
    9797  if (i >= 20) {
    98     fprintf (stderr, "no response\n");
     98    gprint (GP_ERR, "no response\n");
    9999    return (0);
    100100  }
    … …  
    103103  f = fsetlockfile (fifo, 2.0, LCK_XCLD, &state);
    104104  if (f == NULL) {
    105     fprintf (stderr, "message locked (%d)\n", state);
     105    gprint (GP_ERR, "message locked (%d)\n", state);
    106106    return (0);
    107107  }
    … …  
    121121    nbytes = fread (&buffer[Nbytes], 1, 0x1000, f);
    122122    if (nbytes < 0) {
    123       fprintf (stderr, "error in ReadMsg -- got -1 bytes\n");
     123      gprint (GP_ERR, "error in ReadMsg -- got -1 bytes\n");
    124124      return (0);
    125125    }

  • trunk/Ohana/src/opihi/dvo/extract.c

    r7680 r7917  
    6666    remove_argument (N, &argc, argv);
    6767    if ((code = GetPhotcodebyName (argv[N])) == NULL) {
    68       fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", argv[N]);
     68      gprint (GP_ERR, "ERROR: photcode %s not found in photcode table\n", argv[N]);
    6969      return (FALSE);
    7070    }
    … …  
    7373
    7474  if (argc != 3) {
    75     fprintf (stderr, "USAGE: extract (filename) (value) [-g / -a Ncol] \n");
     75    gprint (GP_ERR, "USAGE: extract (filename) (value) [-g / -a Ncol] \n");
    7676    return (FALSE);
    7777  }
    … …  
    9999    if (!strcasecmp (argv[2], "Ncode")) mode = NCODE;
    100100    if (mode == ZERO) {
    101       fprintf (stderr, "value may be one of the following:\n");
    102       fprintf (stderr, " ra dec mag Nmeas Nmiss Xp Xm ID\n");
     101      gprint (GP_ERR, "value may be one of the following:\n");
     102      gprint (GP_ERR, " ra dec mag Nmeas Nmiss Xp Xm ID\n");
    103103      return (FALSE);
    104104    }
    … …  
    106106
    107107  if ((mode == REF) && !PhotcodeSelect) {
    108     fprintf (stderr, "must specify photcode for Reference\n");
     108    gprint (GP_ERR, "must specify photcode for Reference\n");
    109109    return (FALSE);
    110110  }
    111111  if ((mode == TYPE) && !PhotcodeSelect) {
    112     fprintf (stderr, "must specify photcode for Type\n");
     112    gprint (GP_ERR, "must specify photcode for Type\n");
    113113    return (FALSE);
    114114  }
    … …  
    120120    Ns = GetPhotcodeNsec (code[0].code);
    121121    if ((mode != REF) && (code[0].type != PHOT_SEC) && (code[0].type != PHOT_PRI)) {
    122       fprintf (stderr, "filter must be a PRIMARY or SECONDARY photometry type\n");
     122      gprint (GP_ERR, "filter must be a PRIMARY or SECONDARY photometry type\n");
    123123      return (FALSE);
    124124    }
    125125    if ((mode == REF) && (code[0].type != PHOT_REF)) {
    126       fprintf (stderr, "filter must be a REFERENCE photometry type\n");
     126      gprint (GP_ERR, "filter must be a REFERENCE photometry type\n");
    127127      return (FALSE);
    128128    }
    … …  
    138138      mode = MAG;
    139139    if (mode == ZERO) {
    140       fprintf (stderr, "for GSC, value may be one of the following:\n");
    141       fprintf (stderr, " ra dec mag\n");
     140      gprint (GP_ERR, "for GSC, value may be one of the following:\n");
     141      gprint (GP_ERR, " ra dec mag\n");
    142142      return (FALSE);
    143143    }
    … …  
    169169      f = fopen (argv[1], "r");
    170170      if (f == (FILE *) NULL) {
    171         fprintf (stderr, "ERROR: can't open data file: %s\n", argv[1]);
     171        gprint (GP_ERR, "ERROR: can't open data file: %s\n", argv[1]);
    172172        /* delete new vector! */
    173173        return (FALSE);
    … …  
    208208      f = fopen (filename, "r");
    209209      if (f == (FILE *) NULL) {
    210         fprintf (stderr, "no stars in %s, skipping\n", filename);
     210        gprint (GP_ERR, "no stars in %s, skipping\n", filename);
    211211        continue;
    212212      }

  • trunk/Ohana/src/opihi/dvo/find_regions.c

    r7680 r7917  
    1818  f = fopen (filename, "r");
    1919  if (f == NULL) {
    20     fprintf (stderr, "ERROR: can't find regions file %s\n", filename);
     20    gprint (GP_ERR, "ERROR: can't find regions file %s\n", filename);
    2121    *Nregions = 0;
    2222    return ((RegionFile *) NULL);
    … …  
    8282  }
    8383  if (NBigDec < 0) {
    84     fprintf (stderr, "ERROR: Dec out of range: %f\n", minDec);
     84    gprint (GP_ERR, "ERROR: Dec out of range: %f\n", minDec);
    8585    *Nregions = 0;
    8686    return ((RegionFile *) NULL);

  • trunk/Ohana/src/opihi/dvo/fitcolors.c

    r7680 r7917  
    108108  /* determine relevant photcodes, colors */
    109109  if (!(Np = GetPhotcodeCodebyName (argv[2]))) {
    110     fprintf (stderr, "ERROR: photcode not found in photcode table\n");
     110    gprint (GP_ERR, "ERROR: photcode not found in photcode table\n");
    111111    goto usage;
    112112  }
    … …  
    135135    if (codelist[i][0].c2 != codelist[0][0].c2) goto color_mismatch;
    136136  }
    137   fprintf (stderr, "using %d photcodes\n", NP);
     137  gprint (GP_ERR, "using %d photcodes\n", NP);
    138138
    139139  /* output is a named buffer */
    … …  
    185185    // the selection criteria
    186186  }
    187   fprintf (stderr, "using %d possible regions\n", skylist[0].Nregions);
     187  gprint (GP_ERR, "using %d possible regions\n", skylist[0].Nregions);
    188188
    189189  /* vectors to save data */
    … …  
    221221        if (catalog[k].Naverage == 0) continue;
    222222
    223         // fprintf (stderr, "seaching %s with %d stars\n", catalog[k].filename, catalog[k].Naverage);
     223        // gprint (GP_ERR, "seaching %s with %d stars\n", catalog[k].filename, catalog[k].Naverage);
    224224        // ListPhotSelections ();
    225225
    … …  
    259259          if (M2 != NULL) free (M2);
    260260        }
    261         // fprintf (stderr, "selected %d stars\n", Npts);
     261        // gprint (GP_ERR, "selected %d stars\n", Npts);
    262262      }
    263263
    … …  
    275275     
    276276      /* do something useful with the results (stored in Cn, C0, C1, etc) */
    277       fprintf (GetOutfile(), "%s - %s : ", code[0][0].name, code[1][0].name);
    278       fprintf (GetOutfile(), "%7.4f %7.4f   %7.4f   ",
     277      gprint (GP_LOG, "%s - %s : ", code[0][0].name, code[1][0].name);
     278      gprint (GP_LOG, "%7.4f %7.4f   %7.4f   ",
    279279               C0, C1, get_double_variable ("dC"));
    280       fprintf (GetOutfile(), "%5s of %5d\n", get_variable ("Cnv"), Npts);
     280      gprint (GP_LOG, "%5s of %5d\n", get_variable ("Cnv"), Npts);
    281281      out[NP1 + NP2*NP] = C1;
    282282
    … …  
    369369
    370370usage:
    371   fprintf (stderr, "USAGE: chipcolors (output) (photcode) (camera)\n");
     371  gprint (GP_ERR, "USAGE: chipcolors (output) (photcode) (camera)\n");
    372372  goto escape;
    373373
    374374color_missing:
    375   fprintf (stderr, "error: chips are missing a color reference\n");
     375  gprint (GP_ERR, "error: chips are missing a color reference\n");
    376376  goto escape;
    377377
    378378color_mismatch:
    379   fprintf (stderr, "error: all chips must have the same colors\n");
     379  gprint (GP_ERR, "error: all chips must have the same colors\n");
    380380  goto escape;
    381381

  • trunk/Ohana/src/opihi/dvo/fitsed.c

    r7892 r7917  
    187187  /* loop over regions, extract data for each region */
    188188  // XXX add interrupt checks
    189   fprintf (stderr, "using %d possible regions\n", skylist[0].Nregions);
     189  gprint (GP_ERR, "using %d possible regions\n", skylist[0].Nregions);
    190190  for (k = 0; k < skylist[0].Nregions; k++) {
    191191    /* lock, load, unlock catalog */
    … …  
    326326        KiiCursorOn (fd);
    327327        while (KiiCursorRead (fd, &X, &Y, key)) {
    328           fprintf (stderr, "window: %f %f (%s)\n", X, Y, key);
     328          gprint (GP_ERR, "window: %f %f (%s)\n", X, Y, key);
    329329          if (!strcasecmp (key, "Q")) {
    330330            KiiCursorOff (fd);
    … …  
    343343    unlock_catalog (&catalog);
    344344  }
    345   fprintf (stderr, "fitted %d stars\n", Nfit);
     345  gprint (GP_ERR, "fitted %d stars\n", Nfit);
    346346  status = TRUE;
    347347  goto finish;
    348348 
    349349usage:
    350   fprintf (stderr, "USAGE: fitset (sedtable) : (F) - (F)\n");
     350  gprint (GP_ERR, "USAGE: fitset (sedtable) : (F) - (F)\n");
    351351  goto escape;
    352352
    353353table_missing:
    354   fprintf (stderr, "ERROR: can't open the SED table\n");
     354  gprint (GP_ERR, "ERROR: can't open the SED table\n");
    355355  goto escape;
    356356
    357357color_missing:
    358   fprintf (stderr, "ERROR: reference color not in SED table\n");
     358  gprint (GP_ERR, "ERROR: reference color not in SED table\n");
    359359  goto escape;
    360360
    361361color_undefined:
    362   fprintf (stderr, "ERROR: undefined photcode in reference color\n");
     362  gprint (GP_ERR, "ERROR: undefined photcode in reference color\n");
    363363  goto escape;
    364364
    365365code_missing:
    366   fprintf (stderr, "ERROR: undefined photcode in SED table\n");
     366  gprint (GP_ERR, "ERROR: undefined photcode in SED table\n");
    367367  goto escape;
    368368

  • trunk/Ohana/src/opihi/dvo/gcat.c

    r7680 r7917  
    1010
    1111  if ((argc != 3) && (argc != 4)) {
    12     fprintf (stderr, "USAGE: gcat RA DEC [Radius]\n");
     12    gprint (GP_ERR, "USAGE: gcat RA DEC [Radius]\n");
    1313    return (FALSE);
    1414  }
    … …  
    2727  for (i = 0; i < skylist[0].Nregions; i++) {
    2828    if (stat (skylist[0].filename[i], &filestat) != -1) {
    29       fprintf (stderr, "%3d %s *\n", i, skylist[0].regions[i][0].name);
     29      gprint (GP_ERR, "%3d %s *\n", i, skylist[0].regions[i][0].name);
    3030    } else {
    31       fprintf (stderr, "%3d %s\n", i, skylist[0].regions[i][0].name);
     31      gprint (GP_ERR, "%3d %s\n", i, skylist[0].regions[i][0].name);
    3232    }
    3333    set_str_variable ("CATNAME", skylist[0].filename[i]);

  • trunk/Ohana/src/opihi/dvo/get_regions.c

    r7680 r7917  
    1515  f = fopen (filename, "r");
    1616  if (f == NULL) {
    17     fprintf (stderr, "ERROR: can't find GSC region file %s\n", filename);
     17    gprint (GP_ERR, "ERROR: can't find GSC region file %s\n", filename);
    1818    exit (0);
    1919  }

  • trunk/Ohana/src/opihi/dvo/getxtra.c

    r7680 r7917  
    3737
    3838  if (argc != 6) {
    39     fprintf (stderr, "USAGE: addxtra R D radius (type) (value)\n");
     39    gprint (GP_ERR, "USAGE: addxtra R D radius (type) (value)\n");
    4040    return (FALSE);
    4141  }

  • trunk/Ohana/src/opihi/dvo/gimages.c

    r7680 r7917  
    2121    remove_argument (N, &argc, argv);
    2222    if (!str_to_time (argv[N], &tzero)) {
    23       fprintf (stderr, "syntax error\n");
     23      gprint (GP_ERR, "syntax error\n");
    2424      return (FALSE);
    2525    }
    2626    remove_argument (N, &argc, argv);
    2727    if (!str_to_dtime (argv[N], &trange)) {
    28       fprintf (stderr, "syntax error\n");
     28      gprint (GP_ERR, "syntax error\n");
    2929      return (FALSE);
    3030    }
    … …  
    4141
    4242    if (!str_to_dtime (argv[N], &trange)) {
    43       fprintf (stderr, "syntax error\n");
     43      gprint (GP_ERR, "syntax error\n");
    4444      return (FALSE);
    4545    }
    … …  
    5252    remove_argument (N, &argc, argv);
    5353    if ((code = GetPhotcodebyName (argv[N])) == NULL) {
    54       fprintf (stderr, "ERROR: photcode not found in photcode table\n");
     54      gprint (GP_ERR, "ERROR: photcode not found in photcode table\n");
    5555      return (FALSE);
    5656    }
    … …  
    6666
    6767  if (argc != 3) {
    68     fprintf (stderr, "USAGE: gimages RA DEC [-time t dt] [-pix]\n");
     68    gprint (GP_ERR, "USAGE: gimages RA DEC [-time t dt] [-pix]\n");
    6969    return (FALSE);
    7070  }
    … …  
    103103
    104104    if (PixelCoords) {
    105       fprintf (GetOutfile(), "%3d %s %6.1f %6.1f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n",
     105      gprint (GP_LOG, "%3d %s %6.1f %6.1f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n",
    106106               Nfound, image[i].name, X, Y, date, image[i].nstar, image[i].source, image[i].secz_PS, image[i].Mcal_PS, image[i].dMcal_PS, image[i].exptime, image[i].code);
    107107    } else {
    108108      XY_to_RD (&ra, &dec, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    109       fprintf (GetOutfile(), "%3d %s %8.4f %8.4f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n",
     109      gprint (GP_LOG, "%3d %s %8.4f %8.4f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n",
    110110               Nfound, image[i].name, ra, dec, date, image[i].nstar, image[i].source, image[i].secz_PS, image[i].Mcal_PS, image[i].dMcal_PS, image[i].exptime, image[i].code);
    111111    }

  • trunk/Ohana/src/opihi/dvo/gstar.c

    r7680 r7917  
    11# include "dvoshell.h"
    22
    3 void print_value (FILE *f, double value, short int ival);
     3void print_value (double value, short int ival);
    44void initPhotcodeSequence (int Nsec);
    55void freePhotcodeSequence ();
    … …  
    5050
    5151  if (argc != 4) {
    52     fprintf (stderr, "USAGE: gstar RA DEC Radius [-m]\n");
     52    gprint (GP_ERR, "USAGE: gstar RA DEC Radius [-m]\n");
    5353    return (FALSE);
    5454  }
    … …  
    6868
    6969  if (skylist[0].Nregions > 1) {
    70     fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
     70    gprint (GP_ERR, "warning, radius overlaps region boundary, not yet implemented\n");
    7171  }
    7272
    … …  
    142142      k = N1[i];
    143143      if (!QUIET) {
    144         fprintf (GetOutfile(), "star: %d\n", k);
    145         fprintf (GetOutfile(), "%9.5f %9.5f %3d of %3d  %4.1f %5d\n", catalog.average[k].R, catalog.average[k].D,
     144        gprint (GP_LOG, "star: %d\n", k);
     145        gprint (GP_LOG, "%9.5f %9.5f %3d of %3d  %4.1f %5d\n", catalog.average[k].R, catalog.average[k].D,
    146146                 catalog.average[k].Nm, catalog.average[k].Nn + catalog.average[k].Nm,
    147147                 0.01*catalog.average[k].Xp, catalog.average[k].code);
    … …  
    149149        /* filter names */
    150150        for (j = 0; j < Nsec + 1; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsec*k], j, 3);
    151         fprintf (GetOutfile (), "\n");
     151        gprint (GP_LOG, "\n");
    152152
    153153        /* average mags */
    154154        for (j = 0; j < Nsec + 1; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsec*k], j, 0);
    155         fprintf (GetOutfile(), "\n");
     155        gprint (GP_LOG, "\n");
    156156
    157157        /* average mag errors */
    158158        for (j = 0; j < Nsec + 1; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsec*k], j, 1);
    159         fprintf (GetOutfile(), "\n");
     159        gprint (GP_LOG, "\n");
    160160
    161161        /* average mag chisq */
    162162        for (j = 0; j < Nsec + 1; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsec*k], j, 2);
    163         fprintf (GetOutfile(), "\n");
     163        gprint (GP_LOG, "\n");
    164164      }
    165165
    … …  
    173173          if (GetMeasures && !QUIET) {
    174174            date = sec_to_date (catalog.measure[m].t);
    175             fprintf (GetOutfile(), "%6.3f %6.3f %5.3f  %20s  %5.2f %5.2f %2d %3x %3d %-20s\n",
     175            gprint (GP_LOG, "%6.3f %6.3f %5.3f  %20s  %5.2f %5.2f %2d %3x %3d %-20s\n",
    176176                     Mcat, Mrel, catalog.measure[m].dM_PS,
    177177                     date, catalog.measure[m].dR_PS, catalog.measure[m].dD_PS,
    … …  
    219219}
    220220
    221 void print_value (FILE *f, double value, short int ival) {
     221void print_value (double value, short int ival) {
    222222  if (ival == NO_MAG)
    223     fprintf (f, "NaN    ");
     223    gprint (GP_LOG, "NaN    ");
    224224  else
    225     fprintf (f, "%6.3f ", value);
     225    gprint (GP_LOG, "%6.3f ", value);
    226226}
    227227
    … …  
    265265    case 0: /* average mags */
    266266      if (seq == -1) {
    267         print_value (GetOutfile(), average[0].M, average[0].M);
     267        print_value (average[0].M, average[0].M);
    268268      } else {
    269         print_value (GetOutfile(), secfilt[seq].M_PS, secfilt[seq].M_PS);
     269        print_value (secfilt[seq].M_PS, secfilt[seq].M_PS);
    270270      }
    271271      break;
    … …  
    273273    case 1: /* average mags errors */
    274274      if (seq == -1) {
    275         print_value (GetOutfile(), average[0].dM, average[0].dM);
     275        print_value (average[0].dM, average[0].dM);
    276276      } else {
    277         print_value (GetOutfile(), secfilt[seq].dM_PS, secfilt[seq].dM_PS);
     277        print_value (secfilt[seq].dM_PS, secfilt[seq].dM_PS);
    278278      }
    279279      break;
    … …  
    281281    case 2: /* average mag chisq */
    282282      if (seq == -1) {
    283         print_value (GetOutfile(), pow (10.0, 0.01*average[0].Xm), average[0].Xm);
     283        print_value (pow (10.0, 0.01*average[0].Xm), average[0].Xm);
    284284      } else {
    285         print_value (GetOutfile(), pow (10.0, 0.01*secfilt[seq].Xm), secfilt[seq].Xm);
     285        print_value (pow (10.0, 0.01*secfilt[seq].Xm), secfilt[seq].Xm);
    286286      }
    287287      break;
    … …  
    289289    case 3: /* filter names */
    290290      code = GetPhotcodebyNsec (seq + 1);
    291       fprintf (GetOutfile (), "%6s ", code[0].name);
    292       break;
    293   }
    294 }
     291      gprint (GP_LOG, "%6s ", code[0].name);
     292      break;
     293  }
     294}

  • trunk/Ohana/src/opihi/dvo/images.c

    r7680 r7917  
    2626    remove_argument (N, &argc, argv);
    2727    if (!str_to_time (argv[N], &tzero)) {
    28       fprintf (stderr, "syntax error\n");
     28      gprint (GP_ERR, "syntax error\n");
    2929      return (FALSE);
    3030    }
    3131    remove_argument (N, &argc, argv);
    3232    if (!str_to_dtime (argv[N], &trange)) {
    33       fprintf (stderr, "syntax error\n");
     33      gprint (GP_ERR, "syntax error\n");
    3434      return (FALSE);
    3535    }
    … …  
    4444    remove_argument (N, &argc, argv);
    4545    if (!str_to_time (argv[N], &tzero)) {
    46       fprintf (stderr, "syntax error\n");
     46      gprint (GP_ERR, "syntax error\n");
    4747      return (FALSE);
    4848    }
    4949    remove_argument (N, &argc, argv);
    5050    if (!str_to_time (argv[N], &tend)) {
    51       fprintf (stderr, "syntax error\n");
     51      gprint (GP_ERR, "syntax error\n");
    5252      return (FALSE);
    5353    }
    … …  
    6262 
    6363  if (argc != 1) {
    64     fprintf (stderr, "USAGE: image [-time start range]\n");
     64    gprint (GP_ERR, "USAGE: image [-time start range]\n");
    6565    return (FALSE);
    6666  }
    … …  
    143143  }
    144144
    145   fprintf (stderr, "plotting %d images\n", N/8);
     145  gprint (GP_ERR, "plotting %d images\n", N/8);
    146146  Xvec.Nelements = Xvec.Nelements = N;
    147147  if (N > 0) {

  • trunk/Ohana/src/opihi/dvo/imbox.c

    r7680 r7917  
    1313
    1414  if (argc != 2) {
    15     fprintf (stderr, "USAGE: imbox (filename)\n");
     15    gprint (GP_ERR, "USAGE: imbox (filename)\n");
    1616    return (FALSE);
    1717  }
    … …  
    1919
    2020  if (!gfits_read_header (argv[1], &header)) {
    21     fprintf (stderr, "file not found\n");
     21    gprint (GP_ERR, "file not found\n");
    2222    return (FALSE);
    2323  }
    … …  
    4141    }
    4242    if (!GetCoords (&coords, &header)) {
    43       fprintf (stderr, "can't get WCS info from header\n");
     43      gprint (GP_ERR, "can't get WCS info from header\n");
    4444      return (TRUE);
    4545    }

  • trunk/Ohana/src/opihi/dvo/imdata.c

    r7680 r7917  
    2020    remove_argument (N, &argc, argv);
    2121    if (!str_to_time (argv[N], &tzero)) {
    22       fprintf (stderr, "syntax error\n");
     22      gprint (GP_ERR, "syntax error\n");
    2323      return (FALSE);
    2424    }
    2525    remove_argument (N, &argc, argv);
    2626    if (!str_to_dtime (argv[N], &trange)) {
    27       fprintf (stderr, "syntax error\n");
     27      gprint (GP_ERR, "syntax error\n");
    2828      return (FALSE);
    2929    }
    3030    remove_argument (N, &argc, argv);
    3131    TimeSelect = TRUE;
    32     fprintf (stderr, "searching in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange);
     32    gprint (GP_ERR, "searching in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange);
    3333    if (trange > 0) {
    3434      start = tzero;
    … …  
    4141
    4242  if (argc != 4) {
    43     fprintf (stderr, "USAGE: imdata (value) [-time t dt]\n");
     43    gprint (GP_ERR, "USAGE: imdata (value) [-time t dt]\n");
    4444    return (FALSE);
    4545  }
    … …  
    6868    mode = 10;
    6969  if (mode == 0) {
    70     fprintf (stderr, "value may be one of the following:\n");
    71     fprintf (stderr, " ra dR dec dD mag dmag Mrel Mcal source time\n");
     70    gprint (GP_ERR, "value may be one of the following:\n");
     71    gprint (GP_ERR, " ra dR dec dD mag dmag Mrel Mcal source time\n");
    7272    return (FALSE);
    7373  }
    … …  
    108108  free (subset);
    109109  for (i = 0; i < skylist[0].Nregions; i++) {
    110     fprintf (stderr, "try %s\n", skylist[0].regions[i][0].name);
     110    gprint (GP_ERR, "try %s\n", skylist[0].regions[i][0].name);
    111111  }
    112112 

  • trunk/Ohana/src/opihi/dvo/imdense.c

    r7680 r7917  
    1414  /* also, option to list and not plot or plot and not list images */
    1515  if (argc != 1) {
    16     fprintf (stderr, "USAGE: image\n");
     16    gprint (GP_ERR, "USAGE: image\n");
    1717    return (FALSE);
    1818  }

  • trunk/Ohana/src/opihi/dvo/imextract.c

    r7680 r7917  
    2424    remove_argument (N, &argc, argv);
    2525    if (!str_to_time (argv[N], &tzero)) {
    26       fprintf (stderr, "syntax error\n");
     26      gprint (GP_ERR, "syntax error\n");
    2727      return (FALSE);
    2828    }
    2929    remove_argument (N, &argc, argv);
    3030    if (!str_to_dtime (argv[N], &trange)) {
    31       fprintf (stderr, "syntax error\n");
     31      gprint (GP_ERR, "syntax error\n");
    3232      return (FALSE);
    3333    }
    … …  
    6060    remove_argument (N, &argc, argv);
    6161    if ((code = GetPhotcodebyName (argv[N])) == NULL) {
    62       fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", argv[N]);
     62      gprint (GP_ERR, "ERROR: photcode %s not found in photcode table\n", argv[N]);
    6363      return (FALSE);
    6464    }
    6565    if ((code[0].type != PHOT_PRI) && (code[0].type != PHOT_SEC) && (code[0].type != PHOT_DEP)) {
    66       fprintf (stderr, "photcode must be primary, secondary, or dependent code\n");
     66      gprint (GP_ERR, "photcode must be primary, secondary, or dependent code\n");
    6767      return (FALSE);
    6868    }
    … …  
    7171
    7272  if (argc != 2) {
    73     fprintf (stderr, "USAGE: imextract (value) [-region] [-time start range] [-photcode photcode]\n");
     73    gprint (GP_ERR, "USAGE: imextract (value) [-region] [-time start range] [-photcode photcode]\n");
    7474    return (FALSE);
    7575  }
    … …  
    9292  if (!strcasecmp (argv[1], "flag")) mode = FLAG;
    9393  if (mode == ZERO) {
    94     fprintf (stderr, "value may be one of the following:\n");
    95     fprintf (stderr, " ra dec airmass Mcal dMcal Xm photcode time fwhm exptime nstar ncal sky flag\n");
     94    gprint (GP_ERR, "value may be one of the following:\n");
     95    gprint (GP_ERR, " ra dec airmass Mcal dMcal Xm photcode time fwhm exptime nstar ncal sky flag\n");
    9696    return (FALSE);
    9797  }

  • trunk/Ohana/src/opihi/dvo/imlist.c

    r7680 r7917  
    2020    remove_argument (N, &argc, argv);
    2121    if (!str_to_time (argv[N], &tzero)) {
    22       fprintf (stderr, "syntax error\n");
     22      gprint (GP_ERR, "syntax error\n");
    2323      return (FALSE);
    2424    }
    2525    remove_argument (N, &argc, argv);
    2626    if (!str_to_dtime (argv[N], &trange)) {
    27       fprintf (stderr, "syntax error\n");
     27      gprint (GP_ERR, "syntax error\n");
    2828      return (FALSE);
    2929    }
    3030    remove_argument (N, &argc, argv);
    3131    TimeSelect = TRUE;
    32     fprintf (stderr, "plotting in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange);
     32    gprint (GP_ERR, "plotting in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange);
    3333  }
    3434
    … …  
    4646    PhotcodeValue = GetPhotcodebyName (argv[N]);
    4747    if (PhotcodeValue == NULL) {
    48       fprintf (stderr, "photcode not found in photcode table\n");
     48      gprint (GP_ERR, "photcode not found in photcode table\n");
    4949      return (FALSE);
    5050    }
    … …  
    6262
    6363  if (argc != 1) {
    64     fprintf (stderr, "USAGE: image [-time start range] [-region] [-name string]\n");
     64    gprint (GP_ERR, "USAGE: image [-time start range] [-region] [-name string]\n");
    6565    return (FALSE);
    6666  }
    … …  
    8585    t = TimeValue (image[i].tzero, TimeReference, TimeFormat);
    8686    XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    87     fprintf (GetOutfile(), "%3d %s %8.4f %8.4f %f %5d %2d %4.2f %5.3f %5.3f\n",
     87    gprint (GP_LOG, "%3d %s %8.4f %8.4f %f %5d %2d %4.2f %5.3f %5.3f\n",
    8888             i, image[i].name, r, d, t, image[i].nstar, image[i].source, image[i].secz_PS, image[i].Mcal_PS, image[i].dMcal_PS);
    8989  }

  • trunk/Ohana/src/opihi/dvo/imphot.c

    r7680 r7917  
    2222
    2323  if (argc != 3) {
    24     fprintf (stderr, "USAGE: imphot tzero trange [-g buffer]\n");
     24    gprint (GP_ERR, "USAGE: imphot tzero trange [-g buffer]\n");
    2525    return (FALSE);
    2626  }
    … …  
    4343  /* load image(s) in time range given */
    4444  if (!str_to_time (argv[1], &tzero)) {
    45     fprintf (stderr, "syntax error\n");
     45    gprint (GP_ERR, "syntax error\n");
    4646    return (FALSE);
    4747  }
    4848  if (!str_to_dtime (argv[2], &trange)) {
    49     fprintf (stderr, "syntax error\n");
     49    gprint (GP_ERR, "syntax error\n");
    5050    return (FALSE);
    5151  }   
    52   fprintf (stderr, "searching in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange);
     52  gprint (GP_ERR, "searching in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange);
    5353 
    5454  if ((image = LoadImages (&Nimage)) == NULL) return (FALSE);
    … …  
    5656
    5757  if ((Nsubset > 1) && GreyScale) {
    58     fprintf (stderr, "more than one image selected, making GreyScale of first only\n");
     58    gprint (GP_ERR, "more than one image selected, making GreyScale of first only\n");
    5959  }
    6060
    … …  
    7474    switch (image[i].order) {
    7575    case 0:
    76       fprintf (stderr, "%s: %d - %f\n", image[i].name, image[i].order, image[i].Mcal_PS);
     76      gprint (GP_ERR, "%s: %d - %f\n", image[i].name, image[i].order, image[i].Mcal_PS);
    7777      break;
    7878    case 1:
    79       fprintf (stderr, "%s: %d - %f, %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My);
     79      gprint (GP_ERR, "%s: %d - %f, %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My);
    8080      break;
    8181    case 2:
    82       fprintf (stderr, "%s: %d - %f, %d %d, %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My, image[i].Mxx, image[i].Mxy, image[i].Myy);
     82      gprint (GP_ERR, "%s: %d - %f, %d %d, %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My, image[i].Mxx, image[i].Mxy, image[i].Myy);
    8383      break;
    8484    case 3:
    85       fprintf (stderr, "%s: %d - %f, %d %d, %d %d %d, %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My,
     85      gprint (GP_ERR, "%s: %d - %f, %d %d, %d %d %d, %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My,
    8686               image[i].Mxx, image[i].Mxy, image[i].Myy, image[i].Mxxx, image[i].Mxxy, image[i].Mxyy, image[i].Myyy);
    8787      break;
    8888    case 4:
    89       fprintf (stderr, "%s: %d - %f, %d %d, %d %d %d, %d %d %d %d, %d %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My,
     89      gprint (GP_ERR, "%s: %d - %f, %d %d, %d %d %d, %d %d %d %d, %d %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My,
    9090               image[i].Mxx, image[i].Mxy, image[i].Myy, image[i].Mxxx, image[i].Mxxy, image[i].Mxyy, image[i].Myyy,
    9191               image[i].Mxxxx, image[i].Mxxxy, image[i].Mxxyy, image[i].Mxyyy, image[i].Myyyy);

  • trunk/Ohana/src/opihi/dvo/imrough.c

    r7680 r7917  
    2424    remove_argument (N, &argc, argv);
    2525    if (!str_to_time (argv[N], &tzero)) {
    26       fprintf (stderr, "syntax error\n");
     26      gprint (GP_ERR, "syntax error\n");
    2727      return (FALSE);
    2828    }
    2929    remove_argument (N, &argc, argv);
    3030    if (!str_to_dtime (argv[N], &trange)) {
    31       fprintf (stderr, "syntax error\n");
     31      gprint (GP_ERR, "syntax error\n");
    3232      return (FALSE);
    3333    }
    … …  
    4242    remove_argument (N, &argc, argv);
    4343    if (!str_to_time (argv[N], &tzero)) {
    44       fprintf (stderr, "syntax error\n");
     44      gprint (GP_ERR, "syntax error\n");
    4545      return (FALSE);
    4646    }
    4747    remove_argument (N, &argc, argv);
    4848    if (!str_to_time (argv[N], &tend)) {
    49       fprintf (stderr, "syntax error\n");
     49      gprint (GP_ERR, "syntax error\n");
    5050      return (FALSE);
    5151    }
    … …  
    6666    type = get_image_type (argv[N]);
    6767    if (type == T_UNDEF) {
    68       fprintf (stderr, "ERROR: invalid image type %s\n", argv[N]);
     68      gprint (GP_ERR, "ERROR: invalid image type %s\n", argv[N]);
    6969      return (FALSE);
    7070    }
    … …  
    7979    mode = get_image_mode (argv[N]);
    8080    if (mode == M_UNDEF) {
    81       fprintf (stderr, "ERROR: invalid image mode %s\n", argv[N]);
     81      gprint (GP_ERR, "ERROR: invalid image mode %s\n", argv[N]);
    8282      return (FALSE);
    8383    }
    … …  
    107107
    108108  if (argc != 2) {
    109     fprintf (stderr, "USAGE: imrough (value)\n");
    110     fprintf (stderr, "       value options:\n");
     109    gprint (GP_ERR, "USAGE: imrough (value)\n");
     110    gprint (GP_ERR, "       value options:\n");
    111111    for (i = 1; i < NVALUE; i++) {
    112       fprintf (stderr, "%s\n", valuename[i]);
     112      gprint (GP_ERR, "%s\n", valuename[i]);
    113113    }
    114114    return (FALSE);
    … …  
    121121  }
    122122  if (value == V_NONE) {
    123     fprintf (stderr, "ERROR: invalid image value %s\n", argv[1]);
     123    gprint (GP_ERR, "ERROR: invalid image value %s\n", argv[1]);
    124124    return (FALSE);
    125125  }
    … …  
    244244  f = fopen (DataBase, "r");
    245245  if (f == (FILE *) NULL) {
    246     fprintf (stderr, "ERROR: can't open Registration Database\n");
     246    gprint (GP_ERR, "ERROR: can't open Registration Database\n");
    247247    return ((RegImage *) NULL);
    248248  }
    … …  
    252252    fclose (f);
    253253    gfits_free_header (&header);
    254     fprintf (stderr, "ERROR: trouble reading database header\n");
     254    gprint (GP_ERR, "ERROR: trouble reading database header\n");
    255255    return ((RegImage *) NULL);
    256256  }
    … …  
    269269   
    270270    if (status != Nimage) {
    271       fprintf (stderr, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     271      gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
    272272      gfits_free_header (&header);
    273273      free (image);
    … …  
    285285    gfits_free_header (&header);
    286286    gfits_free_matrix (&matrix);
    287     fprintf (stderr, "ERROR: trouble reading database matrix\n");
     287    gprint (GP_ERR, "ERROR: trouble reading database matrix\n");
    288288    return ((RegImage *) NULL);
    289289  }
    … …  
    294294    gfits_free_header (&header);
    295295    gfits_free_matrix (&matrix);
    296     fprintf (stderr, "ERROR: trouble reading database table\n");
     296    gprint (GP_ERR, "ERROR: trouble reading database table\n");
    297297    return ((RegImage *) NULL);
    298298  }

  • trunk/Ohana/src/opihi/dvo/imsearch.c

    r7680 r7917  
    2626    remove_argument (N, &argc, argv);
    2727    if (!str_to_time (argv[N], &tzero)) {
    28       fprintf (stderr, "syntax error\n");
     28      gprint (GP_ERR, "syntax error\n");
    2929      return (FALSE);
    3030    }
    3131    remove_argument (N, &argc, argv);
    3232    if (!str_to_dtime (argv[N], &trange)) {
    33       fprintf (stderr, "syntax error\n");
     33      gprint (GP_ERR, "syntax error\n");
    3434      return (FALSE);
    3535    }
    … …  
    4444    Type = get_image_type (argv[N]);
    4545    if (Type == T_UNDEF) {
    46       fprintf (stderr, "ERROR: invalid image type %s\n", argv[N]);
     46      gprint (GP_ERR, "ERROR: invalid image type %s\n", argv[N]);
    4747      return (FALSE);
    4848    }
    … …  
    5757    Mode = get_image_mode (argv[N]);
    5858    if (Mode == M_UNDEF) {
    59       fprintf (stderr, "ERROR: invalid image mode %s\n", argv[N]);
     59      gprint (GP_ERR, "ERROR: invalid image mode %s\n", argv[N]);
    6060      exit (1);
    6161    }
    … …  
    8686
    8787  if (argc != 1) {
    88     fprintf (stderr, "USAGE: imsearch [-time start range] [-type type] [-mode mode] [-ccd N] [-filter name]\n");
     88    gprint (GP_ERR, "USAGE: imsearch [-time start range] [-type type] [-mode mode] [-ccd N] [-filter name]\n");
    8989    exit (1);
    9090  }
    … …  
    9292  /* load in database header */
    9393  if (!gfits_read_header (DataBase, &header)) {
    94     fprintf (stderr, "ERROR: trouble reading database header\n");
     94    gprint (GP_ERR, "ERROR: trouble reading database header\n");
    9595    return (FALSE);
    9696  }
    … …  
    9999  f = fopen (DataBase, "r");
    100100  if (f == (FILE *) NULL) {
    101     fprintf (stderr, "ERROR: can't open Registration Database\n");
     101    gprint (GP_ERR, "ERROR: can't open Registration Database\n");
    102102    return (FALSE);
    103103  }
    … …  
    110110  fclose (f);
    111111  if (status != Nimage) {
    112     fprintf (stderr, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     112    gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
    113113    gfits_free_header (&header);
    114114    free (pimage);
    … …  
    129129    obstime[strlen(obstime)-1] = 0;
    130130
    131     fprintf (stdout, "%5d %6s %6s %2d %2d   ", i, get_type_name(pimage[i].type), get_mode_name(pimage[i].mode), pimage[i].ccd, pimage[i].type);
    132     fprintf (stdout, "%s %s  ", pimage[i].pathname, pimage[i].filename);
    133     fprintf (stdout, "%s %s %f %s\n", pimage[i].filter, pimage[i].instrument, pimage[i].exptime, obstime);
     131    gprint (GP_LOG, "%5d %6s %6s %2d %2d   ", i, get_type_name(pimage[i].type), get_mode_name(pimage[i].mode), pimage[i].ccd, pimage[i].type);
     132    gprint (GP_LOG, "%s %s  ", pimage[i].pathname, pimage[i].filename);
     133    gprint (GP_LOG, "%s %s %f %s\n", pimage[i].filter, pimage[i].instrument, pimage[i].exptime, obstime);
    134134
    135135    if (SaveNames) {

  • trunk/Ohana/src/opihi/dvo/imstats.c

    r7680 r7917  
    3131
    3232  if (argc != 1) {
    33     fprintf (stderr, "USAGE: imstats [-dM] [-l]\n");
     33    gprint (GP_ERR, "USAGE: imstats [-dM] [-l]\n");
    3434    return (FALSE);
    3535  }
    … …  
    4343  ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    4444  ALLOCATE (Yvec.elements, float, Yvec.Nelements);
    45   fprintf (stdout, "seq  ra (J2000) dec    time (s)   Nstars\n");
     45  gprint (GP_LOG, "seq  ra (J2000) dec    time (s)   Nstars\n");
    4646  for (i = 0; i < Nimage; i++) {
    4747    Xvec.elements[i] = image[i].secz_PS;
    … …  
    5252    if (!FindMosaicForImage (image, Nimage, i)) continue;
    5353    XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    54     fprintf (stderr, "%d %8.4f %8.4f %10d %6d  %5.3f %6.3f %6.3f\n",
     54    gprint (GP_ERR, "%d %8.4f %8.4f %10d %6d  %5.3f %6.3f %6.3f\n",
    5555             i, r, d, image[i].tzero, image[i].nstar, Xvec.elements[i],
    5656             image[i].Mcal_PS, image[i].dMcal_PS);

  • trunk/Ohana/src/opihi/dvo/lcat.c

    r7680 r7917  
    2121  }
    2222  if (argc != 1) {
    23     fprintf (stderr, "USAGE: lcat [-all]\n");
     23    gprint (GP_ERR, "USAGE: lcat [-all]\n");
    2424    return (FALSE);
    2525  }
    … …  
    3535    if (stat (skylist[0].filename[i], &filestat) == -1) exists = 'N';
    3636    if (ShowAll) {
    37       fprintf (stderr, "%3d %s  %c\n", i, skylist[0].regions[i][0].name, exists);
     37      gprint (GP_ERR, "%3d %s  %c\n", i, skylist[0].regions[i][0].name, exists);
    3838    } else {
    3939      if (exists == 'Y') {
    40         fprintf (stderr, "%3d %s\n", i, skylist[0].regions[i][0].name);
     40        gprint (GP_ERR, "%3d %s\n", i, skylist[0].regions[i][0].name);
    4141      }
    4242    }

  • trunk/Ohana/src/opihi/dvo/lcurve.c

    r7680 r7917  
    5353  GalMag = FALSE;
    5454  if ((N = get_argument (argc, argv, "-gal"))) {
    55     fprintf (stderr, "galaxy magnitudes currently disabled\n");
     55    gprint (GP_ERR, "galaxy magnitudes currently disabled\n");
    5656    return (FALSE);
    5757  }
    … …  
    6464
    6565  if (argc < 4) {
    66     fprintf (stderr, "USAGE: lcurve RA DEC Radius\n");
     66    gprint (GP_ERR, "USAGE: lcurve RA DEC Radius\n");
    6767    return (FALSE);
    6868  }
    … …  
    7777
    7878  if (skylist[0].Nregions > 1) {
    79     fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
     79    gprint (GP_ERR, "warning, radius overlaps region boundary, not yet implemented\n");
    8080  }
    8181

  • trunk/Ohana/src/opihi/dvo/lightcurve.c

    r7680 r7917  
    3333    remove_argument (N, &argc, argv);
    3434    if ((code = GetPhotcodebyName (argv[N])) == NULL) {
    35       fprintf (stderr, "ERROR: photcode not found in photcode table\n");
     35      gprint (GP_ERR, "ERROR: photcode not found in photcode table\n");
    3636      return (FALSE);
    3737    }
    … …  
    4141
    4242  if (argc < 4) {
    43     fprintf (stderr, "USAGE: lightcurve RA DEC Radius\n");
     43    gprint (GP_ERR, "USAGE: lightcurve RA DEC Radius\n");
    4444    return (FALSE);
    4545  }
    … …  
    5353
    5454  if (skylist[0].Nregions > 1) {
    55     fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
     55    gprint (GP_ERR, "warning, radius overlaps region boundary, not yet implemented\n");
    5656  }
    5757

  • trunk/Ohana/src/opihi/dvo/mextract.c

    r7680 r7917  
    9898
    9999usage:
    100   fprintf (stderr, "USAGE: mextract (value) [options]\n");
    101   fprintf (stderr, "  value: measure.parameter or photcode\n");
     100  gprint (GP_ERR, "USAGE: mextract (value) [options]\n");
     101  gprint (GP_ERR, "  value: measure.parameter or photcode\n");
    102102  return (FALSE);
    103103

  • trunk/Ohana/src/opihi/dvo/pcat.c

    r7680 r7917  
    3030  }
    3131  if (argc != 1) {
    32     fprintf (stderr, "USAGE: pcat [-all]\n");
     32    gprint (GP_ERR, "USAGE: pcat [-all]\n");
    3333    return (FALSE);
    3434  }
    … …  
    5151    sprintf (filename, "%s/%s", catdir, regions[i].name);
    5252    if (ShowAll || (stat (filename, &filestat) != -1)) {
    53       if (VERBOSE) fprintf (stderr, "%3d %s\n", i, regions[i].name);
     53      if (VERBOSE) gprint (GP_ERR, "%3d %s\n", i, regions[i].name);
    5454
    5555      leftside = -1;
    … …  
    7878  }
    7979
    80   fprintf (stderr, "plotting %d catalogs\n", Npts/8);
     80  gprint (GP_ERR, "plotting %d catalogs\n", Npts/8);
    8181  Xvec.Nelements = Xvec.Nelements = Npts;
    8282  if (Npts > 0) {

  • trunk/Ohana/src/opihi/dvo/photcodes.c

    r7680 r7917  
    1010
    1111  if (argc != 2) {
    12     fprintf (stderr, "USAGE: photcodes (photcode)\n");
     12    gprint (GP_ERR, "USAGE: photcodes (photcode)\n");
    1313    return (FALSE);
    1414  }
    … …  
    1818
    1919  if (!(Np = GetPhotcodeCodebyName (argv[1]))) {
    20     fprintf (stderr, "ERROR: photcode not found in photcode table\n");
     20    gprint (GP_ERR, "ERROR: photcode not found in photcode table\n");
    2121    return (FALSE);
    2222  }
    … …  
    5454    set_str_variable (name, GetPhotcodeNamebyCode (code[0].c2));
    5555
    56     fprintf (stderr, "%5d %s %7.4f %7.4f %7.4f\n",
     56    gprint (GP_ERR, "%5d %s %7.4f %7.4f %7.4f\n",
    5757             code[0].code, code[0].name, 0.001*code[0].C, code[0].K, code[0].X[0]);
    5858  }

  • trunk/Ohana/src/opihi/dvo/photometry.c

    r7680 r7917  
    101101    mode = GetMagMode (p + 1);
    102102    if (mode == MAG_NONE) {
    103       fprintf (stderr, "syntax error in magnitude mode\n");
     103      gprint (GP_ERR, "syntax error in magnitude mode\n");
    104104      free (tmpstring);
    105105      return (FALSE);
    … …  
    119119  code = GetPhotcodebyName (tmpstring);
    120120  if (code == NULL) {
    121     fprintf (stderr, "photcode not found in photcode table\n");
     121    gprint (GP_ERR, "photcode not found in photcode table\n");
    122122    free (tmpstring);
    123123    return (FALSE);
    … …  
    156156
    157157  if (!status) {
    158     fprintf (stderr, "mismatch in photcode and magmode\n");
     158    gprint (GP_ERR, "mismatch in photcode and magmode\n");
    159159    free (tmpstring);
    160160    return (FALSE);
    … …  
    213213  if (!strcasecmp (parname, "YMOSAIC"))  param = MEAS_YMOSAIC;
    214214  if (!strcasecmp (parname, "help")) {
    215     fprintf (stderr, "value may be one of the following:\n");
    216     fprintf (stderr, " ra dR dec dD mag dmag Mrel Mcal photcode time fwhm dophot xccd yccd xmosaic ymosaic flags\n");
    217     fprintf (stderr, "value may also be a valid photcode\n");
    218     fprintf (stderr, "photcodes or 'mag' may have optional magnitude type: mag,[Minst, Mcat, Msys, Mrel, Mcal]\n");
     215    gprint (GP_ERR, "value may be one of the following:\n");
     216    gprint (GP_ERR, " ra dR dec dD mag dmag Mrel Mcal photcode time fwhm dophot xccd yccd xmosaic ymosaic flags\n");
     217    gprint (GP_ERR, "value may also be a valid photcode\n");
     218    gprint (GP_ERR, "photcodes or 'mag' may have optional magnitude type: mag,[Minst, Mcat, Msys, Mrel, Mcal]\n");
    219219  }
    220220  return (param);
    … …  
    250250  if (!strcasecmp (parname, "typefrac")) {
    251251    if (!TypefracType) {
    252       fprintf (stderr, "typefrac needs to specify type to use\n");
     252      gprint (GP_ERR, "typefrac needs to specify type to use\n");
    253253      return (param);
    254254    }
    … …  
    269269  if (code[0] != NULL) {
    270270    if (PhotcodeSelect) {
    271       fprintf (stderr, "photcode selection rules violated: cannot restrict photcode with a photcode\n");
     271      gprint (GP_ERR, "photcode selection rules violated: cannot restrict photcode with a photcode\n");
    272272      return (FALSE);
    273273    } else {
    … …  
    295295  if (NeedPhotcode || Needcode || NcodeSelect || PhotcodeSelect) {
    296296    if (!PhotcodeSelect) {
    297       fprintf (stderr, "photcode selection problem: value requires photcode\n");
     297      gprint (GP_ERR, "photcode selection problem: value requires photcode\n");
    298298      return (FALSE);
    299299    }
    … …  
    304304    if (code[0][0].type == PHOT_PRI) return (TRUE);
    305305    if (code[0][0].type == PHOT_SEC) return (TRUE);
    306     fprintf (stderr, "photcode selection problem: average value requires PRI/SEC photcode\n");
     306    gprint (GP_ERR, "photcode selection problem: average value requires PRI/SEC photcode\n");
    307307    return (FALSE);
    308308  }
    … …  
    311311
    312312void GetAverageParamHelp () {
    313   fprintf (stderr, "value may be one of the following:\n");
    314   fprintf (stderr, " ra dec dmag Nmeas Nmiss Xm Xp Nphot Ncode flag type typefrac\n\n");
    315   fprintf (stderr, "value may also be a valid photcode\n");
    316   fprintf (stderr, "photcodes or 'mag' may have optional magnitude mode: mag,[Mave, Mref]\n");
     313  gprint (GP_ERR, "value may be one of the following:\n");
     314  gprint (GP_ERR, " ra dec dmag Nmeas Nmiss Xm Xp Nphot Ncode flag type typefrac\n\n");
     315  gprint (GP_ERR, "value may also be a valid photcode\n");
     316  gprint (GP_ERR, "photcodes or 'mag' may have optional magnitude mode: mag,[Mave, Mref]\n");
    317317  return;
    318318}
    … …  
    329329  if (VarConfig ("PHOTCODE_FILE", "%s", PhotCodeFile) == (char *) NULL) return (FALSE);
    330330  if (!LoadPhotcodes (PhotCodeFile)) {
    331     fprintf (stderr, "error loading photcodes\n");
     331    gprint (GP_ERR, "error loading photcodes\n");
    332332    return (FALSE);
    333333  }
    … …  
    337337int ListPhotSelections () {
    338338
    339   fprintf (stderr, "TimeSelect: %d, %d - %d\n",      TimeSelect, tzero, tend);
    340   fprintf (stderr, "MagSelect: %d, %f - %f\n",       MagSelect, MagMax, MagMin);
    341   fprintf (stderr, "TypeSelect: %d, %d\n",           TypeSelect, TypeValue);
    342   fprintf (stderr, "ErrSelect: %d, %f\n",            ErrSelect, ErrValue);
    343   fprintf (stderr, "iMagSelect: %d, %f\n",           iMagSelect, iMagMin);
    344   fprintf (stderr, "FlagSelect: %d, %x\n",           FlagSelect, FlagValue);
    345   fprintf (stderr, "TypefracSelect: %d, %d %d %f\n", TypefracSelect, TypefracType, TypefracSign, TypefracValue);
    346   fprintf (stderr, "ApplySelections: %d,%d,%d,%d : %d\n", ApplySelections[0], ApplySelections[1], ApplySelections[2], ApplySelections[3], SelectionParam);
     339  gprint (GP_ERR, "TimeSelect: %d, %d - %d\n",      TimeSelect, tzero, tend);
     340  gprint (GP_ERR, "MagSelect: %d, %f - %f\n",       MagSelect, MagMax, MagMin);
     341  gprint (GP_ERR, "TypeSelect: %d, %d\n",           TypeSelect, TypeValue);
     342  gprint (GP_ERR, "ErrSelect: %d, %f\n",            ErrSelect, ErrValue);
     343  gprint (GP_ERR, "iMagSelect: %d, %f\n",           iMagSelect, iMagMin);
     344  gprint (GP_ERR, "FlagSelect: %d, %x\n",           FlagSelect, FlagValue);
     345  gprint (GP_ERR, "TypefracSelect: %d, %d %d %f\n", TypefracSelect, TypefracType, TypefracSign, TypefracValue);
     346  gprint (GP_ERR, "ApplySelections: %d,%d,%d,%d : %d\n", ApplySelections[0], ApplySelections[1], ApplySelections[2], ApplySelections[3], SelectionParam);
    347347  if (PhotcodeSelect) {
    348     fprintf (stderr, "PhotcodeSelect: %d, %s\n",       PhotcodeSelect, PhotcodeValue[0].name);
     348    gprint (GP_ERR, "PhotcodeSelect: %d, %s\n",       PhotcodeSelect, PhotcodeValue[0].name);
    349349  } else {
    350     fprintf (stderr, "PhotcodeSelect: %d, none\n",       PhotcodeSelect);
    351   }
    352   fprintf (stderr, "ChiSelect: %d, %f\n",            ChiSelect, ChiLimit);
    353   fprintf (stderr, "NphotSelect: %d, %d - %d\n",     NphotSelect, NphotSign, NphotValue);
    354   fprintf (stderr, "NcodeSelect: %d, %d - %d\n",     NcodeSelect, NcodeSign, NcodeValue);
    355   fprintf (stderr, "FWHMSelect: %d, %d %f %f\n",     FWHMSelect, FWHMsign, FWHMvalue, FWHMfrac);
     350    gprint (GP_ERR, "PhotcodeSelect: %d, none\n",       PhotcodeSelect);
     351  }
     352  gprint (GP_ERR, "ChiSelect: %d, %f\n",            ChiSelect, ChiLimit);
     353  gprint (GP_ERR, "NphotSelect: %d, %d - %d\n",     NphotSelect, NphotSign, NphotValue);
     354  gprint (GP_ERR, "NcodeSelect: %d, %d - %d\n",     NcodeSelect, NcodeSign, NcodeValue);
     355  gprint (GP_ERR, "FWHMSelect: %d, %d %f %f\n",     FWHMSelect, FWHMsign, FWHMvalue, FWHMfrac);
    356356}
    357357
    … …  
    364364
    365365  if ((N = get_argument (*argc, argv, "-phothelp"))) {
    366     fprintf (stderr, "optional photometry selection criteria:\n");
    367     fprintf (stderr, " -magrange min max\n");
    368     fprintf (stderr, " -imaglim min\n");
    369     fprintf (stderr, " -flag value\n");
    370     fprintf (stderr, " -chisq value\n");
    371     fprintf (stderr, " -photcode code\n");
    372     fprintf (stderr, " -time start range\n");
    373     fprintf (stderr, " -errorlim value\n");
    374     fprintf (stderr, " -type type\n");
    375     fprintf (stderr, " -nmeas [+/-]N\n");
    376     fprintf (stderr, " -fwhm [+/-]fraction\n");
     366    gprint (GP_ERR, "optional photometry selection criteria:\n");
     367    gprint (GP_ERR, " -magrange min max\n");
     368    gprint (GP_ERR, " -imaglim min\n");
     369    gprint (GP_ERR, " -flag value\n");
     370    gprint (GP_ERR, " -chisq value\n");
     371    gprint (GP_ERR, " -photcode code\n");
     372    gprint (GP_ERR, " -time start range\n");
     373    gprint (GP_ERR, " -errorlim value\n");
     374    gprint (GP_ERR, " -type type\n");
     375    gprint (GP_ERR, " -nmeas [+/-]N\n");
     376    gprint (GP_ERR, " -fwhm [+/-]fraction\n");
    377377    return (FALSE);
    378378  }
    … …  
    413413    remove_argument (N, argc, argv);
    414414    if (strlen(argv[N]) != Nparams) {
    415       fprintf (stderr, "-apply selection must define all parameter choices\n");
     415      gprint (GP_ERR, "-apply selection must define all parameter choices\n");
    416416      return (FALSE);
    417417    }
    … …  
    433433    GetPhotcodeInfo (argv[N], &PhotcodeValue, &PhotcodeMode);
    434434    if (PhotcodeValue == NULL) {
    435       fprintf (stderr, "photcode not found in photcode table\n");
     435      gprint (GP_ERR, "photcode not found in photcode table\n");
    436436      return (FALSE);;
    437437    }
    … …  
    444444    remove_argument (N, argc, argv);
    445445    if (!str_to_time (argv[N], &tzero)) {
    446       fprintf (stderr, "syntax error\n");
     446      gprint (GP_ERR, "syntax error\n");
    447447      return (FALSE);
    448448    }
    449449    remove_argument (N, argc, argv);
    450450    if (!str_to_dtime (argv[N], &trange)) {
    451       fprintf (stderr, "syntax error\n");
     451      gprint (GP_ERR, "syntax error\n");
    452452      return (FALSE);
    453453    }

  • trunk/Ohana/src/opihi/dvo/pmeasure.c

    r7680 r7917  
    6565
    6666  if (argc != 2) {
    67     fprintf (stderr, "USAGE: pmeasure (-all) [-m M M] [-p photcode] [-ID ID] [-flag value] [-x]\n");
     67    gprint (GP_ERR, "USAGE: pmeasure (-all) [-m M M] [-p photcode] [-ID ID] [-flag value] [-x]\n");
    6868    return (FALSE);
    6969  }

  • trunk/Ohana/src/opihi/dvo/procks.c

    r7680 r7917  
    6262
    6363  if (argc != 1) {
    64     fprintf (stderr, "USAGE: procks [-m M M] [-speed s s] \n");
     64    gprint (GP_ERR, "USAGE: procks [-m M M] [-speed s s] \n");
    6565    return (FALSE);
    6666  }
    … …  
    6868  f = fopen (rockcat, "r");
    6969  if (f == (FILE *) NULL) {
    70     fprintf (stderr, "can't open rock catalog\n");
     70    gprint (GP_ERR, "can't open rock catalog\n");
    7171    return (TRUE);
    7272  }
    … …  
    9292  if (Nrocks == 0) {
    9393    free (rocks);
    94     fprintf (stderr, "no rocks in datafile\n");
     94    gprint (GP_ERR, "no rocks in datafile\n");
    9595    return (TRUE);
    9696  }

  • trunk/Ohana/src/opihi/dvo/region_list.c

    r7680 r7917  
    3232
    3333  if (verbose) {
    34       fprintf (stderr, "CATDIR %s\n", CATDIR);
    35       fprintf (stderr, "GSCFILE %s\n", gscfile);
    36       fprintf (stderr, "SKYFILE %s\n", skyfile);
    37       fprintf (stderr, "SKYDEPTH %d\n", skydepth);
     34      gprint (GP_ERR, "CATDIR %s\n", CATDIR);
     35      gprint (GP_ERR, "GSCFILE %s\n", gscfile);
     36      gprint (GP_ERR, "SKYFILE %s\n", skyfile);
     37      gprint (GP_ERR, "SKYDEPTH %d\n", skydepth);
    3838  }
    3939
    … …  
    8383  if ((*RegionName == NULL) && (*RegionList == NULL)) return (TRUE);
    8484
    85   fprintf (stderr, "-cpt and -cptlist are incompatible\n");
     85  gprint (GP_ERR, "-cpt and -cptlist are incompatible\n");
    8686  free (*RegionName);
    8787  free (*RegionList);
    … …  
    123123  Ngraph = 0;
    124124  if (!GetGraphData (&graphsky, NULL, &Ngraph)) {
    125     fprintf (stderr, "region display not available\n");
     125    gprint (GP_ERR, "region display not available\n");
    126126    return (NULL);
    127127  }
    … …  
    144144  f = fopen (filename, "r");
    145145  if (f == NULL) {
    146     fprintf (stderr, "ERROR: can't find region list file %s\n", filename);
     146    gprint (GP_ERR, "ERROR: can't find region list file %s\n", filename);
    147147    skylist[0].Nregions = 0;
    148148    skylist[0].regions = NULL;

  • trunk/Ohana/src/opihi/dvo/showtile.c

    r7680 r7917  
    1818
    1919  if (argc != 1) {
    20     fprintf (stderr, "USAGE: showtile [option]\n");
     20    gprint (GP_ERR, "USAGE: showtile [option]\n");
    2121    return (FALSE);
    2222  }
    … …  
    4040  /* fill in top-left region */
    4141  for (r = 0; r < 3; r += 1.0) {
    42     fprintf (stderr, "r: %f\n", r);
     42    gprint (GP_ERR, "r: %f\n", r);
    4343    for (Nd = d = 0; d < 90; Nd ++, d += 1.0) {
    4444      if (r == 0) {

  • trunk/Ohana/src/opihi/dvo/simage.c

    r7680 r7917  
    3131
    3232  if (argc != 2) {
    33     fprintf (stderr, "USAGE: image (filename)\n");
     33    gprint (GP_ERR, "USAGE: image (filename)\n");
    3434    return (FALSE);
    3535  }
    3636
    37   fprintf (stderr, "not working at the moment (cmp format)\n");
     37  gprint (GP_ERR, "not working at the moment (cmp format)\n");
    3838  return (FALSE);
    3939 
    4040  /* read header */
    4141  if (!gfits_read_header (argv[1], &header)) {
    42     fprintf (stderr, "ERROR: can't find image file %s\n", argv[1]);
     42    gprint (GP_ERR, "ERROR: can't find image file %s\n", argv[1]);
    4343    return (FALSE);
    4444  }
    … …  
    4747  gfits_scan (&header, "CTYPE1",   "%s",  1, coords.ctype);
    4848  if (strcmp (coords.ctype, "RA---PLY")) {
    49     fprintf (stderr, "ERROR: wrong astrometric info in header\n");
     49    gprint (GP_ERR, "ERROR: wrong astrometric info in header\n");
    5050    return (FALSE);
    5151  }
    … …  
    8181  gfits_scan (&header, "NSTARS", "%d", 1, &Nstars);
    8282  if (Nstars == 0) {
    83     fprintf (stderr, "no stars in file\n");
     83    gprint (GP_ERR, "no stars in file\n");
    8484    return (FALSE);
    8585  }
    … …  
    8888  f = fopen (argv[1], "r");
    8989  if (f == NULL) {
    90     fprintf (stderr, "can't find data in file %s\n", argv[1]);
     90    gprint (GP_ERR, "can't find data in file %s\n", argv[1]);
    9191    return (FALSE);
    9292  }
    … …  
    108108    nbytes = fread (buffer, 1, (BLOCK*BYTES_STAR), f);
    109109    if (nbytes != BLOCK*BYTES_STAR) {
    110       fprintf (stderr, "failed to read in stars (1)\n");
     110      gprint (GP_ERR, "failed to read in stars (1)\n");
    111111      free (Xvec.elements);
    112112      free (Yvec.elements);
    … …  
    127127  nbytes = fread (buffer, 1, (Nbytes % (BLOCK*BYTES_STAR)), f);
    128128  if (nbytes != (Nbytes % (BLOCK*BYTES_STAR))) {
    129     fprintf (stderr, "ERROR: failed to read in stars (2)\n");
     129    gprint (GP_ERR, "ERROR: failed to read in stars (2)\n");
    130130    free (Xvec.elements);
    131131    free (Yvec.elements);
    … …  
    144144 
    145145  if (nstars != Nstars) {
    146     fprintf (stderr, "ERROR: failed to read in all stars (%d of %d)\n", nstars, Nstars);
     146    gprint (GP_ERR, "ERROR: failed to read in all stars (%d of %d)\n", nstars, Nstars);
    147147    free (Xvec.elements);
    148148    free (Yvec.elements);

  • trunk/Ohana/src/opihi/dvo/skycat.c

    r7680 r7917  
    3535
    3636  if (argc != 1) {
    37     fprintf (stderr, "USAGE: skycat [-all]\n");
     37    gprint (GP_ERR, "USAGE: skycat [-all]\n");
    3838    return (FALSE);
    3939  }
    … …  
    4747  skylist = SkyListByRadius (sky, Depth, graphmode.coords.crval1, graphmode.coords.crval2, Radius);
    4848 
    49   if (VERBOSE) fprintf (stderr, "region: %6.2f - %6.2f, %6.2f - %6.2f\n",
     49  if (VERBOSE) gprint (GP_ERR, "region: %6.2f - %6.2f, %6.2f - %6.2f\n",
    5050                        graphmode.coords.crval1 - Radius, graphmode.coords.crval1 + Radius,
    5151                        graphmode.coords.crval2 - Radius, graphmode.coords.crval2 + Radius);
    … …  
    6565  for (i = 0; i < Nregions; i++) {
    6666    if (ShowAll || (stat (skylist[0].filename[i], &filestat) != -1)) {
    67       if (VERBOSE) fprintf (stderr, "%3d %s %6.2f - %6.2f, %6.2f - %6.2f\n", i, regions[i][0].name,
     67      if (VERBOSE) gprint (GP_ERR, "%3d %s %6.2f - %6.2f, %6.2f - %6.2f\n", i, regions[i][0].name,
    6868                            regions[i][0].Rmin, regions[i][0].Rmax, regions[i][0].Dmin, regions[i][0].Dmax);
    6969
    … …  
    9393  }
    9494
    95   fprintf (stderr, "plotting %d catalogs\n", Npts/8);
     95  gprint (GP_ERR, "plotting %d catalogs\n", Npts/8);
    9696  Xvec.Nelements = Xvec.Nelements = Npts;
    9797  if (Npts > 0) {

  • trunk/Ohana/src/opihi/dvo/skycoverage.c

    r7680 r7917  
    2525    remove_argument (N, &argc, argv);
    2626    if (!str_to_time (argv[N], &tzero)) {
    27       fprintf (stderr, "syntax error\n");
     27      gprint (GP_ERR, "syntax error\n");
    2828      return (FALSE);
    2929    }
    3030    remove_argument (N, &argc, argv);
    3131    if (!str_to_dtime (argv[N], &trange)) {
    32       fprintf (stderr, "syntax error\n");
     32      gprint (GP_ERR, "syntax error\n");
    3333      return (FALSE);
    3434    }
    … …  
    4343    remove_argument (N, &argc, argv);
    4444    if (!str_to_time (argv[N], &tzero)) {
    45       fprintf (stderr, "syntax error\n");
     45      gprint (GP_ERR, "syntax error\n");
    4646      return (FALSE);
    4747    }
    4848    remove_argument (N, &argc, argv);
    4949    if (!str_to_time (argv[N], &tend)) {
    50       fprintf (stderr, "syntax error\n");
     50      gprint (GP_ERR, "syntax error\n");
    5151      return (FALSE);
    5252    }
    … …  
    6161 
    6262  if (argc != 4) {
    63     fprintf (stderr, "USAGE: skycoverage (buffer) (pixscale) (dPix) [-time start range] [-name name]\n");
    64     fprintf (stderr, "       (buffer) saves bitmapped AIT plot\n");
    65     fprintf (stderr, "       (pixscale) specifies the pixel size in degrees\n");
    66     fprintf (stderr, "       note: we need 64800 / (pixscale)^2 pixels to represent the sky\n");
     63    gprint (GP_ERR, "USAGE: skycoverage (buffer) (pixscale) (dPix) [-time start range] [-name name]\n");
     64    gprint (GP_ERR, "       (buffer) saves bitmapped AIT plot\n");
     65    gprint (GP_ERR, "       (pixscale) specifies the pixel size in degrees\n");
     66    gprint (GP_ERR, "       note: we need 64800 / (pixscale)^2 pixels to represent the sky\n");
    6767    return (FALSE);
    6868  }

  • trunk/Ohana/src/opihi/dvo/skydbtile.c

    r6248 r7917  
    234234  DEC = 0.5*(in[0].Dmin + in[0].Dmax);
    235235  if ((DEC >= 90) || (DEC <= -90)) {
    236     fprintf (stderr, "error in Dmin");
     236    gprint (GP_ERR, "error in Dmin");
    237237    return (NULL);
    238238  }

  • trunk/Ohana/src/opihi/dvo/subpix.c

    r7680 r7917  
    2525
    2626  if (argc != 4) {
    27     fprintf (stderr, "USAGE: subpix ra dec radius\n");
     27    gprint (GP_ERR, "USAGE: subpix ra dec radius\n");
    2828    return (FALSE);
    2929  }
    … …  
    3737  skylist = SkyListByRadius (sky, -1, Ra, Dec, Radius);
    3838  if (skylist[0].Nregions > 1) {
    39     fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
     39    gprint (GP_ERR, "warning, radius overlaps region boundary, not yet implemented\n");
    4040  }
    4141
    … …  
    8383  }
    8484  if (!Nentry) {
    85     fprintf (stderr, "no stars found\n");
     85    gprint (GP_ERR, "no stars found\n");
    8686    free (RA);
    8787    free (DEC);
    … …  
    107107  Ra = RA[entry[Nmin]];
    108108  Dec = DEC[entry[Nmin]];
    109   fprintf (stderr, "finding subpix values for star @ %f %f\n", Ra, Dec);
     109  gprint (GP_ERR, "finding subpix values for star @ %f %f\n", Ra, Dec);
    110110
    111111  free (RA);
    … …  
    147147        RD_to_XY (&X, &Y, Ra, Dec, &image[I].coords);
    148148        t = TimeValue (measure[j].t, TimeReference, TimeFormat);
    149         fprintf (GetOutfile(), "%f %6.3f %7.2f %7.2f %5.3f\n", t, Mabs, X, Y, image[I].secz_PS);
     149        gprint (GP_LOG, "%f %6.3f %7.2f %7.2f %5.3f\n", t, Mabs, X, Y, image[I].secz_PS);
    150150      }
    151151    }

  • trunk/Ohana/src/opihi/dvo/version.c

    r7680 r7917  
    44int version (int argc, char **argv) {
    55
    6   fprintf (stderr, "%s\n", name);
     6  gprint (GP_ERR, "%s\n", name);
    77
    8   fprintf (stderr, "%s\n", opihi_version());
    9   fprintf (stderr, "%s\n", ohana_version());
    10   fprintf (stderr, "%s\n", gfits_version());
     8  gprint (GP_ERR, "%s\n", opihi_version());
     9  gprint (GP_ERR, "%s\n", ohana_version());
     10  gprint (GP_ERR, "%s\n", gfits_version());
    1111
    12   fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__);
     12  gprint (GP_ERR, "compiled on %s %s\n", __DATE__, __TIME__);
    1313  return (TRUE);
    1414}

  • trunk/Ohana/src/opihi/include/data.h

    r7680 r7917  
    3131int InitQueue (Queue *queue);
    3232int DeleteQueue (Queue *queue);
    33 int PrintQueue (FILE *f, Queue *queue);
     33int PrintQueue (Queue *queue);
    3434
    3535/* in sort.c */

  • trunk/Ohana/src/opihi/include/external.h

    r7039 r7917  
    1010# include <time.h>
    1111# include <errno.h>
     12# include <pthread.h>
    1213
    1314# include <ohana.h>

  • trunk/Ohana/src/opihi/include/pantasks.h

    r7892 r7917  
    88# include <netdb.h>
    99# include <arpa/inet.h>
    10 # include <pthread.h>
    1110
    1211typedef struct sockaddr_in SockAddress;
    … …  
    202201int GetClientSocket (char *hostname);
    203202int InitServerSocket_Named (char *hostname, SockAddress *Address);
     203
     204/*
     205void InitPrint ();
     206void SetOutBuffer ();
     207IOBuffer *GetOutBuffer ();
     208void SetOutfile (char *outname);
     209FILE *GetOutFile ();
     210int ioprint (IOBuffer *buffer, char *format, ...);
     211int gprintf (char *format, ...);
     212*/

  • trunk/Ohana/src/opihi/include/pcontrol.h

    r4763 r7917  
    134134IDtype NextJobID ();
    135135IDtype NextHostID ();
    136 void PrintID (FILE *f, IDtype ID);
     136void PrintID (gpDest dest, IDtype ID);
    137137int CheckBusyJob (Job *job);
    138138int StartHost (Host *host);

  • trunk/Ohana/src/opihi/include/shell.h

    r7892 r7917  
    124124char *opihi_version ();
    125125
     126/*** gprint defines ***/
     127
     128/* enums used by gprint functions */
     129typedef enum {GP_FILE, GP_BUFF} gpMode;
     130typedef enum {GP_LOG, GP_ERR} gpDest;
     131
     132/* structure used to represent the gprint i/o stream */
     133typedef struct {
     134  FILE *file;
     135  IOBuffer *buffer;
     136  gpMode mode;
     137  gpDest dest;
     138  pthread_t thread;
     139} gpStream;
     140
     141void gprintInit ();
     142gpStream *gprintGetStream (gpDest dest);
     143void gprintSetBuffer (gpDest dest);
     144IOBuffer *gprintGetBuffer (gpDest dest);
     145void gprintSetFile (gpDest dest, char *filename);
     146FILE *gprintGetFile (gpDest dest);
     147int gprint (gpDest dest, char *format, ...);
     148
    126149# endif

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

    r3104 r7917  
    2020    for (j = 0; j < n; j++) {
    2121      if (!finite(a[i][j])) {
    22         fprintf (stderr, "GAUSSJ: NaN\n");
     22        gprint (GP_ERR, "GAUSSJ: NaN\n");
    2323        goto escape;
    2424      }
    … …  
    3434          else
    3535            if (ipiv[k] > 1) {
    36               fprintf (stderr, "GAUSSJ: Singular Matrix! (1)\n");
     36              gprint (GP_ERR, "GAUSSJ: Singular Matrix! (1)\n");
    3737              goto escape;
    3838            }
    … …  
    5050    indxc[i] = icol;
    5151    if (a[icol][icol] == 0.0) {
    52       fprintf (stderr, "GAUSSJ: Singular Matrix! (2)\n");
     52      gprint (GP_ERR, "GAUSSJ: Singular Matrix! (2)\n");
    5353      goto escape;
    5454    }
    … …  
    108108    for (j = 0; j < n; j++) {
    109109      if (!finite(a[i][j])) {
    110         fprintf (stderr, "GAUSSJ: NaN\n");
     110        gprint (GP_ERR, "GAUSSJ: NaN\n");
    111111        goto fescape;
    112112      }
    … …  
    122122          else
    123123            if (ipiv[k] > 1) {
    124               fprintf (stderr, "GAUSSJ: Singular Matrix! (1)\n");
     124              gprint (GP_ERR, "GAUSSJ: Singular Matrix! (1)\n");
    125125              goto fescape;
    126126            }
    … …  
    138138    indxc[i] = icol;
    139139    if (a[icol][icol] == 0.0) {
    140       fprintf (stderr, "GAUSSJ: Singular Matrix! (2)\n");
     140      gprint (GP_ERR, "GAUSSJ: Singular Matrix! (2)\n");
    141141      goto fescape;
    142142    }

  • trunk/Ohana/src/opihi/lib.data/mrq2dmin.c

    r4689 r7917  
    4949  for (j = 0; j < Npar; j++) {
    5050    for (k = 0; k < Npar; k++) {
    51       fprintf (stderr, "%9.3e  ", ta[j][k]);
    52     }
    53     fprintf (stderr, "    :   %9.3e  ", tb[j][0]);
    54     fprintf (stderr, "\n");
     51      gprint (GP_ERR, "%9.3e  ", ta[j][k]);
     52    }
     53    gprint (GP_ERR, "    :   %9.3e  ", tb[j][0]);
     54    gprint (GP_ERR, "\n");
    5555  }
    5656# endif
    … …  
    105105  chisq = mrq2dcof (x, t, y, dy, Npts, partry, Npar, talpha, tbeta, funcs);
    106106  if (VERBOSE) {
    107     fprintf (stderr, "chisq: %f  ", chisq);
    108     fprintf (stderr, "lambda: %f  ", lambda);
     107    gprint (GP_ERR, "chisq: %f  ", chisq);
     108    gprint (GP_ERR, "lambda: %f  ", lambda);
    109109    for (j = 0; j < Npar; j++) {
    110       fprintf (stderr, "%f ", partry[j]);
    111     }
    112     fprintf (stderr, "\n");
     110      gprint (GP_ERR, "%f ", partry[j]);
     111    }
     112    gprint (GP_ERR, "\n");
    113113  }
    114114
    … …  
    168168  ochisq = mrq2dcof (x, t, y, dy, Npts, par, Npar, alpha, beta, funcs);
    169169  if (VERBOSE) {
    170     fprintf (stderr, "chisq: %f  ", ochisq);
    171     fprintf (stderr, "lambda: %f  ", lambda);
     170    gprint (GP_ERR, "chisq: %f  ", ochisq);
     171    gprint (GP_ERR, "lambda: %f  ", lambda);
    172172    for (i = 0; i < Npar; i++) {
    173       fprintf (stderr, "%f ", par[i]);
    174     }
    175     fprintf (stderr, "\n");
     173      gprint (GP_ERR, "%f ", par[i]);
     174    }
     175    gprint (GP_ERR, "\n");
    176176  }
    177177

  • trunk/Ohana/src/opihi/lib.data/mrqmin.c

    r4304 r7917  
    7272  chisq = mrqcof (x, y, dy, Npts, partry, Npar, talpha, tbeta, funcs);
    7373  if (VERBOSE) {
    74     fprintf (stderr, "chisq: %f  ", chisq);
    75     fprintf (stderr, "lambda: %f  ", lambda);
     74    gprint (GP_ERR, "chisq: %f  ", chisq);
     75    gprint (GP_ERR, "lambda: %f  ", lambda);
    7676    for (j = 0; j < Npar; j++) {
    77       fprintf (stderr, "%f ", partry[j]);
     77      gprint (GP_ERR, "%f ", partry[j]);
    7878    }
    79     fprintf (stderr, "\n");
     79    gprint (GP_ERR, "\n");
    8080  }
    8181
    … …  
    125125  ochisq = mrqcof (x, y, dy, Npts, par, Npar, alpha, beta, funcs);
    126126  if (VERBOSE) {
    127     fprintf (stderr, "chisq: %f  ", ochisq);
    128     fprintf (stderr, "lambda: %f  ", lambda);
     127    gprint (GP_ERR, "chisq: %f  ", ochisq);
     128    gprint (GP_ERR, "lambda: %f  ", lambda);
    129129    for (i = 0; i < Npar; i++) {
    130       fprintf (stderr, "%f ", par[i]);
     130      gprint (GP_ERR, "%f ", par[i]);
    131131    }
    132     fprintf (stderr, "\n");
     132    gprint (GP_ERR, "\n");
    133133  }
    134134  return (ochisq);

  • trunk/Ohana/src/opihi/lib.data/open_graph.c

    r6684 r7917  
    5252void XGraphDead (int input) {
    5353  signal (SIGPIPE, XGraphDead);
    54   fprintf (stderr, "kapa is dead, must restart\n");
     54  gprint (GP_ERR, "kapa is dead, must restart\n");
    5555  Xgraph[Active] = -1;
    5656}
    … …  
    6464  kapa_exec = get_variable ("KAPA");
    6565  if (kapa_exec == (char *) NULL) {
    66     fprintf (stderr, "variable KAPA not found\n");
     66    gprint (GP_ERR, "variable KAPA not found\n");
    6767    return (FALSE);
    6868  }
    … …  
    7373
    7474  if (fd < 0) {
    75     fprintf (stderr, "error starting kapa\n");
     75    gprint (GP_ERR, "error starting kapa\n");
    7676    return (FALSE);
    7777  }
    … …  
    102102  } else {
    103103    if (*N >= NXGRAPH) {
    104       fprintf (stderr, "invalid Xgraph window %d\n", *N);
     104      gprint (GP_ERR, "invalid Xgraph window %d\n", *N);
    105105      return (FALSE);
    106106    }
    … …  
    140140  } else {
    141141    if (*N >= NXGRAPH) {
    142       fprintf (stderr, "invalid Xgraph window %d\n", *N);
     142      gprint (GP_ERR, "invalid Xgraph window %d\n", *N);
    143143      return (FALSE);
    144144    }

  • trunk/Ohana/src/opihi/lib.data/open_image.c

    r6684 r7917  
    3636void XImageDead (int input) {
    3737  signal (SIGPIPE, XImageDead);
    38   fprintf (stderr, "kii is dead, must restart\n");
     38  gprint (GP_ERR, "kii is dead, must restart\n");
    3939  Ximage[Active] = -1;
    4040}
    … …  
    4848  kii_exec = get_variable ("KII");
    4949  if (kii_exec == (char *) NULL) {
    50     fprintf (stderr, "variable KII not found\n");
     50    gprint (GP_ERR, "variable KII not found\n");
    5151    return (FALSE);
    5252  }
    … …  
    5757
    5858  if (fd < 0) {
    59     fprintf (stderr, "error starting kii\n");
     59    gprint (GP_ERR, "error starting kii\n");
    6060    return (FALSE);
    6161  }
    … …  
    8686  } else {
    8787    if (*N >= NXIMAGE) {
    88       fprintf (stderr, "invalid Ximage window %d\n", *N);
     88      gprint (GP_ERR, "invalid Ximage window %d\n", *N);
    8989      return (FALSE);
    9090    }

  • trunk/Ohana/src/opihi/lib.data/powell.c

    r2598 r7917  
    7474
    7575  if (Niter == ITMAX) {
    76     fprintf (stderr, "Too many iterations in routine POWELL\n");
     76    gprint (GP_ERR, "Too many iterations in routine POWELL\n");
    7777    return;
    7878  }

  • trunk/Ohana/src/opihi/lib.data/precess.c

    r2598 r7917  
    2929
    3030  if (!done) {
    31     fprintf (stderr, "error finding epoch %s\n", in_epoch);
     31    gprint (GP_ERR, "error finding epoch %s\n", in_epoch);
    3232    exit (0);
    3333  }

  • trunk/Ohana/src/opihi/lib.data/queues.c

    r6249 r7917  
    1717
    1818  for (i = 0; i < Nqueues; i++) {
    19     fprintf (stderr, "%-15s %3d\n", queues[i][0].name, queues[i][0].Nlines);
     19    gprint (GP_ERR, "%-15s %3d\n", queues[i][0].name, queues[i][0].Nlines);
    2020  }
    2121  return;
    … …  
    324324}
    325325
    326 int PrintQueue (FILE *f, Queue *queue) {
     326int PrintQueue (Queue *queue) {
    327327
    328328  int i;
    … …  
    331331
    332332  for (i = 0; i < queue[0].Nlines; i++) {
    333     fprintf (f, "%s\n", queue[0].lines[i]);
     333    gprint (GP_LOG, "%s\n", queue[0].lines[i]);
    334334  }
    335335  return (TRUE);

  • trunk/Ohana/src/opihi/lib.data/starfuncs.c

    r7080 r7917  
    1111  string = get_variable ("GAIN");
    1212  if (string == (char *) NULL) {
    13     fprintf (stderr, "assuming a value of 1.0\n");
     13    gprint (GP_ERR, "assuming a value of 1.0\n");
    1414    gain = 1.0;
    1515  } else {
    … …  
    8989  set_int_variable ("Nsat", Nmax);
    9090 
    91   fprintf (GetOutfile(), "%f %f %f %f %f %f %f %f\n", x, y, FWHMx, FWHMy, sky, I, mag, dmag);
     91  gprint (GP_LOG, "%f %f %f %f %f %f %f %f\n", x, y, FWHMx, FWHMy, sky, I, mag, dmag);
    9292
    9393  return (mag);

  • trunk/Ohana/src/opihi/lib.data/style_args.c

    r7082 r7917  
    1818  if (*argc == 1) {
    1919    name = KapaColorName (graphmode[0].color);
    20     fprintf (stderr, "current style (%d): -x %d -c %s -pt %d -lt %d -lw %f -sz %f\n", Ngraph,
     20    gprint (GP_ERR, "current style (%d): -x %d -c %s -pt %d -lt %d -lw %f -sz %f\n", Ngraph,
    2121             graphmode[0].style, name, graphmode[0].ptype,
    2222             graphmode[0].ltype, graphmode[0].lweight,

  • trunk/Ohana/src/opihi/lib.shell/BufferOps.c

    r7080 r7917  
    6565
    6666 error:
    67   if (verbose) fprintf (stderr, "invalid matrix %s\n", name);
     67  if (verbose) gprint (GP_ERR, "invalid matrix %s\n", name);
    6868  return (NULL);
    6969}
    … …  
    202202
    203203  if (*number < 0) {
    204     fprintf (stderr, "valid overlays may be: red (0), green (1), blue (2), yellow (3)\n");
     204    gprint (GP_ERR, "valid overlays may be: red (0), green (1), blue (2), yellow (3)\n");
    205205    return (FALSE);
    206206  }
    … …  
    214214  int i;
    215215
    216   fprintf (stderr, "try %d\n", n);
     216  gprint (GP_ERR, "try %d\n", n);
    217217  for (i = 0; i < Nbuffers; i++) {
    218     fprintf (stderr, "%d  %lx\n", i, (long) buffers[i]);
    219     fprintf (stderr, "%d  %lx  %s\n", i, (long) buffers[i][0].name, buffers[i][0].name);
    220     fprintf (stderr, "%d  %lx  %s\n", i, (long) buffers[i][0].file, buffers[i][0].file);
    221     fprintf (stderr, "%d  %lx  %lx\n", i, (long) &buffers[i][0].header, (long) buffers[i][0].header.buffer);
    222     fprintf (stderr, "%d  %lx  %lx\n", i, (long) &buffers[i][0].matrix, (long) buffers[i][0].matrix.buffer);
    223     fprintf (stderr, "%d  %d  %d  %f %f\n", i, buffers[i][0].bitpix, buffers[i][0].unsign, buffers[i][0].bscale, buffers[i][0].bzero);
     218    gprint (GP_ERR, "%d  %lx\n", i, (long) buffers[i]);
     219    gprint (GP_ERR, "%d  %lx  %s\n", i, (long) buffers[i][0].name, buffers[i][0].name);
     220    gprint (GP_ERR, "%d  %lx  %s\n", i, (long) buffers[i][0].file, buffers[i][0].file);
     221    gprint (GP_ERR, "%d  %lx  %lx\n", i, (long) &buffers[i][0].header, (long) buffers[i][0].header.buffer);
     222    gprint (GP_ERR, "%d  %lx  %lx\n", i, (long) &buffers[i][0].matrix, (long) buffers[i][0].matrix.buffer);
     223    gprint (GP_ERR, "%d  %d  %d  %f %f\n", i, buffers[i][0].bitpix, buffers[i][0].unsign, buffers[i][0].bscale, buffers[i][0].bzero);
    224224  }
    225225}
    … …  
    230230
    231231  if (Nbuffers == 0) {
    232     fprintf (stderr, "No allocated buffers\n");
     232    gprint (GP_ERR, "No allocated buffers\n");
    233233    return (TRUE);
    234234  }
    235235 
    236236  if (Long) {
    237     fprintf (GetOutfile(), "    N       name                      file     X     Y    bytes BP  U   bzero     bscale  \n");
     237    gprint (GP_LOG, "    N       name                      file     X     Y    bytes BP  U   bzero     bscale  \n");
    238238    for (i = 0; i < Nbuffers; i++) {
    239       fprintf (GetOutfile(), "%5d %10s %25s %5d %5d %10d %3d %1d %10.4e %10.4e\n",
     239      gprint (GP_LOG, "%5d %10s %25s %5d %5d %10d %3d %1d %10.4e %10.4e\n",
    240240               i, buffers[i][0].name, buffers[i][0].file,
    241241               buffers[i][0].header.Naxis[0], buffers[i][0].header.Naxis[1],
    … …  
    246246  }
    247247
    248   fprintf (GetOutfile(), "    N       name                      file     X     Y    bytes\n");
     248  gprint (GP_LOG, "    N       name                      file     X     Y    bytes\n");
    249249  for (i = 0; i < Nbuffers; i++) {
    250     fprintf (GetOutfile(), "%5d %10s %25s %5d %5d %10d\n",
     250    gprint (GP_LOG, "%5d %10s %25s %5d %5d %10d\n",
    251251             i, buffers[i][0].name, buffers[i][0].file,
    252252             buffers[i][0].header.Naxis[0], buffers[i][0].header.Naxis[1],

  • trunk/Ohana/src/opihi/lib.shell/CommandOps.c

    r4583 r7917  
    3333  }
    3434  if (Nc == -1) {
    35     fprintf (stderr, "programming error: command not found\n");
     35    gprint (GP_ERR, "programming error: command not found\n");
    3636    return (FALSE);
    3737  }
    … …  
    5757  }
    5858  if (EXACT) {
    59     if (VERBOSE) fprintf (stderr, "no exact match to %s\n", name);
     59    if (VERBOSE) gprint (GP_ERR, "no exact match to %s\n", name);
    6060    return (NULL);
    6161  }
    … …  
    7373  if (Nmatch > 1) {
    7474    if (VERBOSE) {
    75       fprintf (stderr, "ambiguous command: %s ( ", name);
     75      gprint (GP_ERR, "ambiguous command: %s ( ", name);
    7676      for (i = 0; i < Nmatch; i++) {
    77         fprintf (stderr, "%s ", commands[match[i]].name);
     77        gprint (GP_ERR, "%s ", commands[match[i]].name);
    7878      }
    79       fprintf (stderr, ")\n");
     79      gprint (GP_ERR, ")\n");
    8080    }
    8181    return (NULL);
    8282  }
    83   if (VERBOSE) fprintf (stderr, "%s: Command not found.\n", name);
     83  if (VERBOSE) gprint (GP_ERR, "%s: Command not found.\n", name);
    8484  return (NULL);
    8585} 

  • trunk/Ohana/src/opihi/lib.shell/MacroOps.c

    r4705 r7917  
    4949
    5050  if ((macro == NULL) || (macro[0].Nlines == 0)) {
    51     fprintf (stderr, "  macro not defined\n");
     51    gprint (GP_ERR, "  macro not defined\n");
    5252    return;
    5353  }
    5454  for (i = 0; i < macro[0].Nlines; i++) {
    55     fprintf (stderr, "  %s\n", macro[0].line[i]);
     55    gprint (GP_ERR, "  %s\n", macro[0].line[i]);
    5656  }
    5757  return;
    … …  
    6161  int i;
    6262  for (i = 0; i < Nmacros; i++) {
    63     fprintf (stderr, "%s\n", macros[i].name);
     63    gprint (GP_ERR, "%s\n", macros[i].name);
    6464  }
    6565}
    … …  
    9191  }
    9292  if (Nm == -1) {
    93     fprintf (stderr, "programming error: macro not found\n");
     93    gprint (GP_ERR, "programming error: macro not found\n");
    9494    return (FALSE);
    9595  }
    … …  
    114114  }
    115115  if (EXACT) {
    116     if (VERBOSE) fprintf (stderr, "no exact match to %s\n", name);
     116    if (VERBOSE) gprint (GP_ERR, "no exact match to %s\n", name);
    117117    return (NULL);
    118118  }
    … …  
    130130  if (Nmatch > 1) {
    131131    if (VERBOSE) {
    132       fprintf (stderr, "ambiguous macro: %s ( ", name);
     132      gprint (GP_ERR, "ambiguous macro: %s ( ", name);
    133133      for (i = 0; i < Nmatch; i++) {
    134         fprintf (stderr, "%s ", macros[match[i]].name);
     134        gprint (GP_ERR, "%s ", macros[match[i]].name);
    135135      }
    136       fprintf (stderr, ")\n");
     136      gprint (GP_ERR, ")\n");
    137137    }
    138138    return (NULL);
    139139  }
    140   if (VERBOSE) fprintf (stderr, "%s: Macro not found.\n", name);
     140  if (VERBOSE) gprint (GP_ERR, "%s: Macro not found.\n", name);
    141141  return (NULL);
    142142} 

  • trunk/Ohana/src/opihi/lib.shell/Makefile

    r5943 r7917  
    5252$(SDIR)/variable.$(ARCH).o              \
    5353$(SDIR)/version.$(ARCH).o               \
     54$(SDIR)/gprint.$(ARCH).o                \
    5455$(SDIR)/opihi.$(ARCH).o
    5556

  • trunk/Ohana/src/opihi/lib.shell/VectorOps.c

    r3901 r7917  
    6464
    6565 error:
    66   if (verbose) fprintf (stderr, "invalid vector %s\n", name);
     66  if (verbose) gprint (GP_ERR, "invalid vector %s\n", name);
    6767  return (NULL);
    6868}
    … …  
    155155
    156156  if (Nvectors == 0) {
    157     fprintf (stderr, "No defined vectors\n");
     157    gprint (GP_ERR, "No defined vectors\n");
    158158    return (FALSE);
    159159  }
    160160
    161   fprintf (GetOutfile(), "    N       name      size\n");
     161  gprint (GP_LOG, "    N       name      size\n");
    162162  for (i = 0; i < Nvectors; i++) {
    163     fprintf (GetOutfile(), "%5d %10s %10d\n",
     163    gprint (GP_LOG, "%5d %10s %10d\n",
    164164             i, vectors[i][0].name, vectors[i][0].Nelements);
    165165  }

  • trunk/Ohana/src/opihi/lib.shell/command.c

    r4470 r7917  
    4949    char *msg;
    5050    msg = get_variable_ptr ("ERRORMSG");
    51     if (msg != (char *) NULL) fprintf (stderr, "%s\n", msg);
     51    if (msg != (char *) NULL) gprint (GP_ERR, "%s\n", msg);
    5252  }
    5353
    5454  set_int_variable ("STATUS", status);
    55   if (VERBOSE) fprintf (stderr, "command: %s, status: %d\n", line, status);
     55  if (VERBOSE) gprint (GP_ERR, "command: %s, status: %d\n", line, status);
    5656  return (status);
    5757}

  • trunk/Ohana/src/opihi/lib.shell/convert_to_RPN.c

    r4462 r7917  
    183183# if (DUMPSTACK)
    184184  for (i = 0; i < Nstack; i++) {
    185     fprintf (stderr, "%s ", stack[i].name);
    186   }
    187   if (Nstack > 0) fprintf (stderr, "\n");
     185    gprint (GP_ERR, "%s ", stack[i].name);
     186  }
     187  if (Nstack > 0) gprint (GP_ERR, "\n");
    188188  for (i = 0; i < Nstack; i++) {
    189     fprintf (stderr, "%d ", stack[i].type);
    190   }
    191   if (Nstack > 0) fprintf (stderr, "\n");
     189    gprint (GP_ERR, "%d ", stack[i].type);
     190  }
     191  if (Nstack > 0) gprint (GP_ERR, "\n");
    192192# endif
    193193

  • trunk/Ohana/src/opihi/lib.shell/errors.c

    r2598 r7917  
    1212int print_error () {
    1313
    14   fprintf (stderr, "%s\n", errorline);
     14  gprint (GP_ERR, "%s\n", errorline);
    1515  return (TRUE);
    1616}

  • trunk/Ohana/src/opihi/lib.shell/evaluate_stack.c

    r6250 r7917  
    4444
    4545    if (VERBOSE) {
    46       fprintf (stderr, "%d: ", i);
     46      gprint (GP_ERR, "%d: ", i);
    4747      for (j = 0; j < *Nstack; j++) {
    48         fprintf (stderr, "%s ", stack[j].name);
     48        gprint (GP_ERR, "%s ", stack[j].name);
    4949      }
    50       if (*Nstack > 0) fprintf (stderr, "\n");
    51       fprintf (stderr, "%d: ", i);
     50      if (*Nstack > 0) gprint (GP_ERR, "\n");
     51      gprint (GP_ERR, "%d: ", i);
    5252      for (j = 0; j < *Nstack; j++) {
    53         fprintf (stderr, "%d ", stack[j].type);
     53        gprint (GP_ERR, "%d ", stack[j].type);
    5454      }
    55       if (*Nstack > 0) fprintf (stderr, "\n");
     55      if (*Nstack > 0) gprint (GP_ERR, "\n");
    5656    }
    5757
    … …  
    161161  for (i = 0; i < Nstack; i++) {
    162162    if (IsBufferPtr (stack[i].buffer) && (stack[i].type == 'm')) {
    163       if (VERBOSE) fprintf (stderr, "free %s (buff) (%lx)\n", stack[i].name, (long) stack[i].buffer);
     163      if (VERBOSE) gprint (GP_ERR, "free %s (buff) (%lx)\n", stack[i].name, (long) stack[i].buffer);
    164164      free (stack[i].buffer[0].header.buffer);
    165165      free (stack[i].buffer[0].matrix.buffer);
    … …  
    168168    }   
    169169    if (IsVectorPtr (stack[i].vector) && (stack[i].type == 'v')) {
    170       if (VERBOSE) fprintf (stderr, "free %s (vect) (%lx)\n", stack[i].name, (long) stack[i].vector);
     170      if (VERBOSE) gprint (GP_ERR, "free %s (vect) (%lx)\n", stack[i].name, (long) stack[i].vector);
    171171      free (stack[i].vector[0].elements);
    172172      free (stack[i].vector);
    173173      stack[i].vector = NULL;
    174174    }   
    175     if (VERBOSE) fprintf (stderr, "free %s (name) (%d) (%lx)\n", stack[i].name, i, (long) stack[i].name);
     175    if (VERBOSE) gprint (GP_ERR, "free %s (name) (%d) (%lx)\n", stack[i].name, i, (long) stack[i].name);
    176176    free (stack[i].name);
    177177    stack[i].name = NULL;

  • trunk/Ohana/src/opihi/lib.shell/expand_vars.c

    r6424 r7917  
    5353    if (*c == 0) {  /* all digit var == macro parameter */
    5454      if (!MacroDepth) {
    55         fprintf (stderr, "not in a macro\n");
     55        gprint (GP_ERR, "not in a macro\n");
    5656        goto error;
    5757      } else { /* if we are executing a macro, attach the list depth to the front, pass on down the line */
    … …  
    6565    Val = get_variable_ptr (V0);
    6666    if (Val == NULL) {   /* var was not found! */
    67       fprintf (stderr, "variable %s not found\n", V0);
     67      gprint (GP_ERR, "variable %s not found\n", V0);
    6868      goto error;
    6969    }

  • trunk/Ohana/src/opihi/lib.shell/expand_vectors.c

    r3922 r7917  
    5959    /* find vector element */
    6060    if (I >= vec[0].Nelements) {
    61       fprintf (stderr, "vector subscript out of range\n");
     61      gprint (GP_ERR, "vector subscript out of range\n");
    6262      goto escape;
    6363    }

  • trunk/Ohana/src/opihi/lib.shell/interrupt.c

    r2598 r7917  
    2424 
    2525  while (1) {
    26     fprintf (stderr, "operation halted, continue? (y/n) ");
     26    gprint (GP_ERR, "operation halted, continue? (y/n) ");
    2727    fscanf (stdin, "%s", string);
    2828   

  • trunk/Ohana/src/opihi/lib.shell/isolate_elements.c

    r3318 r7917  
    112112        if (in[i][j] != '"') continue;
    113113        /*
    114           fprintf (stderr, "mismatched quotes\n");
     114          gprint (GP_ERR, "mismatched quotes\n");
    115115          return (FALSE);
    116116        }

  • trunk/Ohana/src/opihi/lib.shell/macro_create.c

    r3907 r7917  
    2121
    2222  if (argc != 2) {
    23     fprintf (stderr, "USAGE: macro <name> [-c \"comment line\"]\n");
    24     fprintf (stderr, "  (enter commands, end with the word 'END')\n");
     23    gprint (GP_ERR, "USAGE: macro <name> [-c \"comment line\"]\n");
     24    gprint (GP_ERR, "  (enter commands, end with the word 'END')\n");
    2525    return (FALSE);
    2626  }
    … …  
    3131 
    3232  if ((macro == NULL) && (cmd != NULL)) {
    33     fprintf (stderr, "cannot redefine inherent command %s\n", argv[1]);
     33    gprint (GP_ERR, "cannot redefine inherent command %s\n", argv[1]);
    3434    return (FALSE);
    3535  }
    3636  if ((macro != NULL) && (cmd == NULL)) {
    37     fprintf (stderr, "programming error: macro not in command list (%s)\n", argv[1]);
     37    gprint (GP_ERR, "programming error: macro not in command list (%s)\n", argv[1]);
    3838    return (FALSE);
    3939  }
    … …  
    7575
    7676    if ((ThisList == 0) && (input == (char *) NULL)) {
    77       fprintf (stderr, "end macro with 'END'\n");
     77      gprint (GP_ERR, "end macro with 'END'\n");
    7878      continue;
    7979    }
    … …  
    8181
    8282    if ((ThisList > 0) && (input == (char *) NULL)) {
    83       fprintf (stderr, "missing 'END' in macro definition\n");
     83      gprint (GP_ERR, "missing 'END' in macro definition\n");
    8484      input = strcreate ("end");
    8585    }

  • trunk/Ohana/src/opihi/lib.shell/macro_delete.c

    r2598 r7917  
    77
    88  if (argc != 2) {
    9     fprintf (stderr, "USAGE: macro delete <macro>\n");
     9    gprint (GP_ERR, "USAGE: macro delete <macro>\n");
    1010    return (FALSE);
    1111  }
    … …  
    1313  macro = MatchMacro (argv[1], FALSE, TRUE);
    1414  if (macro == NULL) {
    15     fprintf (stderr, "Macro %s not found\n", argv[1]);
     15    gprint (GP_ERR, "Macro %s not found\n", argv[1]);
    1616    return (FALSE);
    1717  }
    1818  cmd = MatchCommand (argv[1], FALSE, TRUE);
    1919  if (cmd == NULL) {
    20     fprintf (stderr, "programming error: macro exists but not command\n");
     20    gprint (GP_ERR, "programming error: macro exists but not command\n");
    2121    return (FALSE);
    2222  }

  • trunk/Ohana/src/opihi/lib.shell/macro_edit.c

    r2598 r7917  
    33int macro_edit (int argc, char **argv) {
    44
    5   fprintf (stderr, "this function is not implemented yet\n");
     5  gprint (GP_ERR, "this function is not implemented yet\n");
    66  return (FALSE);
    77

  • trunk/Ohana/src/opihi/lib.shell/macro_exec.c

    r2598 r7917  
    99  macro = MatchMacro (argv[0], FALSE, TRUE);
    1010  if (macro == NULL) {
    11     fprintf (stderr, "%s: Command not found.\n", argv[0]);
     11    gprint (GP_ERR, "%s: Command not found.\n", argv[0]);
    1212    return (FALSE);
    1313  }

  • trunk/Ohana/src/opihi/lib.shell/macro_list.c

    r2598 r7917  
    77
    88  if (argc != 2) {
    9     fprintf (stderr, "USAGE: macro list <macro>\n");
     9    gprint (GP_ERR, "USAGE: macro list <macro>\n");
    1010    return (FALSE);
    1111  }
    … …  
    1313  macro = MatchMacro (argv[0], FALSE, TRUE);
    1414  if (macro == NULL) {
    15     fprintf (stderr, "%s: Macro not found\n", argv[1]);
     15    gprint (GP_ERR, "%s: Macro not found\n", argv[1]);
    1616    return (FALSE);
    1717  }
    1818
    1919  for (i = 0; i < macro[0].Nlines; i++) {
    20     fprintf (stderr, "%s\n", macro[0].line[i]);
     20    gprint (GP_ERR, "%s\n", macro[0].line[i]);
    2121  }
    2222  return (TRUE);

  • trunk/Ohana/src/opihi/lib.shell/macro_read.c

    r2598 r7917  
    33int macro_read (int argc, char **argv) {
    44
    5   fprintf (stderr, "this function is not implemented yet\n");
     5  gprint (GP_ERR, "this function is not implemented yet\n");
    66  return (FALSE);
    77

  • trunk/Ohana/src/opihi/lib.shell/macro_write.c

    r2598 r7917  
    33int macro_write (int argc, char **argv) {
    44
    5   fprintf (stderr, "this function is not implemented yet\n");
     5  gprint (GP_ERR, "this function is not implemented yet\n");
    66  return (FALSE);
    77

  • trunk/Ohana/src/opihi/lib.shell/opihi.c

    r7892 r7917  
    2525      ppid = getppid();
    2626      if (ppid == 1) {
    27         fprintf (stderr, "caught parent shutdown\n");
     27        gprint (GP_ERR, "caught parent shutdown\n");
    2828        exit (2);
    2929      }
    3030      if (!isatty (STDIN_FILENO)) exit (2);
    31       fprintf (stdout, "Use \"quit\" to exit\n");
     31      gprint (GP_LOG, "Use \"quit\" to exit\n");
    3232      Nbad ++;
    3333      continue;

  • trunk/Ohana/src/opihi/lib.shell/parse.c

    r3317 r7917  
    7474      free (B);
    7575
    76       if (status) fprintf (stderr, "warning: exit status of command %d\n", status);
     76      if (status) gprint (GP_ERR, "warning: exit status of command %d\n", status);
    7777
    7878      /* convert all but last return to ' '.  drop last return */
    … …  
    131131    free (V0); V0 = (char *) NULL;
    132132    if (Nval >= vec[0].Nelements) {
    133       fprintf (stderr, "no element %d\n", Nval);
     133      gprint (GP_ERR, "no element %d\n", Nval);
    134134      goto escape;
    135135    }
    … …  
    170170    c1 = strchr (L, '}');
    171171    if (c1 == NULL) {
    172       fprintf (stderr, "no close brackets!\n");
     172      gprint (GP_ERR, "no close brackets!\n");
    173173      goto escape;
    174174    }
    175175    c2 = strchr (L, '{');
    176176    if ((c2 != NULL) && (c2 < c1)) {
    177       fprintf (stderr, "can't nest brackets!\n");
     177      gprint (GP_ERR, "can't nest brackets!\n");
    178178      goto escape;
    179179    }
    … …  
    205205
    206206  error:
    207   fprintf (stderr, "syntax error\n");
     207  gprint (GP_ERR, "syntax error\n");
    208208
    209209  escape:

  • trunk/Ohana/src/opihi/lib.shell/startup.c

    r5919 r7917  
    1919  /* load config data (.ptolemyrc) */
    2020  if (!ConfigInit (argc, argv)) {
    21     fprintf (stderr, "can't find config file. some functions will be unavailable\n");
     21    gprint (GP_ERR, "can't find config file. some functions will be unavailable\n");
    2222  }
    2323
    … …  
    5858    f = fopen (opihi_history, "a");
    5959    if (f == NULL) /* no current history file here */
    60       fprintf (stderr, "can't save history.\n");
     60      gprint (GP_ERR, "can't save history.\n");
    6161    else
    6262      fclose (f);

  • trunk/Ohana/src/opihi/lib.shell/string.c

    r6424 r7917  
    3232    for (j = i; (string[j] != 0) && (string[j] != '"'); j++);
    3333    if (string[j] == 0) {
    34       fprintf (stderr, "misbalanced quotes\n");
     34      gprint (GP_ERR, "misbalanced quotes\n");
    3535      return ((char *)NULL);
    3636    }
    … …  
    5555    }
    5656    if ((string[j] == 0) && (N != 0)) {
    57       fprintf (stderr, "misbalanced parenthesis\n");
     57      gprint (GP_ERR, "misbalanced parenthesis\n");
    5858      return ((char *)NULL);
    5959    }
    … …  
    130130    for (; (string[i] != 0) && (string[i] != '"'); i++);
    131131    if (string[i] == 0) {
    132       fprintf (stderr, "misbalanced quotes\n");
     132      gprint (GP_ERR, "misbalanced quotes\n");
    133133      return ((char *)NULL);
    134134    }
    … …  
    152152    }
    153153    if ((string[i] == 0) && (j != 0)) {
    154       fprintf (stderr, "misbalanced parenthesis\n");
     154      gprint (GP_ERR, "misbalanced parenthesis\n");
    155155      return ((char *)NULL);
    156156    }

  • trunk/Ohana/src/opihi/lib.shell/timeformat.c

    r2598 r7917  
    88  if ((p = get_variable ("TIMEREF")) != (char *) NULL) {
    99    if (!str_to_time (p, TimeReference)) {
    10       fprintf (stderr, "error in TIME_REF format\n");
     10      gprint (GP_ERR, "error in TIME_REF format\n");
    1111      return (FALSE);
    1212    }
    … …  
    2222    if (!strcasecmp (p, "min")) *TimeFormat    = TIME_MINUTES;
    2323    if (!strcasecmp (p, "sec")) *TimeFormat    = TIME_SECONDS;
    24     if (!*TimeFormat) fprintf (stderr, "unknown TIME_FORMAT\n");
     24    if (!*TimeFormat) gprint (GP_ERR, "unknown TIME_FORMAT\n");
    2525    free (p);
    2626    return (FALSE);

  • trunk/Ohana/src/opihi/lib.shell/variable.c

    r6424 r7917  
    2020  for (i = 0; i < Nvariables; i++) {
    2121    if (!strcmp (name, variables[i].name)) {
    22       fprintf (stderr, "warning: local variable overrides global name\n");
     22      gprint (GP_ERR, "warning: local variable overrides global name\n");
    2323    }
    2424  } */
    … …  
    305305
    306306  if (Nvariables == 0) {
    307     fprintf (stderr, "No defined variables\n");
     307    gprint (GP_ERR, "No defined variables\n");
    308308    return;
    309309  }
    310310
    311311  for (i = 0; i < Nvariables; i++) {
    312     fprintf (stderr, "%s = %s\n", variables[i].name, variables[i].value);
     312    gprint (GP_ERR, "%s = %s\n", variables[i].name, variables[i].value);
    313313  }
    314314  return;

  • trunk/Ohana/src/opihi/mana/Makefile

    r6678 r7917  
    1919# link flags
    2020LIBS    =       -L$(LIB) -L$(LLIB) -L$(XLIB)
    21 LIBS1   =       -lsocket -lnsl -lreadline $(TLIB) -ldvo -lkapa -lFITS -lohana -lX11 -lm
     21LIBS1   =       -lsocket -lnsl -lreadline $(TLIB) -ldvo -lkapa -lFITS -lohana -lX11 -lpthread -lm
    2222# LIBS1   =       -lreadline $(TLIB) -ldvo -lkapa -lFITS -lohana -lX11 -lm
    2323LIBS2   =       -lbasiccmd -ldatacmd -lastrocmd -lshell -ldata

  • trunk/Ohana/src/opihi/mana/adc.c

    r2598 r7917  
    2828
    2929  if (argc != 4) {
    30     fprintf (stderr, "USAGE: adc ai N (variable)\n");
    31     fprintf (stderr, "USAGE: adc di N (variable)\n");
    32     fprintf (stderr, "USAGE: adc do N mode\n");
     30    gprint (GP_ERR, "USAGE: adc ai N (variable)\n");
     31    gprint (GP_ERR, "USAGE: adc di N (variable)\n");
     32    gprint (GP_ERR, "USAGE: adc do N mode\n");
    3333    return (FALSE);
    3434  }
    … …  
    3636  if (!SerialConnected) {
    3737    if (!SerialInit ('b')) {
    38       fprintf (stderr, "error opening serial line\n");
     38      gprint (GP_ERR, "error opening serial line\n");
    3939      return (FALSE);
    4040    }
    … …  
    5555    N = atof (argv[2]);
    5656    if ((N < 1) || (N > 6)) {
    57       fprintf (stderr, "digital output is between 1 and 6\n");
     57      gprint (GP_ERR, "digital output is between 1 and 6\n");
    5858      return (FALSE);
    5959    }
    … …  
    7272    output[1] = 0;
    7373    SerialCommand (output, &input, 50);
    74     fprintf (stderr, "%x (%x, %x) -> %x (%d, %d)\n",
     74    gprint (GP_ERR, "%x (%x, %x) -> %x (%d, %d)\n",
    7575             output[0], setbit, DigitalOutState, input[0],
    7676             strlen(input), strlen(output));
    … …  
    8282    N = atof (argv[2]);
    8383    if ((N < 2) || (N > 16)) {
    84       fprintf (stderr, "analog input is between 2 and 16\n");
    85       fprintf (stderr, " (problem with 1 for the moment...)\n");
     84      gprint (GP_ERR, "analog input is between 2 and 16\n");
     85      gprint (GP_ERR, " (problem with 1 for the moment...)\n");
    8686      return (FALSE);
    8787    }
    … …  
    105105    output[1] = 0;
    106106    SerialCommand (output, &input, 50);
    107     /* fprintf (stderr, "%x -> %x\n", output[0], input[0]); */
     107    /* gprint (GP_ERR, "%x -> %x\n", output[0], input[0]); */
    108108    lo = input[0];
    109109    free (input);

  • trunk/Ohana/src/opihi/mana/demux.c

    r2598 r7917  
    88
    99  if (argc != 4) {
    10     fprintf (stderr, "USAGE: demux <buffer> nx ny\n");
     10    gprint (GP_ERR, "USAGE: demux <buffer> nx ny\n");
    1111    return (FALSE);
    1212  }

  • trunk/Ohana/src/opihi/mana/findpeaks.c

    r2938 r7917  
    100100
    101101 usage:
    102   fprintf (stderr, "findpeaks (buffer) (threshold)\n");
     102  gprint (GP_ERR, "findpeaks (buffer) (threshold)\n");
    103103  return (FALSE);
    104104}

  • trunk/Ohana/src/opihi/mana/fitcontour.c

    r4689 r7917  
    9494
    9595 usage:
    96   fprintf (stderr, "fitcontour x y (xo) (yo)\n");
     96  gprint (GP_ERR, "fitcontour x y (xo) (yo)\n");
    9797  return (FALSE);
    9898}

  • trunk/Ohana/src/opihi/mana/focus.c

    r2598 r7917  
    77  if (!strcasecmp (argv[1], "init")) {
    88    if (argc != 3) {
    9       fprintf (stderr, "USAGE: focus init (port)\n");
     9      gprint (GP_ERR, "USAGE: focus init (port)\n");
    1010      return (FALSE);
    1111    }
    1212    if (!SerialInit (argv[2])) return (FALSE);
    13     fprintf (stderr, "focus on port %s\n", argv[2]);
     13    gprint (GP_ERR, "focus on port %s\n", argv[2]);
    1414    return (TRUE);
    1515  }
    … …  
    2222
    2323    if (argc != 4) {
    24       fprintf (stderr, "USAGE: focus pos Nservo (angle)\n");
     24      gprint (GP_ERR, "USAGE: focus pos Nservo (angle)\n");
    2525      return (FALSE);
    2626    }
    … …  
    3131    sprintf (line, "%c%c%c\n", 0xff, servo, angle);
    3232    status = SerialCommand (line, &answer, 10);
    33     fprintf (stderr, "status: %d\n", status);
     33    gprint (GP_ERR, "status: %d\n", status);
    3434    if (answer != (char *) NULL) {
    35       fprintf (stderr, "answer: ..%s..\n", answer);
     35      gprint (GP_ERR, "answer: ..%s..\n", answer);
    3636    }
    3737    return (TRUE);
    … …  
    4545
    4646    if (argc != 3) {
    47       fprintf (stderr, "USAGE: focus raw value\n");
     47      gprint (GP_ERR, "USAGE: focus raw value\n");
    4848      return (FALSE);
    4949    }
    … …  
    5353    sprintf (line, "%c", value);
    5454    status = SerialCommand (line, &answer, 10);
    55     fprintf (stderr, "status: %d\n", status);
     55    gprint (GP_ERR, "status: %d\n", status);
    5656    if (answer != (char *) NULL) {
    57       fprintf (stderr, "answer: ..%s..\n", answer);
     57      gprint (GP_ERR, "answer: ..%s..\n", answer);
    5858    }
    5959    return (TRUE);
    … …  
    6161
    6262 usage:
    63   fprintf (stderr, "focus init port\n");
    64   fprintf (stderr, "focus pos (string)\n");
    65   fprintf (stderr, "focus raw (value)\n");
     63  gprint (GP_ERR, "focus init port\n");
     64  gprint (GP_ERR, "focus pos (string)\n");
     65  gprint (GP_ERR, "focus raw (value)\n");
    6666  return (FALSE);
    6767}

  • trunk/Ohana/src/opihi/mana/mana.c

    r7892 r7917  
    1818  InitMana ();
    1919
     20  gprintInit ();
     21
    2022  rl_readline_name = opihi_name;
    2123  rl_attempted_completion_function = command_completer;
    … …  
    3436/* standard welcome message */
    3537void welcome () {
    36   fprintf (stderr, "\n");
    37   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     38  gprint (GP_ERR, "\n");
     39  gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    3840}
    3941

  • trunk/Ohana/src/opihi/mana/opihi.c

    r2598 r7917  
    1010
    1111void welcome () {
    12   fprintf (stderr, "\n");
    13   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     12  gprint (GP_ERR, "\n");
     13  gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    1414}
    1515
    … …  
    5555  f = fopen (opihi_history, "a");
    5656  if (f == NULL) /* no current history file here */
    57     fprintf (stderr, "can't save history.\n");
     57    gprint (GP_ERR, "can't save history.\n");
    5858  else
    5959    fclose (f);

  • trunk/Ohana/src/opihi/mana/rawstars.c

    r2938 r7917  
    3535  if ((yp = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    3636  if (xp[0].Nelements != yp[0].Nelements) {
    37     fprintf (stderr, "vectors are not the same length\n");
     37    gprint (GP_ERR, "vectors are not the same length\n");
    3838    return (FALSE);
    3939  }
    … …  
    9090
    9191 usage:
    92   fprintf (stderr, "rawstars (buffer) (xp) (yp)\n");
     92  gprint (GP_ERR, "rawstars (buffer) (xp) (yp)\n");
    9393  return (FALSE);
    9494}

  • trunk/Ohana/src/opihi/mana/simsignal.c

    r2598 r7917  
    99
    1010  if (argc != 5) {
    11     fprintf (stderr, "USAGE: simsignal (vector) Nbin Nbits period\n");
     11    gprint (GP_ERR, "USAGE: simsignal (vector) Nbin Nbits period\n");
    1212    return (FALSE);
    1313  }

  • trunk/Ohana/src/opihi/mana/starcontour.c

    r4689 r7917  
    125125
    126126 usage:
    127   fprintf (stderr, "starcontour (buffer) (xpeak) (ypeak) (level)\n");
     127  gprint (GP_ERR, "starcontour (buffer) (xpeak) (ypeak) (level)\n");
    128128  return (FALSE);
    129129}

  • trunk/Ohana/src/opihi/mana/tests.c

    r2598 r7917  
    1616  char *test, *line;
    1717
    18   fprintf (stderr, "starting test 1...  ");
     18  gprint (GP_ERR, "starting test 1...  ");
    1919  ALLOCATE (test, char, 256);
    2020  sprintf (test, "100");
    … …  
    2323    if (line != NULL) free (line);
    2424  }
    25   fprintf (stderr, "done with test 1\n");
     25  gprint (GP_ERR, "done with test 1\n");
    2626  sleep (1);
    2727}
    … …  
    3232  char *test, *line;
    3333
    34   fprintf (stderr, "starting test 1b...  ");
     34  gprint (GP_ERR, "starting test 1b...  ");
    3535  ALLOCATE (test, char, 256);
    3636  sprintf (test, "dsin(45)");
    … …  
    3939    if (line != NULL) free (line);
    4040  }
    41   fprintf (stderr, "done with test 1b\n");
     41  gprint (GP_ERR, "done with test 1b\n");
    4242  sleep (1);
    4343}
    … …  
    4848  char *test, *line;
    4949
    50   fprintf (stderr, "starting test 2...  ");
     50  gprint (GP_ERR, "starting test 2...  ");
    5151  ALLOCATE (test, char, 256);
    5252  sprintf (test, "5 * 100");
    … …  
    5555    if (line != NULL) free (line);
    5656  }
    57   fprintf (stderr, "done with test 2\n");
     57  gprint (GP_ERR, "done with test 2\n");
    5858  sleep (1);
    5959}
    … …  
    6464  char *test, *line;
    6565
    66   fprintf (stderr, "starting test 3...  ");
     66  gprint (GP_ERR, "starting test 3...  ");
    6767  ALLOCATE (test, char, 256);
    6868  sprintf (test, "5 * dsin(45)");
    … …  
    7171    if (line != NULL) free (line);
    7272  }
    73   fprintf (stderr, "done with test 3\n");
     73  gprint (GP_ERR, "done with test 3\n");
    7474  sleep (1);
    7575}
    … …  
    8080  char *test, *line;
    8181
    82   fprintf (stderr, "starting test 4...  ");
     82  gprint (GP_ERR, "starting test 4...  ");
    8383  for (i = 0; i < 1000000; i++) {
    8484    ALLOCATE (test, char, 256);
    … …  
    8787    if (line != NULL) free (line);
    8888  }
    89   fprintf (stderr, "done with test 4\n");
     89  gprint (GP_ERR, "done with test 4\n");
    9090  sleep (1);
    9191}
    … …  
    9696  char *test, *line;
    9797
    98   fprintf (stderr, "starting test 5...  ");
     98  gprint (GP_ERR, "starting test 5...  ");
    9999  for (i = 0; i < 1000000; i++) {
    100100    ALLOCATE (test, char, 256);
    … …  
    103103    if (line != NULL) free (line);
    104104  }
    105   fprintf (stderr, "done with test 5\n");
     105  gprint (GP_ERR, "done with test 5\n");
    106106  sleep (1);
    107107}

  • trunk/Ohana/src/opihi/mana/version.c

    r7080 r7917  
    44int version (int argc, char **argv) {
    55
    6   fprintf (stderr, "%s\n", name);
     6  gprint (GP_ERR, "%s\n", name);
    77
    8   fprintf (stderr, "%s\n", opihi_version());
    9   fprintf (stderr, "%s\n", ohana_version());
    10   fprintf (stderr, "%s\n", gfits_version());
     8  gprint (GP_ERR, "%s\n", opihi_version());
     9  gprint (GP_ERR, "%s\n", ohana_version());
     10  gprint (GP_ERR, "%s\n", gfits_version());
    1111
    12   fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__);
     12  gprint (GP_ERR, "compiled on %s %s\n", __DATE__, __TIME__);
    1313  return (TRUE);
    1414}

  • trunk/Ohana/src/opihi/pantasks/CheckController.c

    r6687 r7917  
    1919  // TimerMark ();
    2020  // status = ControllerCommand ("stop", CONTROLLER_PROMPT, &buffer);
    21   // if (VerboseMode()) fprintf (stderr, "stop controller %f\n", TimerElapsed(TRUE));
     21  // if (VerboseMode()) gprint (GP_ERR, "stop controller %f\n", TimerElapsed(TRUE));
    2222
    2323  TimerMark ();
    2424  FlushIOBuffer (&buffer);
    2525  status = ControllerCommand ("jobstack exit", CONTROLLER_PROMPT, &buffer);
    26   if (VerboseMode()) fprintf (stderr, "check exit stack %f\n", TimerElapsed(TRUE));
     26  if (VerboseMode()) gprint (GP_ERR, "check exit stack %f\n", TimerElapsed(TRUE));
    2727  if (!status) goto escape;
    2828
    … …  
    3434  status = sscanf (buffer.buffer, "%*s %d", &Njobs);
    3535  if (status != 1) goto escape;
    36   if (VerboseMode()) fprintf (stderr, "parse %d jobs on stack %f\n", Njobs, TimerElapsed(TRUE));
     36  if (VerboseMode()) gprint (GP_ERR, "parse %d jobs on stack %f\n", Njobs, TimerElapsed(TRUE));
    3737
    3838  p = buffer.buffer;
    … …  
    4040    q = strchr (p, '\n');
    4141    if (q == NULL) {
    42       fprintf (stderr, "controller message error: incomplete job list\n");
     42      gprint (GP_ERR, "controller message error: incomplete job list\n");
    4343      break;
    4444    }
    … …  
    4848    job = FindControllerJob (JobID);
    4949    if (job == NULL) {
    50       fprintf (stderr, "misplaced job? %d not in EXIT job list\n", JobID);
     50      gprint (GP_ERR, "misplaced job? %d not in EXIT job list\n", JobID);
    5151      continue;
    5252    }
    … …  
    5454    CheckControllerJob (job);
    5555  }
    56   if (VerboseMode()) fprintf (stderr, "clear %d exit jobs %f\n", i, TimerElapsed(TRUE));
     56  if (VerboseMode()) gprint (GP_ERR, "clear %d exit jobs %f\n", i, TimerElapsed(TRUE));
    5757
    5858  if (TestElapsedCheck()) goto finish;
    … …  
    7070  status = sscanf (buffer.buffer, "%*s %d", &Njobs);
    7171  if (status != 1) goto escape;
    72   if (VerboseMode()) fprintf (stderr, "check crash stack %f\n", TimerElapsed(TRUE));
     72  if (VerboseMode()) gprint (GP_ERR, "check crash stack %f\n", TimerElapsed(TRUE));
    7373
    7474  p = buffer.buffer;
    … …  
    7676    q = strchr (p, '\n');
    7777    if (q == NULL) {
    78       fprintf (stderr, "controller message error: incomplete job list\n");
     78      gprint (GP_ERR, "controller message error: incomplete job list\n");
    7979      break;
    8080    }
    … …  
    8484    job = FindControllerJob (JobID);
    8585    if (job == NULL) {
    86       fprintf (stderr, "misplaced job? %d not in CRASH job list\n", JobID);
     86      gprint (GP_ERR, "misplaced job? %d not in CRASH job list\n", JobID);
    8787      continue;
    8888    }
    … …  
    9090    CheckControllerJob (job);
    9191  }
    92   if (VerboseMode()) fprintf (stderr, "clear %d crash jobs %f\n", i, TimerElapsed(TRUE));
     92  if (VerboseMode()) gprint (GP_ERR, "clear %d crash jobs %f\n", i, TimerElapsed(TRUE));
    9393
    9494 finish:

  • trunk/Ohana/src/opihi/pantasks/CheckJobs.c

    r6687 r7917  
    1818    switch (status) {
    1919      case JOB_PENDING:
    20         /* if (VerboseMode()) fprintf (stderr, "job %s (%d) pending\n", job[0].task[0].name, job[0].JobID); */
     20        /* if (VerboseMode()) gprint (GP_LOG, "job %s (%d) pending\n", job[0].task[0].name, job[0].JobID); */
    2121        break;
    2222
    2323      case JOB_BUSY:
    24         /* if (VerboseMode()) fprintf (stderr, "job %s (%d) busy\n", job[0].task[0].name, job[0].JobID); */
     24        /* if (VerboseMode()) gprint (GP_LOG, "job %s (%d) busy\n", job[0].task[0].name, job[0].JobID); */
    2525        break;
    2626
    … …  
    2828        /* run task[0].crash macro, if it exists */
    2929        /* push output buffer data to the stdout and stderr queues */
    30         if (VerboseMode()) fprintf (stderr, "job %s (%d) crash\n", job[0].task[0].name, job[0].JobID);
     30        if (VerboseMode()) gprint (GP_LOG, "job %s (%d) crash\n", job[0].task[0].name, job[0].JobID);
    3131        PushNamedQueue ("stdout", job[0].stdout.buffer);
    3232        PushNamedQueue ("stderr", job[0].stderr.buffer);
    … …  
    4848
    4949      case JOB_EXIT:
    50         if (VerboseMode()) fprintf (stderr, "job %s (%d) exit\n", job[0].task[0].name, job[0].JobID);
     50        if (VerboseMode()) gprint (GP_LOG, "job %s (%d) exit\n", job[0].task[0].name, job[0].JobID);
    5151        PushNamedQueue ("stdout", job[0].stdout.buffer);
    5252        PushNamedQueue ("stderr", job[0].stderr.buffer);
    … …  
    7979
    8080      default:
    81         if (VerboseMode()) fprintf (stderr, "unknown exit status: %d\n", status);
     81        if (VerboseMode()) gprint (GP_LOG, "unknown exit status: %d\n", status);
    8282        /** do something more useful here ?? **/
    8383        break;
    … …  
    8989    if (job[0].mode == JOB_LOCAL) {
    9090      if (GetTaskTimer(job[0].start) < job[0].task[0].timeout_period) continue;
    91       if (VerboseMode()) fprintf (stderr, "timeout on %s\n", job[0].task[0].name);
     91      if (VerboseMode()) gprint (GP_LOG, "timeout on %s\n", job[0].task[0].name);
    9292
    9393      /* update the timeout counter */
    … …  
    9696      if (!KillLocalJob (job)) {
    9797        job[0].state = JOB_HUNG;
    98         if (VerboseMode()) fprintf (stderr, "child process %d is hung, cannot kill\n", job[0].pid);
     98        if (VerboseMode()) gprint (GP_LOG, "child process %d is hung, cannot kill\n", job[0].pid);
    9999        continue;
    100100      }

  • trunk/Ohana/src/opihi/pantasks/CheckPassword.c

    r7892 r7917  
    1515  int status;
    1616
    17   if (DEBUG) fprintf (stderr, "waiting for password %s\n", PASSWORD);
     17  if (DEBUG) gprint (GP_ERR, "waiting for password %s\n", PASSWORD);
    1818
    1919  status = ExpectCommand (BindSocket, strlen(PASSWORD), 0.1, &message);
    2020  if (status != 0) {
    21     if (DEBUG) fprintf (stderr, "failed connection\n");
     21    if (DEBUG) gprint (GP_ERR, "failed connection\n");
    2222    FreeIOBuffer (&message);
    2323    close (BindSocket);
    … …  
    2525  }
    2626  if (strncmp (message.buffer, PASSWORD, strlen(PASSWORD))) {
    27     if (DEBUG) fprintf (stderr, "invalid password\n");
     27    if (DEBUG) gprint (GP_ERR, "invalid password\n");
    2828    close (BindSocket);
    2929    return (FALSE);
    3030  }
    31   if (DEBUG) fprintf (stderr, "accepted password (%s)\n", message.buffer);
     31  if (DEBUG) gprint (GP_ERR, "accepted password (%s)\n", message.buffer);
    3232 
    3333  return (TRUE);

  • trunk/Ohana/src/opihi/pantasks/ControllerOps.c

    r6687 r7917  
    2525  gettimeofday (&stop, (void *) NULL);
    2626  dtime = DTIME (stop, start);
    27   /* if (VerboseMode()) fprintf (stderr, "check job status %f\n", dtime); */
     27  /* if (VerboseMode()) gprint (GP_ERR, "check job status %f\n", dtime); */
    2828
    2929  if ((job[0].state == JOB_EXIT) || (job[0].state == JOB_CRASH)) {
    … …  
    3232    gettimeofday (&stop, (void *) NULL);
    3333    dtime = DTIME (stop, start);
    34     /* if (VerboseMode()) fprintf (stderr, "get stdout %f\n", dtime); */
     34    /* if (VerboseMode()) gprint (GP_ERR, "get stdout %f\n", dtime); */
    3535
    3636    gettimeofday (&start, (void *) NULL);
    … …  
    3838    gettimeofday (&stop, (void *) NULL);
    3939    dtime = DTIME (stop, start);
    40     /* if (VerboseMode()) fprintf (stderr, "get stderr %f\n", dtime); */
     40    /* if (VerboseMode()) gprint (GP_ERR, "get stderr %f\n", dtime); */
    4141
    4242    gettimeofday (&start, (void *) NULL);
    … …  
    4444    gettimeofday (&stop, (void *) NULL);
    4545    dtime = DTIME (stop, start);
    46     /* if (VerboseMode()) fprintf (stderr, "delete job %f\n", dtime); */
     46    /* if (VerboseMode()) gprint (GP_ERR, "delete job %f\n", dtime); */
    4747  } 
    4848  return (TRUE);
    … …  
    8181  p = memstr (buffer.buffer, "job not found", buffer.Nbuffer);
    8282  if (p != NULL) {
    83     fprintf (stderr, "unknown job %d\n", job[0].pid);
     83    gprint (GP_ERR, "unknown job %d\n", job[0].pid);
    8484    FreeIOBuffer (&buffer);
    8585    return (FALSE);
    … …  
    105105  if (!strcmp(status_string, "CRASH"))   outstate = JOB_CRASH;
    106106  if (outstate == -1) {
    107     fprintf (stderr, "programming error?\n");
     107    gprint (GP_ERR, "programming error?\n");
    108108    exit (1);
    109109  }
    … …  
    147147  if (status == -1) return (CONTROLLER_HUNG);
    148148
    149   /* if (VerboseMode()) fprintf (stderr, "message received (GetJobOutput : %s)\n", cmd);   */
     149  /* if (VerboseMode()) gprint (GP_ERR, "message received (GetJobOutput : %s)\n", cmd);   */
    150150  /* drop extra bytes from pcontrol (not pclient:job) */
    151151  buffer[0].Nbuffer = Nstart + Nbytes;
    … …  
    205205  p = memstr (buffer.buffer, "JobID", buffer.Nbuffer);
    206206  if (p == NULL) {
    207     fprintf (stderr, "missing PID in pcontrol message : programming error\n");
     207    gprint (GP_ERR, "missing PID in pcontrol message : programming error\n");
    208208    exit (1);
    209209  }
    … …  
    240240  pid = fork ();
    241241  if (!pid) { /* must be child process */
    242     fprintf (stderr, "starting controller connection\n");
     242    gprint (GP_LOG, "starting controller connection\n");
    243243
    244244    /* close the other ends of the pipes */
    … …  
    303303  ControllerPID = pid;
    304304  ControllerStatus = TRUE;
    305   fprintf (stderr, "Connected\n");
     305  gprint (GP_LOG, "Connected\n");
    306306  return (TRUE);
    307307
    … …  
    311311
    312312io_error:
    313   fprintf (stderr, "timeout while connecting\n");
     313  gprint (GP_ERR, "timeout while connecting\n");
    314314  goto close_pipes;
    315315
    … …  
    341341  if ((status == -1) && (errno == EPIPE)) {
    342342    StopController ();
    343     if (VerboseMode()) fprintf (stderr, "controller is down\n");
     343    if (VerboseMode()) gprint (GP_ERR, "controller is down\n");
    344344    return (FALSE);
    345345  }
    … …  
    355355  if (status ==  0) {
    356356    StopController ();
    357     if (VerboseMode()) fprintf (stderr, "controller is down\n");
     357    if (VerboseMode()) gprint (GP_ERR, "controller is down\n");
    358358    return (FALSE);
    359359  }
    360360  if (status == -1) {
    361     if (VerboseMode()) fprintf (stderr, "controller is not responding\n");
     361    if (VerboseMode()) gprint (GP_ERR, "controller is not responding\n");
    362362    return (FALSE);
    363363  }
    … …  
    369369    bzero (buffer[0].buffer + buffer[0].Nbuffer, buffer[0].Nalloc - buffer[0].Nbuffer);
    370370  }
    371   /* if (VerboseMode()) fprintf (stderr, "message received, %d cycles\n", i); */
     371  /* if (VerboseMode()) gprint (GP_ERR, "message received, %d cycles\n", i); */
    372372  return (TRUE);
    373373}
    … …  
    383383  switch (Nread) {
    384384    case -2:  /* error in read (programming error?  system level error?) */
    385       fprintf (stderr, "serious IO error\n");
     385      gprint (GP_ERR, "serious IO error\n");
    386386      exit (2);
    387387    case -1:  /* no data in pipe */
    … …  
    395395  switch (Nread) {
    396396    case -2:  /* error in read (programming error?  system level error?) */
    397       fprintf (stderr, "serious IO error\n");
     397      gprint (GP_ERR, "serious IO error\n");
    398398      exit (2);
    399399    case -1:  /* no data in pipe */
    … …  
    407407int PrintControllerOutput () {
    408408
    409   fprintf (stderr, "--- stdout ---\n");
    410   fwrite (stdout_buffer.buffer, 1, stdout_buffer.Nbuffer, stderr);
    411   fprintf (stderr, "--- stdout ---\n");
    412   fwrite (stderr_buffer.buffer, 1, stderr_buffer.Nbuffer, stderr);
    413   fprintf (stderr, "---  done  ---\n");
     409  gprint (GP_LOG, "--- stdout ---\n");
     410  gwrite (stdout_buffer.buffer, 1, stdout_buffer.Nbuffer, GP_LOG);
     411  gprint (GP_LOG, "--- stderr ---\n");
     412  gwrite (stderr_buffer.buffer, 1, stderr_buffer.Nbuffer, GP_LOG);
     413  gprint (GP_LOG, "---  done  ---\n");
    414414  return (TRUE);
    415415}

  • trunk/Ohana/src/opihi/pantasks/JobOps.c

    r6687 r7917  
    6565  int i;
    6666
    67   fprintf (stderr, "\n");
     67  gprint (GP_LOG, "\n");
    6868  if (Njobs == 0) {
    69     fprintf (stderr, " no defined jobs\n");
     69    gprint (GP_LOG, " no defined jobs\n");
    7070    return;
    7171  }
    7272
    73   fprintf (stderr, " Jobs\n");
    74   for (i = 0; i < Njobs; i++) {
    75     fprintf (stderr, " %d: %-15s %5d %20s (%lx)\n", Njobs, jobs[i][0].task[0].name, jobs[i][0].JobID, jobs[i][0].argv[0], (long) jobs[i][0].argv);
     73  gprint (GP_LOG, " Jobs\n");
     74  for (i = 0; i < Njobs; i++) {
     75    gprint (GP_LOG, " %d: %-15s %5d %20s (%lx)\n", Njobs, jobs[i][0].task[0].name, jobs[i][0].JobID, jobs[i][0].argv[0], (long) jobs[i][0].argv);
    7676  }
    7777  return;
    … …  
    155155  }
    156156  if (Nm == -1) {
    157     fprintf (stderr, "programming error: job not found\n");
     157    gprint (GP_ERR, "programming error: job not found\n");
    158158    return (FALSE);
    159159  }

  • trunk/Ohana/src/opihi/pantasks/ListenClients.c

    r7892 r7917  
    2525  */
    2626
    27   if (DEBUG) fprintf (stderr, "adding a new client (%d)\n", client);
     27  if (DEBUG) gprint (GP_LOG, "adding a new client (%d)\n", client);
    2828  clients[Nclients] = client;
    2929  InitIOBuffer(&buffers[Nclients], 256);
    … …  
    4242  fd_set fdSet;
    4343  struct timeval timeout;
     44  IOBuffer *outbuffer;
    4445
    4546  InitClients ();
    … …  
    5051    for (i = 0; i < Ncurrent; i++) {
    5152      ExpectMessage (clients[i], 0.25, &buffers[i]);
    52       if (DEBUG) fprintf (stderr, "read %d from client %d\n", buffers[i].Nbuffer, i);
     53      if (DEBUG) gprint (GP_ERR, "read %d from client %d\n", buffers[i].Nbuffer, i);
    5354      if (buffers[i].Nbuffer) {
    54         if (DEBUG) fprintf (stderr, "%s\n", buffers[i].buffer);
     55        if (DEBUG) gprint (GP_ERR, "%s\n", buffers[i].buffer);
    5556      }
    5657    }
    … …  
    7374      FD_SET (clients[i], &fdSet);
    7475      if (FD_ISSET(clients[i], &fdSet)) {
    75         if (DEBUG) fprintf (stderr, "fd %d is set\n", clients[i]);
     76        if (DEBUG) gprint (GP_ERR, "fd %d is set\n", clients[i]);
    7677      } else {
    77         if (DEBUG) fprintf (stderr, "fd %d is not set\n", clients[i]);
     78        if (DEBUG) gprint (GP_ERR, "fd %d is not set\n", clients[i]);
    7879      }
    7980    }   
    … …  
    8182
    8283    /* block until we have some data on the pipes (or timeout) */
    83     if (DEBUG) fprintf (stderr, "listening to %d clients\n", Ncurrent);
     84    if (DEBUG) gprint (GP_ERR, "listening to %d clients\n", Ncurrent);
    8485    status = select (Nmax, &fdSet, NULL, NULL, &timeout);
    8586
    86     if (DEBUG) fprintf (stderr, "messages from %d clients\n", status);
     87    if (DEBUG) gprint (GP_ERR, "messages from %d clients\n", status);
    8788
    8889    if (status == -1) {
    … …  
    99100
    100101      /* this client has data, handle it */
    101       if (DEBUG) fprintf (stderr, "data from client %d\n", clients[i]);
    102 
    103       if (DEBUG) fprintf (stderr, "start: ", buffers[i].buffer);
    104       fwrite (buffers[i].buffer, 1, buffers[i].Nbuffer, stderr);
    105       if (DEBUG) fprintf (stderr, "...\n");
     102      if (DEBUG) {
     103        gprint (GP_ERR, "data from client %d\n", clients[i]);
     104        gprint (GP_ERR, "start: ", buffers[i].buffer);
     105        gwrite (buffers[i].buffer, 1, buffers[i].Nbuffer, GP_ERR);
     106        gprint (GP_ERR, "...\n");
     107      }
    106108       
    107109      /* read until the pipe is empty: -1 is empty, -2 is error */
    … …  
    109111      while (Nread >= 0) {
    110112        Nread = ReadtoIOBuffer (&buffers[i], clients[i]);       
    111         if (DEBUG) fprintf (stderr, "read %d bytes from socket\n", Nread);
     113        if (DEBUG) gprint (GP_ERR, "read %d bytes from socket\n", Nread);
    112114
    113115        if (Nread == -2) {
    114116          /* error: do something */
    115           if (1) fprintf (stderr, "error reading from socket\n");
     117          if (1) gprint (GP_ERR, "error reading from socket\n");
    116118        }
    117119      }
    118       if (DEBUG) fprintf (stderr, "read %d total bytes\n", buffers[i].Nbuffer);
     120      if (DEBUG) gprint (GP_ERR, "read %d total bytes\n", buffers[i].Nbuffer);
    119121
    120122      if (DEBUG) {
    121         fprintf (stderr, "end: ", buffers[i].buffer);
    122         fwrite (buffers[i].buffer, 1, buffers[i].Nbuffer, stderr);
    123         fprintf (stderr, "...\n");
     123        gprint (GP_ERR, "end: ", buffers[i].buffer);
     124        gwrite (buffers[i].buffer, 1, buffers[i].Nbuffer, GP_ERR);
     125        gprint (GP_ERR, "...\n");
    124126      }
    125127       
    … …  
    129131
    130132      /* we now have a possible command from the client: run it */
     133      /* XXX : we need to handle ; in the client-parsing of commands */
    131134      stripwhite (line);
    132135      if (*line) {
    133         if (1) fprintf (stderr, "got command: %s\n", line);
     136        if (1) gprint (GP_ERR, "got command: %s\n", line);
     137        SetOutBuffer ();
    134138        status = multicommand (line);
     139        outbuffer = GetOutBuffer ();
     140
     141        gprint (GP_ERR, "send message: %d bytes\n", outbuffer[0].Nbuffer);
     142        gwrite (outbuffer[0].buffer, 1, outbuffer[0].Nbuffer, GP_ERR);
     143        gprint (GP_ERR, "end message\n");
     144       
     145        SendMessage (clients[i], outbuffer[0].buffer);
     146        SetOutfile ("stdout");
    135147      }
    136148      free (line);
    137149
     150     
    138151      /* this function should return the output buffer
    139152         to the currently selected client */

  • trunk/Ohana/src/opihi/pantasks/LocalJob.c

    r6687 r7917  
    2424    switch (Nread) {
    2525      case -2:  /* error in read (programming error?  system level error?) */
    26         fprintf (stderr, "serious IO error\n");
     26        gprint (GP_ERR, "serious IO error\n");
    2727        exit (2);
    2828      case -1:  /* no data in pipe */
    … …  
    3636    switch (Nread) {
    3737      case -2:  /* error in read (programming error?  system level error?) */
    38         fprintf (stderr, "serious IO error\n");
     38        gprint (GP_ERR, "serious IO error\n");
    3939        exit (2);
    4040      case -1:  /* no data in pipe */
    … …  
    5757      switch (errno) {
    5858        case ECHILD:
    59           fprintf (stderr, "unknown PID, not a child proc\n");
    60           fprintf (stderr, "did process already exit?  programming error?\n");
     59          gprint (GP_ERR, "unknown PID, not a child proc\n");
     60          gprint (GP_ERR, "did process already exit?  programming error?\n");
    6161          job[0].state = JOB_NONE;
    6262          job[0].exit_status = 0;
    6363          return (FALSE);
    6464        case EINVAL:
    65           fprintf (stderr, "error EINVAL (waitpid): programming error\n");
     65          gprint (GP_ERR, "error EINVAL (waitpid): programming error\n");
    6666          exit (1);
    6767        case EINTR:
    68           fprintf (stderr, "error EINTR (waitpid): programming error\n");
     68          gprint (GP_ERR, "error EINTR (waitpid): programming error\n");
    6969          exit (1);
    7070        default:
    71           fprintf (stderr, "unknown error for waitpid (%d): programming error\n", errno);
     71          gprint (GP_ERR, "unknown error for waitpid (%d): programming error\n", errno);
    7272          exit (1);
    7373      }
    … …  
    8181    default:
    8282      if (result != job[0].pid) {
    83         fprintf (stderr, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, job[0].pid);
     83        gprint (GP_ERR, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, job[0].pid);
    8484        exit (1);
    8585      }
    … …  
    9393      }
    9494      if (WIFSTOPPED(waitstatus)) {
    95         fprintf (stderr, "waitpid returns 'stopped': programming error\n");
     95        gprint (GP_ERR, "waitpid returns 'stopped': programming error\n");
    9696        exit (1);
    9797      }
    … …  
    114114  pid = fork ();
    115115  if (!pid) { /* must be child process */
    116     if (VerboseMode()) fprintf (stderr, "starting local job\n");
     116    if (VerboseMode()) gprint (GP_ERR, "starting local job\n");
    117117
    118118    /* close the other ends of the pipes */

  • trunk/Ohana/src/opihi/pantasks/Makefile

    r7892 r7917  
    1919# link flags
    2020LIBS    =       -L$(LIB) -L$(LLIB) -L$(XLIB)
    21 LIBS1   =       -lsocket -lnsl -lreadline $(TLIB) -ldvo -lkapa -lFITS -lohana -lX11 -lm
     21LIBS1   =       -lsocket -lnsl -lreadline $(TLIB) -ldvo -lkapa -lFITS -lohana -lX11 -lpthread -lm
    2222LIBS2   =       -lbasiccmd -ldatacmd -lastrocmd -lshell -ldata
    2323LFLAGS  =       $(LIBS) $(LIBS2) $(LIBS1)
    … …  
    9494$(BIN)/pantasks_server.$(ARCH) : $(server) $(funcs) $(cmds) $(libs)
    9595        @if [ ! -d $(BIN) ]; then mkdir -p $(BIN); fi
    96         $(CC) -o $@ $^ $(LFLAGS) -lpthread
     96        $(CC) -o $@ $^ $(LFLAGS)
    9797
    9898pantasks_client.install: $(DESTBIN)/pantasks_client

  • trunk/Ohana/src/opihi/pantasks/SocketOps.c

    r7892 r7917  
    3333  status = inet_aton (hostip, &Address[0].sin_addr);
    3434  if (!status) {
    35     fprintf (stderr, "invalid address\n");
     35    gprint (GP_ERR, "invalid address\n");
    3636    exit (2);
    3737  }
    … …  
    4646  }
    4747
    48   if (DEBUG) fprintf (stderr, "init sock: %d, len: %d\n", InitSocket, length);
     48  if (DEBUG) gprint (GP_ERR, "init sock: %d, len: %d\n", InitSocket, length);
    4949  status = bind (InitSocket, (struct sockaddr *) Address, length);
    5050  if (status == -1) {
    … …  
    7474  fcntl (InitSocket, F_SETFL, !O_NONBLOCK);
    7575
    76   if (DEBUG) fprintf (stderr, "init sock: %d, len: %d\n", InitSocket, length);
     76  if (DEBUG) gprint (GP_ERR, "init sock: %d, len: %d\n", InitSocket, length);
    7777  BindSocket = accept (InitSocket, (struct sockaddr *) &Address_in, &length);
    78   if (DEBUG) fprintf (stderr, "bind sock: %d\n", BindSocket);
     78  if (DEBUG) gprint (GP_ERR, "bind sock: %d\n", BindSocket);
    7979  if (BindSocket == -1) {
    8080    perror ("accept: ");
    … …  
    8484  addr = Address_in.sin_addr.s_addr;
    8585  if (DEBUG) {
    86     fprintf (stderr, "incoming connection from: ");
    87     fprintf (stderr, " %u", (0xff & (addr >>  0)));
    88     fprintf (stderr, ".%u", (0xff & (addr >>  8)));
    89     fprintf (stderr, ".%u", (0xff & (addr >> 16)));
    90     fprintf (stderr, ".%u", (0xff & (addr >> 24)));
    91     fprintf (stderr, "\n");
     86    gprint (GP_ERR, "incoming connection from: ");
     87    gprint (GP_ERR, " %u", (0xff & (addr >>  0)));
     88    gprint (GP_ERR, ".%u", (0xff & (addr >>  8)));
     89    gprint (GP_ERR, ".%u", (0xff & (addr >> 16)));
     90    gprint (GP_ERR, ".%u", (0xff & (addr >> 24)));
     91    gprint (GP_ERR, "\n");
    9292  }
    9393
    … …  
    109109  }
    110110
    111   if (DEBUG) fprintf (stderr, "connection rejected\n");
     111  if (DEBUG) gprint (GP_ERR, "connection rejected\n");
    112112  close (BindSocket);
    113113  return (-1);
    114114
    115115accepted:
    116   if (DEBUG) fprintf (stderr, "connection accepted\n");
     116  if (DEBUG) gprint (GP_ERR, "connection accepted\n");
    117117  fcntl (BindSocket, F_SETFL, O_NONBLOCK);
    118118  return (BindSocket);
    … …  
    135135
    136136  if (DEBUG) {
    137     fprintf (stderr, "trying %s (%s:%d)...", host[0].h_name, hostip, MY_PORT);
     137    gprint (GP_ERR, "trying %s (%s:%d)...", host[0].h_name, hostip, MY_PORT);
    138138  }
    139139
    … …  
    142142  status = inet_aton (hostip, &Address.sin_addr);
    143143  if (!status) {
    144     fprintf (stderr, "invalid address\n");
     144    gprint (GP_ERR, "invalid address\n");
    145145    exit (2);
    146146  }
    … …  
    160160  }
    161161
    162   if (DEBUG) fprintf (stderr, "connected\n");
     162  if (DEBUG) gprint (GP_ERR, "connected\n");
    163163  fcntl (InitSocket, F_SETFL, O_NONBLOCK);
    164164  return (InitSocket);
    … …  
    183183  status = inet_aton (hostip, &Address[0].sin_addr);
    184184  if (!status) {
    185     fprintf (stderr, "invalid address\n");
     185    gprint (GP_ERR, "invalid address\n");
    186186    exit (2);
    187187  }
    … …  
    195195  }
    196196
    197   if (DEBUG) fprintf (stderr, "init sock: %d, len: %d\n", InitSocket, length);
     197  if (DEBUG) gprint (GP_ERR, "init sock: %d, len: %d\n", InitSocket, length);
    198198  status = bind (InitSocket, (struct sockaddr *) Address, length);
    199199  if (status == -1) {
    … …  
    208208  }
    209209
    210   if (DEBUG) fprintf (stderr, "socket listening on %s (%s:%d)\n", host[0].h_name, hostip, MY_PORT);
     210  if (DEBUG) gprint (GP_ERR, "socket listening on %s (%s:%d)\n", host[0].h_name, hostip, MY_PORT);
    211211  return (InitSocket);
    212212}
    … …  
    230230    test &= ((ip4 >=0) && (ip4 < 256));
    231231    if (!test) {
    232       fprintf (stderr, "invalid IP address %s\n", string);
     232      gprint (GP_ERR, "invalid IP address %s\n", string);
    233233      exit (2);
    234234    }

  • trunk/Ohana/src/opihi/pantasks/TaskOps.c

    r6687 r7917  
    5454  int i, valid;
    5555
    56   fprintf (stderr, "\n");
     56  gprint (GP_LOG, "\n");
    5757  if (Ntasks == 0) {
    58     fprintf (stderr, " no defined tasks\n");
     58    gprint (GP_LOG, " no defined tasks\n");
    5959    return;
    6060  }
    6161
    62   fprintf (stderr, " Task Status\n");
    63   fprintf (stderr, "  * Name            Njobs  Command\n");
     62  gprint (GP_LOG, " Task Status\n");
     63  gprint (GP_LOG, "  * Name            Njobs  Command\n");
    6464  for (i = 0; i < Ntasks; i++) {
    6565    valid = CheckTimeRanges (tasks[i][0].ranges, tasks[i][0].Nranges);
    66     if (verbose) fprintf (stderr, "\n");
     66    if (verbose) gprint (GP_LOG, "\n");
    6767    if (valid) {
    68       fprintf (stderr, "  + ");
     68      gprint (GP_LOG, "  + ");
    6969    } else {
    70       fprintf (stderr, "  - ");
     70      gprint (GP_LOG, "  - ");
    7171    }
    7272    if (tasks[i][0].argv == NULL) {
    73       fprintf (stderr, "%-15s %5d  %-20s\n", tasks[i][0].name, tasks[i][0].Njobs, "(dynamic)");
     73      gprint (GP_LOG, "%-15s %5d  %-20s\n", tasks[i][0].name, tasks[i][0].Njobs, "(dynamic)");
    7474    } else {
    75       fprintf (stderr, "%-15s %5d  %-20s\n", tasks[i][0].name, tasks[i][0].Njobs, tasks[i][0].argv[0]);
     75      gprint (GP_LOG, "%-15s %5d  %-20s\n", tasks[i][0].name, tasks[i][0].Njobs, tasks[i][0].argv[0]);
    7676    }
    7777    if (verbose) {
    78       fprintf (stderr, "    spawn period: %f, polling period: %f, timeout period: %f\n",
     78      gprint (GP_LOG, "    spawn period: %f, polling period: %f, timeout period: %f\n",
    7979               tasks[i][0].exec_period, tasks[i][0].poll_period, tasks[i][0].timeout_period);
    8080      if (tasks[i][0].host == NULL) {
    81         fprintf (stderr, "    task runs locally\n");
     81        gprint (GP_LOG, "    task runs locally\n");
    8282        continue;
    8383      }
    8484      if (!strcasecmp(tasks[i][0].host, "ANYHOST")) {
    85         fprintf (stderr, "    task host selected by controller\n");
     85        gprint (GP_LOG, "    task host selected by controller\n");
    8686        continue;
    8787      }
    8888      if (tasks[i][0].host_required) {
    89         fprintf (stderr, "    host %s (required)\n", tasks[i][0].host);
     89        gprint (GP_LOG, "    host %s (required)\n", tasks[i][0].host);
    9090      } else {
    91         fprintf (stderr, "    host %s (desired)\n", tasks[i][0].host);
     91        gprint (GP_LOG, "    host %s (desired)\n", tasks[i][0].host);
    9292      }
    9393    }
    … …  
    104104  task = FindTask (name);
    105105  if (task == NULL) {
    106     fprintf (stderr, "task %s not found\n", name);
     106    gprint (GP_LOG, "task %s not found\n", name);
    107107    return (FALSE);
    108108  }
    109109
    110   fprintf (stderr, "\n macro %s\n", task[0].name);
    111 
    112   fprintf (stderr, "\n command: ");
     110  gprint (GP_LOG, "\n macro %s\n", task[0].name);
     111
     112  gprint (GP_LOG, "\n command: ");
    113113  for (i = 0; i < task[0].argc; i++) {
    114     fprintf (stderr, "%s ", task[0].argv[i]);
    115   }
    116   fprintf (stderr, "\n\n");
     114    gprint (GP_LOG, "%s ", task[0].argv[i]);
     115  }
     116  gprint (GP_LOG, "\n\n");
    117117
    118118  if (task[0].host == NULL) {
    119     fprintf (stderr, " task runs locally\n");
     119    gprint (GP_LOG, " task runs locally\n");
    120120    goto periods;
    121121  }
    122122  if (!strcasecmp(task[0].host, "ANYHOST")) {
    123     fprintf (stderr, " task host selected by controller\n");
     123    gprint (GP_LOG, " task host selected by controller\n");
    124124    goto periods;
    125125  }
    126126  if (task[0].host_required) {
    127     fprintf (stderr, " host %s (required)\n", task[0].host);
     127    gprint (GP_LOG, " host %s (required)\n", task[0].host);
    128128  } else {
    129     fprintf (stderr, " host %s (desired)\n", task[0].host);
     129    gprint (GP_LOG, " host %s (desired)\n", task[0].host);
    130130  }
    131131
    132132periods:
    133   fprintf (stderr, " time periods: exec: %f  poll: %f  timeout: %f\n",
     133  gprint (GP_LOG, " time periods: exec: %f  poll: %f  timeout: %f\n",
    134134           task[0].exec_period, task[0].poll_period, task[0].timeout_period);
    135135
    136   fprintf (stderr, "\n pre-execute macro\n");
     136  gprint (GP_LOG, "\n pre-execute macro\n");
    137137  ListMacro (task[0].exec);
    138138
    139   fprintf (stderr, "\n timeout macro\n");
     139  gprint (GP_LOG, "\n timeout macro\n");
    140140  ListMacro (task[0].timeout);
    141141
    142   fprintf (stderr, "\n crash macro\n");
     142  gprint (GP_LOG, "\n crash macro\n");
    143143  ListMacro (task[0].crash);
    144144
    145   fprintf (stderr, "\n default exit macro\n");
     145  gprint (GP_LOG, "\n default exit macro\n");
    146146  ListMacro (task[0].defexit);
    147147
    148148  for (i = 0; i < task[0].Nexit; i++) {
    149     fprintf (stderr, "\n exit macro (status == %d)\n", atoi(task[0].exit[i][0].name));
     149    gprint (GP_LOG, "\n exit macro (status == %d)\n", atoi(task[0].exit[i][0].name));
    150150    ListMacro (task[0].exit[i]);
    151151  }
    … …  
    252252  }
    253253  if (Nt == -1) {
    254     fprintf (stderr, "programming error: task not found\n");
     254    gprint (GP_ERR, "programming error: task not found\n");
    255255    return (FALSE);
    256256  }
    … …  
    269269  if (task[0].argc != 0) {
    270270    if (task[0].argv == NULL) {
    271       fprintf (stderr, "task command arguments not defined (programming error)\n");
     271      gprint (GP_ERR, "task command arguments not defined (programming error)\n");
    272272      return (FALSE);
    273273    }
    … …  
    275275  }
    276276  if (RequireStatic) {
    277     fprintf (stderr, "task command not defined\n");
     277    gprint (GP_ERR, "task command not defined\n");
    278278    return (FALSE);
    279279  }
    … …  
    286286    }
    287287  }
    288   fprintf (stderr, "task command not defined\n");
     288  gprint (GP_ERR, "task command not defined\n");
    289289  return (FALSE);
    290290}

  • trunk/Ohana/src/opihi/pantasks/client_shell.c

    r7892 r7917  
    1919  /* connect to the server */
    2020  if (VarConfig ("PANTASKS_SERVER", "%s", hostname) == NULL) {
    21     fprintf (stderr, "pantasks server host undefined\n");
     21    gprint (GP_ERR, "pantasks server host undefined\n");
    2222    exit (2);
    2323  }
    … …  
    3838      ppid = getppid();
    3939      if (ppid == 1) {
    40         fprintf (stderr, "caught parent shutdown\n");
     40        gprint (GP_ERR, "caught parent shutdown\n");
    4141        exit (2);
    4242      }
    4343      if (!isatty (STDIN_FILENO)) exit (2);
    44       fprintf (stdout, "Use \"quit\" to exit\n");
     44      gprint (GP_ERR, "Use \"quit\" to exit\n");
    4545      Nbad ++;
    4646      continue;
    … …  
    5757    status = command (line, &outline);
    5858    if (outline == NULL) {
    59       fprintf (stderr, "programming error: command_client returned NULL\n");
     59      gprint (GP_ERR, "programming error: command_client returned NULL\n");
    6060      exit (2);
    6161    }
    … …  
    6363    /* command was not caught by client, send to server */
    6464    if (*outline && !status ) {
    65       fprintf (stderr, "sending message to %d: %s\n", server, outline);
     65      gprint (GP_ERR, "sending message to %d: %s\n", server, outline);
    6666      SendMessage (server, outline);
    6767      add_history (outline);
    … …  
    6969
    7070      // XXX add this in and print to stdout
    71       // status = ExpectMessage (server, 2.0, &message);
     71      status = ExpectMessage (server, 2.0, &message);
     72      gprint (GP_ERR, "got message: %d bytes\n", message.Nbuffer);
     73      gwrite (message.buffer, 1, message.Nbuffer, GP_ERR);
     74      gprint (GP_ERR, "end message\n");
    7275    }
    7376    free (outline);

  • trunk/Ohana/src/opihi/pantasks/controller.c

    r6687 r7917  
    2323
    2424  if (argc < 2) {
    25     fprintf (stderr, "USAGE: controller (command) ... \n");
     25    gprint (GP_ERR, "USAGE: controller (command) ... \n");
    2626    return (FALSE);
    2727  }
    … …  
    2929  func = FindControllerCommand (argv[1]);
    3030  if (func == NULL) {
    31     fprintf (stderr, "invalid controller command\n");
     31    gprint (GP_ERR, "invalid controller command\n");
    3232    return (FALSE);
    3333  }

  • trunk/Ohana/src/opihi/pantasks/controller_check.c

    r6687 r7917  
    1414  status = CheckControllerStatus ();
    1515  if (!status) {
    16     fprintf (stderr, "controller is not running\n");
     16    gprint (GP_LOG, "controller is not running\n");
    1717    return (TRUE);
    1818  }
    … …  
    2222  status = ControllerCommand (command, CONTROLLER_PROMPT, &buffer);
    2323  if (VerboseMode()) {
    24     fprintf (stderr, "controller command sent\n"); 
    25     fwrite (buffer.buffer, 1, buffer.Nbuffer, stderr);
    26     fprintf (stderr, "\n Nbytes received: %d\n", buffer.Nbuffer); 
     24    gprint (GP_LOG, "controller command sent\n"); 
     25    gwrite (buffer.buffer, 1, buffer.Nbuffer, GP_LOG);
     26    gprint (GP_LOG, "\n Nbytes received: %d\n", buffer.Nbuffer); 
    2727  }
    2828  FreeIOBuffer (&buffer);
    … …  
    3030
    3131usage:
    32   fprintf (stderr, "USAGE: controller check job (jobID)\n");
    33   fprintf (stderr, "USAGE: controller check host (hostID)\n");
     32  gprint (GP_ERR, "USAGE: controller check job (jobID)\n");
     33  gprint (GP_ERR, "USAGE: controller check host (hostID)\n");
    3434  return (FALSE);
    3535}

  • trunk/Ohana/src/opihi/pantasks/controller_exit.c

    r6687 r7917  
    44
    55  if (argc != 2) {
    6     fprintf (stderr, "USAGE: controller exit TRUE\n");
     6    gprint (GP_ERR, "USAGE: controller exit TRUE\n");
    77    return (FALSE);
    88  }

  • trunk/Ohana/src/opihi/pantasks/controller_host.c

    r6687 r7917  
    88
    99  if (argc != 3) {
    10     fprintf (stderr, "USAGE: controller host (command) (hostname)\n");
     10    gprint (GP_ERR, "USAGE: controller host (command) (hostname)\n");
    1111    return (FALSE);
    1212  }
    … …  
    1818  InitIOBuffer (&buffer, 0x100);
    1919  status = ControllerCommand (command, CONTROLLER_PROMPT, &buffer);
    20   if (status) fwrite (buffer.buffer, 1, buffer.Nbuffer, stderr);
     20  if (status) gwrite (buffer.buffer, 1, buffer.Nbuffer, GP_LOG);
    2121  FreeIOBuffer (&buffer);
    2222  return (TRUE);

  • trunk/Ohana/src/opihi/pantasks/controller_output.c

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

  • trunk/Ohana/src/opihi/pantasks/controller_pulse.c

    r6687 r7917  
    88
    99  if (argc != 2) {
    10     fprintf (stderr, "USAGE: controller pulse (usec)\n");
     10    gprint (GP_ERR, "USAGE: controller pulse (usec)\n");
    1111    return (FALSE);
    1212  }
    … …  
    1818  InitIOBuffer (&buffer, 0x100);
    1919  status = ControllerCommand (command, CONTROLLER_PROMPT, &buffer);
    20   if (status) fwrite (buffer.buffer, 1, buffer.Nbuffer, stderr);
     20  if (status) gwrite (buffer.buffer, 1, buffer.Nbuffer, GP_LOG);
    2121  FreeIOBuffer (&buffer);
    2222  return (TRUE);

  • trunk/Ohana/src/opihi/pantasks/controller_status.c

    r6687 r7917  
    88
    99  if (argc != 1) {
    10     fprintf (stderr, "USAGE: controller status\n");
     10    gprint (GP_ERR, "USAGE: controller status\n");
    1111    return (FALSE);
    1212  }
    … …  
    1515  status = CheckControllerStatus ();
    1616  if (!status) {
    17     fprintf (stderr, "controller is not running\n");
     17    gprint (GP_LOG, "controller is not running\n");
    1818    return (TRUE);
    1919  }
    … …  
    2323  status = ControllerCommand (command, CONTROLLER_PROMPT, &buffer);
    2424  if (status) {
    25     fwrite (buffer.buffer, 1, buffer.Nbuffer, stderr);
     25    gwrite (buffer.buffer, 1, buffer.Nbuffer, GP_LOG);
    2626  } else {
    27     fprintf (stderr, "controller is down\n");
     27    gprint (GP_LOG, "controller is down\n");
    2828  }
    2929  FreeIOBuffer (&buffer);

  • trunk/Ohana/src/opihi/pantasks/delete.c

    r6687 r7917  
    66
    77  if (argc < 2) {
    8     fprintf (stderr, "USAGE: delete (JobID)\n");
     8    gprint (GP_ERR, "USAGE: delete (JobID)\n");
    99    return (FALSE);
    1010  }
    … …  
    1212  /* use a string interp to convert JobIDs to ints ? */
    1313
    14   fprintf (stderr, "this function is not yet implemented\n");
     14  gprint (GP_ERR, "this function is not yet implemented\n");
    1515  return (TRUE);
    1616}

  • trunk/Ohana/src/opihi/pantasks/invalid.c

    r7892 r7917  
    33int invalid (int argc, char **argv) {
    44
    5   fprintf (stderr, "%s is not valid for the pantasks client\n", argv[0]);
     5  gprint (GP_ERR, "%s is not valid for the pantasks client\n", argv[0]);
    66  return (TRUE);
    77

  • trunk/Ohana/src/opihi/pantasks/job.c

    r6687 r7917  
    3333  if ((N = get_argument (argc, argv, "+host"))) {
    3434    if (Mode == PCONTROL_JOB_WANTHOST) {
    35       fprintf (stderr, "ERROR: -host and +host are incompatible\n");
     35      gprint (GP_ERR, "ERROR: -host and +host are incompatible\n");
    3636      FREE (Host);
    3737      return (FALSE);
    … …  
    5252
    5353  if (argc < 2) {
    54     fprintf (stderr, "USAGE: job [options] (arg0) (arg1) ... (argN)\n");
     54    gprint (GP_ERR, "USAGE: job [options] (arg0) (arg1) ... (argN)\n");
    5555    FREE (Host);
    5656    return (FALSE);
    … …  
    6464
    6565  JobID = AddJob (Host, Mode, Timeout, targc, targv);
    66   fprintf (stdout, "JobID: %d\n", JobID);
     66  gprint (GP_LOG, "JobID: %d\n", JobID);
    6767  return (TRUE);
    6868}

  • trunk/Ohana/src/opihi/pantasks/kill.c

    r6687 r7917  
    77
    88  if (argc < 2) {
    9     fprintf (stderr, "USAGE: kill (JobID)\n");
     9    gprint (GP_ERR, "USAGE: kill (JobID)\n");
    1010    return (FALSE);
    1111  }
    … …  
    1717    if (!KillLocalJob (job)) {
    1818      job[0].state = JOB_HUNG;
    19       if (VerboseMode()) fprintf (stderr, "child process %d is hung, cannot kill\n", job[0].pid);
     19      if (VerboseMode()) gprint (GP_LOG, "child process %d is hung, cannot kill\n", job[0].pid);
    2020      return (FALSE);
    2121    }
    … …  
    2323    if (!KillControllerJob (job)) {
    2424      job[0].state = JOB_HUNG;
    25       if (VerboseMode()) fprintf (stderr, "child process %d is hung, cannot kill\n", job[0].pid);
     25      if (VerboseMode()) gprint (GP_LOG, "child process %d is hung, cannot kill\n", job[0].pid);
    2626      return (FALSE);
    2727    }
    2828  }   
    2929   
    30   fprintf (stderr, "this function is not yet implemented\n");
     30  gprint (GP_ERR, "this function is not yet implemented\n");
    3131  return (TRUE);
    3232}

  • trunk/Ohana/src/opihi/pantasks/pantasks.c

    r6687 r7917  
    3838/* standard welcome message */
    3939void welcome () {
    40   fprintf (stderr, "\n");
    41   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     40  gprint (GP_LOG, "\n");
     41  gprint (GP_LOG, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    4242}
    4343
    … …  
    5151
    5252void gotsignal (int signum) {
    53   fprintf (stderr, "got signal : %d\n", signum);
     53  gprint (GP_ERR, "got signal : %d\n", signum);
    5454  return;
    5555}

  • trunk/Ohana/src/opihi/pantasks/pantasks_client.c

    r7892 r7917  
    3838/* standard welcome message */
    3939void welcome () {
    40   fprintf (stderr, "\n");
    41   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     40  gprint (GP_LOG, "\n");
     41  gprint (GP_LOG, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    4242}
    4343
    … …  
    5454/* default signal handling */
    5555void gotsignal (int signum) {
    56   fprintf (stderr, "got signal : %d\n", signum);
     56  gprint (GP_ERR, "got signal : %d\n", signum);
    5757  return;
    5858}

  • trunk/Ohana/src/opihi/pantasks/pantasks_server.c

    r7892 r7917  
    3030  InitData ();
    3131  InitPantasks ();
     32 
     33  InitPrint ();
    3234
    3335  // signal (SIGPIPE, gotsignal);
    … …  
    7779
    7880void gotsignal (int signum) {
    79   fprintf (stderr, "got signal : %d\n", signum);
     81  gprint (GP_ERR, "got signal : %d\n", signum);
    8082  return;
    8183}

  • trunk/Ohana/src/opihi/pantasks/pulse.c

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

  • trunk/Ohana/src/opihi/pantasks/run.c

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

  • trunk/Ohana/src/opihi/pantasks/scheduler.c

    r4689 r7917  
    5252    f = fopen (opihi_history, "a");
    5353    if (f == NULL) /* no current history file here */
    54       fprintf (stderr, "can't save history.\n");
     54      gprint (GP_ERR, "can't save history.\n");
    5555    else
    5656      fclose (f);
    … …  
    6565/* standard welcome message */
    6666void welcome () {
    67   fprintf (stderr, "\n");
    68   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     67  gprint (GP_LOG, "\n");
     68  gprint (GP_LOG, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    6969}
    7070

  • trunk/Ohana/src/opihi/pantasks/status.c

    r6687 r7917  
    33int status_sys (int argc, char **argv) {
    44
    5   fprintf (stderr, "\n");
     5  gprint (GP_LOG, "\n");
    66  if (rl_event_hook == NULL) {
    7     fprintf (stderr, " Scheduler is stopped\n");
     7    gprint (GP_LOG, " Scheduler is stopped\n");
    88  } else {
    9     fprintf (stderr, " Scheduler is running\n");
     9    gprint (GP_LOG, " Scheduler is running\n");
    1010  }
    1111  if (CheckControllerStatus ()) {
    12     fprintf (stderr, " Controller is running\n");
     12    gprint (GP_LOG, " Controller is running\n");
    1313  } else {
    14     fprintf (stderr, " Controller is stopped\n");
     14    gprint (GP_LOG, " Controller is stopped\n");
    1515  }
    1616  ListTasks (FALSE);

  • trunk/Ohana/src/opihi/pantasks/stop.c

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

  • trunk/Ohana/src/opihi/pantasks/task.c

    r6687 r7917  
    2828
    2929  if (argc != 2) {
    30     fprintf (stderr, "USAGE: task <name>\n");
    31     fprintf (stderr, "  (enter commands & task functions; end with the word 'END')\n");
     30    gprint (GP_ERR, "USAGE: task <name>\n");
     31    gprint (GP_ERR, "  (enter commands & task functions; end with the word 'END')\n");
    3232    return (FALSE);
    3333  }
    … …  
    5858
    5959    if ((ThisList == 0) && (input == (char *) NULL)) {
    60       fprintf (stderr, "end task with 'END'\n");
     60      gprint (GP_ERR, "end task with 'END'\n");
    6161      continue;
    6262    }
    6363    if ((ThisList > 0) && (input == (char *) NULL)) {
    64       fprintf (stderr, "missing 'END' in task definition\n");
     64      gprint (GP_ERR, "missing 'END' in task definition\n");
    6565      input = strcreate ("end");
    6666    }
    … …  
    103103
    104104      case TASK_NONE:
    105         fprintf (stderr, "unknown task command %s\n", input);
     105        gprint (GP_ERR, "unknown task command %s\n", input);
    106106        break;
    107107    }

  • trunk/Ohana/src/opihi/pantasks/task_command.c

    r6687 r7917  
    77
    88  if (argc < 2) {
    9     fprintf (stderr, "USAGE: command <command> <arg>. ..\n");
    10     fprintf (stderr, "  (define command for this task)\n");
     9    gprint (GP_ERR, "USAGE: command <command> <arg>. ..\n");
     10    gprint (GP_ERR, "  (define command for this task)\n");
    1111    return (FALSE);
    1212  }
    … …  
    1616    task = GetActiveTask ();
    1717    if (task == NULL) {
    18       fprintf (stderr, "ERROR: not defining or running a task\n");
     18      gprint (GP_ERR, "ERROR: not defining or running a task\n");
    1919      return (FALSE);
    2020    }

  • trunk/Ohana/src/opihi/pantasks/task_host.c

    r6687 r7917  
    1313
    1414  if (argc != 2) {
    15     fprintf (stderr, "USAGE: host <name> [-required]\n");
    16     fprintf (stderr, "  define host machine for this task\n");
    17     fprintf (stderr, "  -required flags indicates controller must use this host\n");
    18     fprintf (stderr, "  value of 'local' for host indicates process not using controller\n");
    19     fprintf (stderr, "  value of 'anyhost' for host indicates controller may assign at will\n");
     15    gprint (GP_ERR, "USAGE: host <name> [-required]\n");
     16    gprint (GP_ERR, "  define host machine for this task\n");
     17    gprint (GP_ERR, "  -required flags indicates controller must use this host\n");
     18    gprint (GP_ERR, "  value of 'local' for host indicates process not using controller\n");
     19    gprint (GP_ERR, "  value of 'anyhost' for host indicates controller may assign at will\n");
    2020    return (FALSE);
    2121  }
    … …  
    2525    task = GetActiveTask ();
    2626    if (task == NULL) {
    27       fprintf (stderr, "ERROR: not defining or running a task\n");
     27      gprint (GP_ERR, "ERROR: not defining or running a task\n");
    2828      return (FALSE);
    2929    }

  • trunk/Ohana/src/opihi/pantasks/task_macros.c

    r6687 r7917  
    1111
    1212  if (!strcmp (argv[0], "task.exec") && (argc != 1)) {
    13     fprintf (stderr, "USAGE: task.exec\n");
    14     fprintf (stderr, "  (define pre-exec macro for this task)\n");
     13    gprint (GP_ERR, "USAGE: task.exec\n");
     14    gprint (GP_ERR, "  (define pre-exec macro for this task)\n");
    1515    return (FALSE);
    1616  }
    1717
    1818  if (!strcmp (argv[0], "task.exit") && (argc != 2)) {
    19     fprintf (stderr, "USAGE: task.exit (state)\n");
    20     fprintf (stderr, "  (define exit state macro for this task)\n");
     19    gprint (GP_ERR, "USAGE: task.exit (state)\n");
     20    gprint (GP_ERR, "  (define exit state macro for this task)\n");
    2121    return (FALSE);
    2222  }
    … …  
    2424  task = GetNewTask ();
    2525  if (task == NULL) {
    26     fprintf (stderr, "ERROR: not defining or running a task\n");
     26    gprint (GP_ERR, "ERROR: not defining or running a task\n");
    2727    return (FALSE);
    2828  }
    … …  
    115115
    116116    if ((ThisList == 0) && (input == (char *) NULL)) {
    117       fprintf (stderr, "end macro with 'END'\n");
     117      gprint (GP_ERR, "end macro with 'END'\n");
    118118      continue;
    119119    }
    120120    if ((ThisList > 0) && (input == (char *) NULL)) {
    121       fprintf (stderr, "missing 'END' in macro definition\n");
     121      gprint (GP_ERR, "missing 'END' in macro definition\n");
    122122      input = strcreate ("end");
    123123    }

  • trunk/Ohana/src/opihi/pantasks/task_nmax.c

    r6687 r7917  
    99  task = GetNewTask ();
    1010  if (task == NULL) {
    11     fprintf (stderr, "ERROR: not defining or running a task\n");
     11    gprint (GP_ERR, "ERROR: not defining or running a task\n");
    1212    return (FALSE);
    1313  }
    … …  
    1717
    1818usage:
    19   fprintf (stderr, "USAGE: nmax N\n");
     19  gprint (GP_ERR, "USAGE: nmax N\n");
    2020  return (FALSE);
    2121}

  • trunk/Ohana/src/opihi/pantasks/task_periods.c

    r6687 r7917  
    3535
    3636  if (argc != 1) {
    37     fprintf (stderr, "USAGE: periods [-poll value] [-exec value] [-timeout value]\n");
    38     fprintf (stderr, "  define time periods for this task\n");
     37    gprint (GP_ERR, "USAGE: periods [-poll value] [-exec value] [-timeout value]\n");
     38    gprint (GP_ERR, "  define time periods for this task\n");
    3939    return (FALSE);
    4040  }
    … …  
    4444    task = GetActiveTask ();
    4545    if (task == NULL) {
    46       fprintf (stderr, "ERROR: not defining or running a task\n");
     46      gprint (GP_ERR, "ERROR: not defining or running a task\n");
    4747      return (FALSE);
    4848    }

  • trunk/Ohana/src/opihi/pantasks/task_trange.c

    r6687 r7917  
    2525  task = GetNewTask ();
    2626  if (task == NULL) {
    27     fprintf (stderr, "ERROR: not defining or running a task\n");
     27    gprint (GP_ERR, "ERROR: not defining or running a task\n");
    2828    return (FALSE);
    2929  }
    … …  
    6161
    6262usage:
    63   fprintf (stderr, "USAGE: trange start end\n");
     63  gprint (GP_ERR, "USAGE: trange start end\n");
    6464  return (FALSE);
    6565}

  • trunk/Ohana/src/opihi/pantasks/verbose.c

    r6687 r7917  
    77  if (argc == 1) {
    88    if (VERBOSE) {
    9       fprintf (stderr, "verbose mode ON\n");
     9      gprint (GP_LOG, "verbose mode ON\n");
    1010    } else {
    11       fprintf (stderr, "verbose mode OFF\n");
     11      gprint (GP_LOG, "verbose mode OFF\n");
    1212    }
    1313    return (TRUE);
    … …  
    2929  }
    3030
    31   fprintf (stderr, "USAGE: verbose (on/off/toggle)\n");
     31  gprint (GP_ERR, "USAGE: verbose (on/off/toggle)\n");
    3232  return (FALSE);
    3333}

  • trunk/Ohana/src/opihi/pantasks/version.c

    r7080 r7917  
    44int version (int argc, char **argv) {
    55
    6   fprintf (stderr, "%s\n", name);
     6  gprint (GP_LOG, "%s\n", name);
    77
    8   fprintf (stderr, "%s\n", opihi_version());
    9   fprintf (stderr, "%s\n", ohana_version());
    10   fprintf (stderr, "%s\n", gfits_version());
     8  gprint (GP_LOG, "%s\n", opihi_version());
     9  gprint (GP_LOG, "%s\n", ohana_version());
     10  gprint (GP_LOG, "%s\n", gfits_version());
    1111
    12   fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__);
     12  gprint (GP_LOG, "compiled on %s %s\n", __DATE__, __TIME__);
    1313  return (TRUE);
    1414}

  • trunk/Ohana/src/opihi/pclient/ChildOps.c

    r4772 r7917  
    4343    Nbad ++;
    4444    if (Nbad > 10) {
    45       fprintf (stderr, "runaway!\n");
     45      gprint (GP_ERR, "runaway!\n");
    4646      exit (2);
    4747    }
    … …  
    5656  switch (Nread) {
    5757    case -2:  /* error in read (programming error?  system level error?) */
    58       fprintf (stderr, "serious IO error\n");
     58      gprint (GP_ERR, "serious IO error\n");
    5959      exit (2);
    6060    case -1:  /* no data in pipe */
    … …  
    7171  switch (Nread) {
    7272    case -2:  /* error in read (programming error?  system level error?) */
    73       fprintf (stderr, "serious IO error\n");
     73      gprint (GP_ERR, "serious IO error\n");
    7474      exit (2);
    7575    case -1:  /* no data in pipe */
    … …  
    9696      switch (errno) {
    9797        case ECHILD:
    98           fprintf (stderr, "unknown PID, not a child proc\n");
    99           fprintf (stderr, "did process already exit?  programming error?\n");
     98          gprint (GP_ERR, "unknown PID, not a child proc\n");
     99          gprint (GP_ERR, "did process already exit?  programming error?\n");
    100100          ChildStatus = PCLIENT_NONE;
    101101          break;
    102102        case EINVAL:
    103           fprintf (stderr, "error EINVAL (waitpid): programming error\n");
     103          gprint (GP_ERR, "error EINVAL (waitpid): programming error\n");
    104104          exit (1);
    105105        case EINTR:
    106           fprintf (stderr, "error EINTR (waitpid): programming error\n");
     106          gprint (GP_ERR, "error EINTR (waitpid): programming error\n");
    107107          exit (1);
    108108        default:
    109           fprintf (stderr, "unknown error for waitpid (%d): programming error\n", errno);
     109          gprint (GP_ERR, "unknown error for waitpid (%d): programming error\n", errno);
    110110          exit (1);
    111111      }
    … …  
    118118    default:
    119119      if (result != ChildPID) {
    120         fprintf (stderr, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, ChildPID);
     120        gprint (GP_ERR, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, ChildPID);
    121121        exit (1);
    122122      }
    … …  
    131131      }
    132132      if (WIFSTOPPED(waitstatus)) {
    133         fprintf (stderr, "waitpid returns 'stopped': programming error\n");
     133        gprint (GP_ERR, "waitpid returns 'stopped': programming error\n");
    134134        exit (1);
    135135      }

  • trunk/Ohana/src/opihi/pclient/job.c

    r4762 r7917  
    77
    88  if (argc < 2) {
    9     fprintf (stderr, "USAGE: job (arg0) (arg1) ... (argN)\n");
    10     fprintf (GetOutfile(), "STATUS %d\n", -2);
     9    gprint (GP_ERR, "USAGE: job (arg0) (arg1) ... (argN)\n");
     10    gprint (GP_LOG, "STATUS %d\n", -2);
    1111    return (FALSE);
    1212  }
    1313 
    1414  if (ChildStatus != PCLIENT_NONE) {
    15     fprintf (stderr, "need to clear existing child\n");
    16     fprintf (GetOutfile(), "STATUS %d\n", -3);
     15    gprint (GP_ERR, "need to clear existing child\n");
     16    gprint (GP_LOG, "STATUS %d\n", -3);
    1717    return (FALSE);
    1818  }
    … …  
    3131  pid = fork ();
    3232  if (!pid) { /* must be child process */
    33     /* fprintf (stderr, "starting child process %s...\n", targv[0]); */
     33    /* gprint (GP_ERR, "starting child process %s...\n", targv[0]); */
    3434
    3535    /* close the other ends of the pipes */
    … …  
    5050    /* exec job */
    5151    status = execvp (targv[0], targv);
    52     fprintf (stderr, "error starting child process: %d\n", status);
     52    gprint (GP_ERR, "error starting child process: %d\n", status);
    5353    exit (1);
    5454  }
    … …  
    7373  ChildPID = pid;
    7474
    75   fprintf (GetOutfile(), "STATUS %d\n", ChildPID);
     75  gprint (GP_LOG, "STATUS %d\n", ChildPID);
    7676  return (TRUE);
    7777
    … …  
    8585  if (child_stderr_fd[1] != 0) close (child_stderr_fd[1]);
    8686
    87   fprintf (GetOutfile(), "STATUS %d\n", -1);
     87  gprint (GP_LOG, "STATUS %d\n", -1);
    8888  return (FALSE);
    8989}

  • trunk/Ohana/src/opihi/pclient/pclient.c

    r5919 r7917  
    3939/* standard welcome message */
    4040void welcome () {
    41   fprintf (stderr, "\n");
    42   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     41  gprint (GP_ERR, "\n");
     42  gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    4343}
    4444
    … …  
    4949
    5050void gotsignal (int signum) {
    51   fprintf (stderr, "got signal : %d\n", signum);
     51  gprint (GP_ERR, "got signal : %d\n", signum);
    5252  return;
    5353}

  • trunk/Ohana/src/opihi/pclient/reset.c

    r4762 r7917  
    77
    88  if (argc != 1) {
    9     fprintf (stderr, "USAGE: reset\n");
    10     fprintf (GetOutfile(), "STATUS -1\n");
     9    gprint (GP_ERR, "USAGE: reset\n");
     10    gprint (GP_LOG, "STATUS -1\n");
    1111    return (FALSE);
    1212  }
    1313 
    1414  if (ChildStatus == PCLIENT_NONE) {
    15     fprintf (stderr, "no child process, cannot reset\n");
    16     fprintf (GetOutfile(), "STATUS 2\n");
     15    gprint (GP_ERR, "no child process, cannot reset\n");
     16    gprint (GP_LOG, "STATUS 2\n");
    1717    return (TRUE);
    1818  }
    … …  
    4242
    4343    /* total failure, don't reset */
    44     fprintf (stderr, "child process %d is hung, cannot reset\n", ChildPID);
    45     fprintf (GetOutfile(), "STATUS 0\n");
     44    gprint (GP_ERR, "child process %d is hung, cannot reset\n", ChildPID);
     45    gprint (GP_LOG, "STATUS 0\n");
    4646    return (FALSE);
    4747  }
    … …  
    6262  ChildExitStatus = 0;
    6363
    64   fprintf (GetOutfile(), "STATUS 1\n");
     64  gprint (GP_LOG, "STATUS 1\n");
    6565  return (TRUE);
    6666}

  • trunk/Ohana/src/opihi/pclient/status.c

    r4762 r7917  
    66
    77  if (argc != 1) {
    8     fprintf (stderr, "USAGE: status\n");
     8    gprint (GP_ERR, "USAGE: status\n");
    99    return (FALSE);
    1010  }
    … …  
    1515  if (ChildStatus == PCLIENT_CRASH) strcpy (status_string, "CRASH");
    1616
    17   fprintf (GetOutfile(), "STATUS %s\n", status_string);
    18   fprintf (GetOutfile(), "EXITST %d\n", ChildExitStatus);
    19   fprintf (GetOutfile(), "STDOUT %d\n", child_stdout.Nbuffer);
    20   fprintf (GetOutfile(), "STDERR %d\n", child_stderr.Nbuffer);
     17  gprint (GP_LOG, "STATUS %s\n", status_string);
     18  gprint (GP_LOG, "EXITST %d\n", ChildExitStatus);
     19  gprint (GP_LOG, "STDOUT %d\n", child_stdout.Nbuffer);
     20  gprint (GP_LOG, "STDERR %d\n", child_stderr.Nbuffer);
    2121
    2222  set_str_variable ("JOBSTATUS", status_string);

  • trunk/Ohana/src/opihi/pclient/stdout.c

    r4450 r7917  
    44
    55  if (argc != 1) {
    6     fprintf (stderr, "USAGE: stdout\n");
    7     fprintf (stdout, "STATUS %d\n", -1);
     6    gprint (GP_ERR, "USAGE: stdout\n");
     7    gprint (GP_LOG, "STATUS %d\n", -1);
    88    return (FALSE);
    99  }
    1010 
    1111  fwrite (child_stdout.buffer, 1, child_stdout.Nbuffer, stdout);
    12   fprintf (stdout, "STATUS %d\n", 0);
     12  gprint (GP_LOG, "STATUS %d\n", 0);
    1313  return (TRUE);
    1414
    … …  
    1818
    1919  if (argc != 1) {
    20     fprintf (stderr, "USAGE: stderr\n");
    21     fprintf (stdout, "STATUS %d\n", -1);
     20    gprint (GP_ERR, "USAGE: stderr\n");
     21    gprint (GP_LOG, "STATUS %d\n", -1);
    2222    return (FALSE);
    2323  }
    2424 
    2525  fwrite (child_stderr.buffer, 1, child_stderr.Nbuffer, stdout);
    26   fprintf (stdout, "STATUS %d\n", 0);
     26  gprint (GP_LOG, "STATUS %d\n", 0);
    2727  return (TRUE);
    2828

  • trunk/Ohana/src/opihi/pclient/version.c

    r7080 r7917  
    44int version (int argc, char **argv) {
    55
    6   fprintf (stderr, "%s\n", name);
     6  gprint (GP_ERR, "%s\n", name);
    77
    8   fprintf (stderr, "%s\n", opihi_version());
    9   fprintf (stderr, "%s\n", ohana_version());
    10   fprintf (stderr, "%s\n", gfits_version());
     8  gprint (GP_ERR, "%s\n", opihi_version());
     9  gprint (GP_ERR, "%s\n", ohana_version());
     10  gprint (GP_ERR, "%s\n", gfits_version());
    1111
    12   fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__);
     12  gprint (GP_ERR, "compiled on %s %s\n", __DATE__, __TIME__);
    1313  return (TRUE);
    1414}

  • trunk/Ohana/src/opihi/pcontrol/CheckBusyJob.c

    r4763 r7917  
    3434
    3535    case PCLIENT_GOOD:
    36       if (VerboseMode()) fprintf (stderr, "message received (CheckBusyJob)\n");
     36      if (VerboseMode()) gprint (GP_ERR, "message received (CheckBusyJob)\n");
    3737      break;
    3838
    3939    default:
    40       fprintf (stderr, "programming error: unknown status for pclient command\n"); 
     40      gprint (GP_ERR, "programming error: unknown status for pclient command\n"); 
    4141      exit (1);
    4242  }
    … …  
    4545  p = memstr (buffer.buffer, "STATUS", buffer.Nbuffer);
    4646  if (p == NULL) {
    47     fprintf (stderr, "programming error: missing STATUS in pclient message\n");
     47    gprint (GP_ERR, "programming error: missing STATUS in pclient message\n");
    4848    exit (1);
    4949  }
    5050  sscanf (p, "%*s %s", string);
    5151  if (!strcmp(string, "NONE")) {
    52     fprintf (stderr, "programming error: no current job\n");
     52    gprint (GP_ERR, "programming error: no current job\n");
    5353    exit (1);
    5454  }
    … …  
    6565  if (!strcmp(string, "CRASH")) outstate = PCONTROL_JOB_CRASH;
    6666  if (outstate == PCONTROL_JOB_BUSY) {
    67     fprintf (stderr, "programming error : should not reach here (CheckJob)\n");
     67    gprint (GP_ERR, "programming error : should not reach here (CheckJob)\n");
    6868    exit (1);
    6969  }

  • trunk/Ohana/src/opihi/pcontrol/CheckDoneHost.c

    r4763 r7917  
    1414  switch (status) {
    1515    case PCLIENT_DOWN:
    16       if (VerboseMode()) fprintf (stderr, "host %s is down\n", host[0].hostname);
     16      if (VerboseMode()) gprint (GP_ERR, "host %s is down\n", host[0].hostname);
    1717      /* DONE host does not have an incomplete job */
    1818      HarvestHost (host[0].pid);
    … …  
    2424    case PCLIENT_HUNG:
    2525      PutHost (host, PCONTROL_HOST_DONE, STACK_BOTTOM);
    26       if (VerboseMode()) fprintf (stderr, "host %s is not responding\n", host[0].hostname);
     26      if (VerboseMode()) gprint (GP_ERR, "host %s is not responding\n", host[0].hostname);
    2727      FreeIOBuffer (&buffer);
    2828      return (FALSE);
    2929
    3030    case PCLIENT_GOOD:
    31       if (VerboseMode()) fprintf (stderr, "message received (CheckDoneHost)\n"); 
     31      if (VerboseMode()) gprint (GP_ERR, "message received (CheckDoneHost)\n"); 
    3232      break;
    3333
    3434    default:
    35       if (VerboseMode()) fprintf (stderr, "unknown status for pclient command: programming error\n"); 
     35      if (VerboseMode()) gprint (GP_ERR, "unknown status for pclient command: programming error\n"); 
    3636      exit (1);
    3737  }
    … …  
    4040  p = memstr (buffer.buffer, "STATUS", buffer.Nbuffer);
    4141  if (p == NULL) {
    42     fprintf (stderr, "programming error: missing STATUS in pclient message (CheckDoneHost)\n");
     42    gprint (GP_ERR, "programming error: missing STATUS in pclient message (CheckDoneHost)\n");
    4343    exit (1);
    4444  }
    … …  
    4646  switch (status) {
    4747    case -1:
    48       fprintf (stderr, "programming error: reset syntax error\n");
     48      gprint (GP_ERR, "programming error: reset syntax error\n");
    4949      exit (1);
    5050     
    5151    case 0:
    52       if (VerboseMode()) fprintf (stderr, "reset failed\n");
     52      if (VerboseMode()) gprint (GP_ERR, "reset failed\n");
    5353      PutHost (host, PCONTROL_HOST_DONE, STACK_BOTTOM);
    5454      FreeIOBuffer (&buffer);
    … …  
    5757    case 1:
    5858    case 2:
    59       if (VerboseMode()) fprintf (stderr, "successful reset\n");
     59      if (VerboseMode()) gprint (GP_ERR, "successful reset\n");
    6060      PutHost (host, PCONTROL_HOST_IDLE, STACK_BOTTOM);
    6161      FreeIOBuffer (&buffer);
    … …  
    6363
    6464    default:
    65       fprintf (stderr, "programming error: should not reach here (CheckDoneHost)\n");
     65      gprint (GP_ERR, "programming error: should not reach here (CheckDoneHost)\n");
    6666      exit (1);
    6767  }
    68   fprintf (stderr, "programming error: should not reach here either (CheckDoneHost)\n");
     68  gprint (GP_ERR, "programming error: should not reach here either (CheckDoneHost)\n");
    6969  exit (1);
    7070}

  • trunk/Ohana/src/opihi/pcontrol/CheckHost.c

    r4772 r7917  
    1212  switch (status) {
    1313    case 0:
    14       if (VerboseMode()) fprintf (stderr, "host %s is down\n", host[0].hostname);
     14      if (VerboseMode()) gprint (GP_ERR, "host %s is down\n", host[0].hostname);
    1515      /* if host has a job, job is dead, return to Pending */
    1616      job = (Job *) host[0].job;
    … …  
    2525     
    2626    case -1:
    27       if (VerboseMode()) fprintf (stderr, "host %s is not responding\n", host[0].hostname);
     27      if (VerboseMode()) gprint (GP_ERR, "host %s is not responding\n", host[0].hostname);
    2828      /*** do we mark this in some way (HUNG) ? ***/
    2929      PutHost (host, host[0].stack, STACK_BOTTOM);
    … …  
    3636      return (TRUE);
    3737  }
    38   fprintf (stderr, "programming error: should not reach here (Check Host)\n");
     38  gprint (GP_ERR, "programming error: should not reach here (Check Host)\n");
    3939  return (FALSE);
    4040}

  • trunk/Ohana/src/opihi/pcontrol/CheckIdleHost.c

    r4762 r7917  
    1414    if (job[0].mode != PCONTROL_JOB_NEEDHOST) continue;
    1515    if (job[0].hostname == NULL) {
    16       fprintf (stderr, "programming error: NEEDHOST hostname missing\n");
     16      gprint (GP_ERR, "programming error: NEEDHOST hostname missing\n");
    1717      exit (2);
    1818    }
    … …  
    2929    if (job[0].mode != PCONTROL_JOB_WANTHOST) continue;
    3030    if (job[0].hostname == NULL) {
    31       fprintf (stderr, "programming error: WANTHOST hostname missing\n");
     31      gprint (GP_ERR, "programming error: WANTHOST hostname missing\n");
    3232      exit (2);
    3333    }

  • trunk/Ohana/src/opihi/pcontrol/CheckSystem.c

    r4763 r7917  
    3737    stack = GetHostStack (PCONTROL_HOST_BUSY);
    3838    Nbusy = stack[0].Nobject;
    39     fprintf (stderr, "busy, idle, down: %2d %2d %2d\n", Nbusy, Nidle, Ndown);
     39    gprint (GP_ERR, "busy, idle, down: %2d %2d %2d\n", Nbusy, Nidle, Ndown);
    4040  }
    4141
    … …  
    6363    dtime = DTIME (stop, start);
    6464  }
    65   if (0 && (Nobject > 0)) fprintf (stderr, "checked %d of %d jobs\n", i, Nobject);
     65  if (0 && (Nobject > 0)) gprint (GP_ERR, "checked %d of %d jobs\n", i, Nobject);
    6666  return (TRUE);
    6767}
    … …  
    8787    dtime = DTIME (stop, start);
    8888  }
    89   if (0 && (Nobject > 0)) fprintf (stderr, "checked %d of %d jobs\n", i, Nobject);
     89  if (0 && (Nobject > 0)) gprint (GP_ERR, "checked %d of %d jobs\n", i, Nobject);
    9090  return (TRUE);
    9191}
    … …  
    111111    dtime = DTIME (stop, start);
    112112  }
    113   if (0) fprintf (stderr, "checked %d hosts\n", i);
     113  if (0) gprint (GP_ERR, "checked %d hosts\n", i);
    114114  return (TRUE);
    115115}
    … …  
    140140    dtime = DTIME (stop, start);
    141141  }
    142   if (0) fprintf (stderr, "checked %d hosts\n", i);
     142  if (0) gprint (GP_ERR, "checked %d hosts\n", i);
    143143  return (TRUE);
    144144}
    … …  
    168168    dtime = DTIME (stop, start);
    169169  }
    170   if (0) fprintf (stderr, "checked %d hosts\n", i);
     170  if (0) gprint (GP_ERR, "checked %d hosts\n", i);
    171171  return (TRUE);
    172172}
    … …  
    193193    dtime = DTIME (stop, start);
    194194  }
    195   if (0) fprintf (stderr, "checked %d idle hosts\n", i);
     195  if (0) gprint (GP_ERR, "checked %d idle hosts\n", i);
    196196
    197197  stack = GetHostStack (PCONTROL_HOST_BUSY);
    … …  
    205205    dtime = DTIME (stop, start);
    206206  }
    207   if (0) fprintf (stderr, "checked %d busy hosts\n", i);
     207  if (0) gprint (GP_ERR, "checked %d busy hosts\n", i);
    208208  return (TRUE);
    209209}
    … …  
    213213  gettimeofday (&stop, (void *) NULL);
    214214  dtime = DTIME (stop, start);
    215   if (VerboseMode()) fprintf (stderr, "check 4: %f seconds\n", dtime);
     215  if (VerboseMode()) gprint (GP_ERR, "check 4: %f seconds\n", dtime);
    216216
    217217  gettimeofday (&start, (void *) NULL);

  • trunk/Ohana/src/opihi/pcontrol/GetJobOutput.c

    r4762 r7917  
    4040  switch (status) {
    4141    case -1:
    42       if (VerboseMode()) fprintf (stderr, "host %s is not responding\n", host[0].hostname);
     42      if (VerboseMode()) gprint (GP_ERR, "host %s is not responding\n", host[0].hostname);
    4343      return (FALSE);
    4444
    4545    case 0:
    46       if (VerboseMode()) fprintf (stderr, "host %s is down\n", host[0].hostname);
     46      if (VerboseMode()) gprint (GP_ERR, "host %s is down\n", host[0].hostname);
    4747      return (FALSE);
    4848
    4949    default:
    50       if (VerboseMode()) fprintf (stderr, "message received (GetJobOutput : %s)\n", cmd); 
     50      if (VerboseMode()) gprint (GP_ERR, "message received (GetJobOutput : %s)\n", cmd); 
    5151      /* drop extra bytes from pclient (not pclient:job) */
    5252      buffer[0].Nbuffer = Nstart + Nbytes;
    … …  
    5757  }
    5858
    59   fprintf (stderr, "programming error: should not reach here (GetJobOutput)\n");
     59  gprint (GP_ERR, "programming error: should not reach here (GetJobOutput)\n");
    6060  exit (1);
    6161}

  • trunk/Ohana/src/opihi/pcontrol/HostOps.c

    r4705 r7917  
    2828      return (HostPool_Off);
    2929    default:
    30       fprintf (stderr, "error: unknown host stack : programming error\n");
     30      gprint (GP_ERR, "error: unknown host stack : programming error\n");
    3131      exit (1);
    3232  }
    33   fprintf (stderr, "error: unknown host stack : programming error\n");
     33  gprint (GP_ERR, "error: unknown host stack : programming error\n");
    3434  exit (1);
    3535}
    … …  
    151151  host = GetHost (StackID, N);
    152152  if (host == NULL) {
    153     fprintf (stderr, "programming error! host missing from stack\n");
     153    gprint (GP_ERR, "programming error! host missing from stack\n");
    154154    exit (1);
    155155  }

  • trunk/Ohana/src/opihi/pcontrol/JobID.c

    r3203 r7917  
    2828}
    2929
    30 void PrintID (FILE *f, IDtype ID) {
     30void PrintID (gpDest dest, IDtype ID) {
    3131
    3232  unsigned short int word0, word1, word2, word3;
    … …  
    3737  word3 = 0xffff & (ID >> 48);
    3838
    39   fprintf (f, "%x.%x.%x.%x", word3, word2, word1, word0);
     39  gprint (dest, "%x.%x.%x.%x", word3, word2, word1, word0);
    4040}
    4141

  • trunk/Ohana/src/opihi/pcontrol/JobOps.c

    r4706 r7917  
    2828      return (JobPool_Crash);
    2929    default:
    30       fprintf (stderr, "error: unknown job stack : programming error\n");
     30      gprint (GP_ERR, "error: unknown job stack : programming error\n");
    3131      exit (1);
    3232  }
    33   fprintf (stderr, "error: unknown job stack : programming error\n");
     33  gprint (GP_ERR, "error: unknown job stack : programming error\n");
    3434  exit (1);
    3535}
    … …  
    151151  job = GetJob (StackID, N);
    152152  if (job == NULL) {
    153     fprintf (stderr, "programming error! job missing from stack\n");
     153    gprint (GP_ERR, "programming error! job missing from stack\n");
    154154    exit (1);
    155155  }
    … …  
    176176
    177177  PutJob (job, PCONTROL_JOB_PENDING, STACK_BOTTOM);
    178   fprintf (stderr, "added new job\n");
     178  gprint (GP_ERR, "added new job\n");
    179179  return (job[0].JobID);
    180180}
    … …  
    203203  host = (Host *) job[0].host;
    204204  if (host == NULL) {
    205     fprintf (stderr, "programming error: job has no host\n");
     205    gprint (GP_ERR, "programming error: job has no host\n");
    206206    exit (2);
    207207  }
    … …  
    213213  /* remove host from correct stack */
    214214  if (PullHost (host[0].HostID, host[0].stack) == NULL) {
    215     fprintf (stderr, "programming error: host is not found in current stack\n");
     215    gprint (GP_ERR, "programming error: host is not found in current stack\n");
    216216    exit (2);
    217217  }
    … …  
    226226  /* remove job from correct stack */
    227227  if (PullJob (job[0].JobID, job[0].stack) == NULL) {
    228     fprintf (stderr, "programming error: job is not found in current stack\n");
     228    gprint (GP_ERR, "programming error: job is not found in current stack\n");
    229229    exit (2);
    230230  }

  • trunk/Ohana/src/opihi/pcontrol/KillJob.c

    r4763 r7917  
    3232
    3333    case PCLIENT_GOOD:
    34       fprintf (stderr, "message received (KillJob)\n"); 
     34      gprint (GP_ERR, "message received (KillJob)\n"); 
    3535      break;
    3636
    3737    default:
    38       fprintf (stderr, "unknown status for pclient command: programming error\n"); 
     38      gprint (GP_ERR, "unknown status for pclient command: programming error\n"); 
    3939      exit (1);
    4040  }
    … …  
    4343  p = memstr (buffer.buffer, "STATUS", buffer.Nbuffer);
    4444  if (p == NULL) {
    45     fprintf (stderr, "missing STATUS in pclient message : programming error\n");
     45    gprint (GP_ERR, "missing STATUS in pclient message : programming error\n");
    4646    exit (1);
    4747  }
    48   fprintf (stderr, "client message: %s\n", buffer.buffer);
     48  gprint (GP_ERR, "client message: %s\n", buffer.buffer);
    4949  sscanf (p, "%*s %d", &status);
    5050  FreeIOBuffer (&buffer);
    51   fprintf (stderr, "client status: %d\n", status);
     51  gprint (GP_ERR, "client status: %d\n", status);
    5252
    5353  switch (status) {
    5454    case -1:
    55       fprintf (stderr, "programming error (syntax error to pclient)\n");
     55      gprint (GP_ERR, "programming error (syntax error to pclient)\n");
    5656      return (FALSE);
    5757      break;
    5858    case 0:
    59       fprintf (stderr, "failure to kill child process\n");
     59      gprint (GP_ERR, "failure to kill child process\n");
    6060      PutJob (job, PCONTROL_JOB_BUSY, STACK_BOTTOM);
    6161      return (FALSE);
    … …  
    6666      return (TRUE);
    6767    case 2:
    68       fprintf (stderr, "programming error (client has no job)\n");
     68      gprint (GP_ERR, "programming error (client has no job)\n");
    6969      return (FALSE);
    7070  }
    7171
    72   fprintf (stderr, "programming error : should not reach here (CheckJob)\n");
     72  gprint (GP_ERR, "programming error : should not reach here (CheckJob)\n");
    7373  exit (1);
    7474}

  • trunk/Ohana/src/opihi/pcontrol/ResetJob.c

    r4763 r7917  
    2121    case PCLIENT_DOWN:
    2222      /*** different behavior for ANYHOST, WANTHOST, NEEDHOST? ***/
    23       fprintf (stderr, "host %s is down\n", host[0].hostname);
     23      gprint (GP_ERR, "host %s is down\n", host[0].hostname);
    2424      HarvestHost (host[0].pid);
    2525      PutHost (host, PCONTROL_HOST_DOWN, STACK_BOTTOM);
    … …  
    2929    case PCLIENT_HUNG:
    3030      /*** should we consider a HUNG host DOWN? ***/
    31       fprintf (stderr, "host %s is not responding\n", host[0].hostname);
     31      gprint (GP_ERR, "host %s is not responding\n", host[0].hostname);
    3232      FreeIOBuffer (&buffer);
    3333      return (FALSE);
    3434
    3535    case PCLIENT_GOOD:
    36       fprintf (stderr, "message received (ResetJob)\n"); 
     36      gprint (GP_ERR, "message received (ResetJob)\n"); 
    3737      FreeIOBuffer (&buffer);
    3838      return (TRUE);
    3939
    4040    default:
    41       fprintf (stderr, "unknown status for pclient command: programming error\n"); 
     41      gprint (GP_ERR, "unknown status for pclient command: programming error\n"); 
    4242      exit (1);
    4343  }
    4444
    45   fprintf (stderr, "programming error in GetJobOutput (should not reach here)\n");
     45  gprint (GP_ERR, "programming error in GetJobOutput (should not reach here)\n");
    4646  exit (1);
    4747}

  • trunk/Ohana/src/opihi/pcontrol/StartHost.c

    r4705 r7917  
    1717  if (!pid) {     
    1818    /** failure to start: extend retry period **/
    19     if (VerboseMode()) fprintf (stderr, "failure to start %s\n", host[0].hostname);
     19    if (VerboseMode()) gprint (GP_ERR, "failure to start %s\n", host[0].hostname);
    2020    gettimeofday (&now, (void *) NULL);
    2121    if (ZTIME(host[0].nexttry) || ZTIME(host[0].lasttry)) {

  • trunk/Ohana/src/opihi/pcontrol/StartJob.c

    r4763 r7917  
    1313  host = (Host *) job[0].host;
    1414  if (host == NULL) {
    15     fprintf (stderr, "programming error: no assigned host\n");
     15    gprint (GP_ERR, "programming error: no assigned host\n");
    1616    exit (1);
    1717  }
    … …  
    3636  switch (status) {
    3737    case PCLIENT_DOWN:
    38       if (VerboseMode()) fprintf (stderr, "host %s is down\n", host[0].hostname);
     38      if (VerboseMode()) gprint (GP_ERR, "host %s is down\n", host[0].hostname);
    3939      goto failure;
    4040
    4141    case PCLIENT_HUNG:
    42       if (VerboseMode()) fprintf (stderr, "host %s is not responding\n", host[0].hostname);
     42      if (VerboseMode()) gprint (GP_ERR, "host %s is not responding\n", host[0].hostname);
    4343      goto failure;
    4444
    4545    case PCLIENT_GOOD:
    46       if (VerboseMode()) fprintf (stderr, "message received (StartJob)\n"); 
     46      if (VerboseMode()) gprint (GP_ERR, "message received (StartJob)\n"); 
    4747      break;
    4848
    4949    default:
    50       if (VerboseMode()) fprintf (stderr, "unknown status for pclient command: programming error\n"); 
     50      if (VerboseMode()) gprint (GP_ERR, "unknown status for pclient command: programming error\n"); 
    5151      exit (1);
    5252  }
    … …  
    5555  p = memstr (buffer.buffer, "STATUS", buffer.Nbuffer);
    5656  if (p == NULL) {
    57     fprintf (stderr, "programming error: missing STATUS in pclient message\n");
     57    gprint (GP_ERR, "programming error: missing STATUS in pclient message\n");
    5858    exit (1);
    5959  }
    … …  
    6161  switch (status) {
    6262    case -1:
    63       if (VerboseMode()) fprintf (stderr, "error in pclient child\n");
     63      if (VerboseMode()) gprint (GP_ERR, "error in pclient child\n");
    6464      goto failure;
    6565
    6666    case -2:
    67       fprintf (stderr, "programming error: syntax error in pclient command\n");
     67      gprint (GP_ERR, "programming error: syntax error in pclient command\n");
    6868      exit (1);
    6969
    7070    case -3:
    71       fprintf (stderr, "programming error: existing child on pclient\n");
     71      gprint (GP_ERR, "programming error: existing child on pclient\n");
    7272      exit (1);
    7373
    … …  
    8181  }
    8282  /* we should never reach here */
    83   fprintf (stderr, "programming error: should not reach here (StartJob)\n");
     83  gprint (GP_ERR, "programming error: should not reach here (StartJob)\n");
    8484  exit (1);
    8585

  • trunk/Ohana/src/opihi/pcontrol/StopHosts.c

    r4763 r7917  
    4141
    4242    case PCLIENT_HUNG:
    43       fprintf (stderr, "host %s is not responding\n", host[0].hostname);
     43      gprint (GP_ERR, "host %s is not responding\n", host[0].hostname);
    4444      break;
    4545
    … …  
    4848
    4949    default:
    50       fprintf (stderr, "unknown status for pclient command: programming error\n"); 
     50      gprint (GP_ERR, "unknown status for pclient command: programming error\n"); 
    5151      exit (1);
    5252  }
    … …  
    8383      switch (errno) {
    8484        case ECHILD:
    85           fprintf (stderr, "unknown PID, not a child proc\n");
    86           fprintf (stderr, "did process already exit?  programming error?\n");
     85          gprint (GP_ERR, "unknown PID, not a child proc\n");
     86          gprint (GP_ERR, "did process already exit?  programming error?\n");
    8787          break;
    8888        case EINVAL:
    89           fprintf (stderr, "error EINVAL (waitpid): programming error\n");
     89          gprint (GP_ERR, "error EINVAL (waitpid): programming error\n");
    9090          exit (1);
    9191        case EINTR:
    92           fprintf (stderr, "error EINTR (waitpid): programming error\n");
     92          gprint (GP_ERR, "error EINTR (waitpid): programming error\n");
    9393          exit (1);
    9494        default:
    95           fprintf (stderr, "unknown error for waitpid (%d): programming error\n", errno);
     95          gprint (GP_ERR, "unknown error for waitpid (%d): programming error\n", errno);
    9696          exit (1);
    9797      }
    … …  
    9999     
    100100    case 0:
    101       fprintf (stderr, "child did not exit??");
     101      gprint (GP_ERR, "child did not exit??");
    102102      /** put back in IDLE state? **/
    103103      break;
    … …  
    105105    default:
    106106      if (result != pid) {
    107         fprintf (stderr, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, pid);
     107        gprint (GP_ERR, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, pid);
    108108        exit (1);
    109109      }
    110110     
    111111      if (WIFEXITED(waitstatus)) {
    112         fprintf (stderr, "child exited with status %d\n", WEXITSTATUS(waitstatus));
     112        gprint (GP_ERR, "child exited with status %d\n", WEXITSTATUS(waitstatus));
    113113      }
    114114      if (WIFSIGNALED(waitstatus)) {
    115         fprintf (stderr, "child crashed with status %d\n", WTERMSIG(waitstatus));
     115        gprint (GP_ERR, "child crashed with status %d\n", WTERMSIG(waitstatus));
    116116      }
    117117      if (WIFSTOPPED(waitstatus)) {
    118         fprintf (stderr, "waitpid returns 'stopped': programming error\n");
     118        gprint (GP_ERR, "waitpid returns 'stopped': programming error\n");
    119119        exit (1);
    120120      }

  • trunk/Ohana/src/opihi/pcontrol/check.c

    r4689 r7917  
    1111
    1212  if (argc != 3) {
    13     fprintf (stdout, "USAGE: check job (JobID)\n");
    14     fprintf (stdout, "USAGE: check host (HostID)\n");
     13    gprint (GP_LOG, "USAGE: check job (JobID)\n");
     14    gprint (GP_LOG, "USAGE: check host (HostID)\n");
    1515    return (FALSE);
    1616  }
    … …  
    2020    job = FindJobStack (JobID);
    2121    if (job == NULL) {
    22       fprintf (stdout, "job not found\n");
     22      gprint (GP_LOG, "job not found\n");
    2323      return (FALSE);
    2424    }
    25     fprintf (stdout, "STATUS %s\n", jobstate[job[0].stack]);
    26     fprintf (stdout, "EXITST %d\n", job[0].exit_status);
    27     fprintf (stdout, "STDOUT %d\n", job[0].stdout_size);
    28     fprintf (stdout, "STDERR %d\n", job[0].stderr_size);
     25    gprint (GP_LOG, "STATUS %s\n", jobstate[job[0].stack]);
     26    gprint (GP_LOG, "EXITST %d\n", job[0].exit_status);
     27    gprint (GP_LOG, "STDOUT %d\n", job[0].stdout_size);
     28    gprint (GP_LOG, "STDERR %d\n", job[0].stderr_size);
    2929    return (TRUE);
    3030  }
    … …  
    3434    host = FindHostStack (HostID);
    3535    if (host == NULL) {
    36       fprintf (stdout, "host not found\n");
     36      gprint (GP_LOG, "host not found\n");
    3737      return (FALSE);
    3838    }
    39     fprintf (stdout, "host %s\n", hoststate[host[0].stack]);
     39    gprint (GP_LOG, "host %s\n", hoststate[host[0].stack]);
    4040    return (TRUE);
    4141  }
    4242
    43   fprintf (stdout, "unknown item to check\n");
     43  gprint (GP_LOG, "unknown item to check\n");
    4444  return (FALSE);
    4545}

  • trunk/Ohana/src/opihi/pcontrol/delete.c

    r4689 r7917  
    77
    88  if (argc < 2) {
    9     fprintf (stderr, "USAGE: delete (JobID)\n");
     9    gprint (GP_ERR, "USAGE: delete (JobID)\n");
    1010    return (FALSE);
    1111  }
    … …  
    2222  if (job != NULL) goto found;
    2323
    24   fprintf (stderr, "job %s not PENDING, CRASH, EXIT\n", argv[1]);
     24  gprint (GP_ERR, "job %s not PENDING, CRASH, EXIT\n", argv[1]);
    2525  return (FALSE);
    2626 
    … …  
    2828  {
    2929    int j;
    30     fprintf (stderr, "deleting job  %s  %d  ", job[0].hostname, job[0].argc);
     30    gprint (GP_LOG, "deleting job  %s  %d  ", job[0].hostname, job[0].argc);
    3131    for (j = 0; j < job[0].argc; j++) {
    32       fprintf (stderr, "%s ", job[0].argv[j]);
     32      gprint (GP_LOG, "%s ", job[0].argv[j]);
    3333    }
    34     PrintID (stderr, job[0].JobID);
    35     fprintf (stderr, "\n");
     34    PrintID (GP_LOG, job[0].JobID);
     35    gprint (GP_LOG, "\n");
    3636  } 
    3737  DelJob (job);

  • trunk/Ohana/src/opihi/pcontrol/host.c

    r4705 r7917  
    88
    99  if (argc != 3) {
    10     fprintf (stdout, "USAGE: host (command) (hostname)\n");
     10    gprint (GP_LOG, "USAGE: host (command) (hostname)\n");
    1111    return (FALSE);
    1212  }
    … …  
    1414  if (!strcasecmp (argv[1], "ADD")) {
    1515    HostID = AddHost (argv[2]);
    16     fprintf (stdout, "HostID: %d\n", (int) HostID);
     16    gprint (GP_LOG, "HostID: %d\n", (int) HostID);
    1717    return (TRUE);
    1818  }
    … …  
    2020    N = FindNamedHost (argv[2], PCONTROL_HOST_OFF);
    2121    if (N < 0) {
    22       fprintf (stdout, "host %s is not OFF\n", argv[2]);
     22      gprint (GP_LOG, "host %s is not OFF\n", argv[2]);
    2323      return (FALSE);
    2424    }
    … …  
    3030    N = FindNamedHost (argv[2], PCONTROL_HOST_DOWN);
    3131    if (N < 0) {
    32       fprintf (stdout, "host %s is not DOWN\n", argv[2]);
     32      gprint (GP_LOG, "host %s is not DOWN\n", argv[2]);
    3333      return (FALSE);
    3434    }
    … …  
    5252        return (TRUE);
    5353      case PCONTROL_HOST_DOWN:
    54         fprintf (stdout, "host %s is DOWN\n", argv[2]);
     54        gprint (GP_LOG, "host %s is DOWN\n", argv[2]);
    5555        return (TRUE);
    5656      case PCONTROL_HOST_OFF:
    57         fprintf (stdout, "host %s is OFF\n", argv[2]);
     57        gprint (GP_LOG, "host %s is OFF\n", argv[2]);
    5858        return (TRUE);
    5959      default:
    60         fprintf (stdout, "host %s not found\n", argv[2]);
     60        gprint (GP_LOG, "host %s not found\n", argv[2]);
    6161        return (FALSE);
    6262    }
    … …  
    8484      return (TRUE);
    8585    }
    86     fprintf (stdout, "host %s is not BUSY, IDLE, or DOWN\n", argv[2]);
     86    gprint (GP_LOG, "host %s is not BUSY, IDLE, or DOWN\n", argv[2]);
    8787    return (FALSE);
    8888  }
    … …  
    9090    N = FindNamedHost (argv[2], PCONTROL_HOST_OFF);
    9191    if (N < 0) {
    92       fprintf (stdout, "host %s is not OFF\n", argv[2]);
     92      gprint (GP_LOG, "host %s is not OFF\n", argv[2]);
    9393      return (FALSE);
    9494    }
    … …  
    9898  }
    9999 
    100   fprintf (stderr, "unknown host command %s\n", argv[1]);
    101   fprintf (stderr, "valid options: xxx\n");
     100  gprint (GP_ERR, "unknown host command %s\n", argv[1]);
     101  gprint (GP_ERR, "valid options: xxx\n");
    102102  return (FALSE);
    103103}

  • trunk/Ohana/src/opihi/pcontrol/job.c

    r4689 r7917  
    1717  if ((N = get_argument (argc, argv, "+host"))) {
    1818    if (Mode == PCONTROL_JOB_WANTHOST) {
    19       fprintf (stderr, "ERROR: -host and +host are incompatible\n");
     19      gprint (GP_ERR, "ERROR: -host and +host are incompatible\n");
    2020      FREE (Host);
    2121      return (FALSE);
    … …  
    3636
    3737  if (argc < 2) {
    38     fprintf (stderr, "USAGE: job [options] (arg0) (arg1) ... (argN)\n");
     38    gprint (GP_ERR, "USAGE: job [options] (arg0) (arg1) ... (argN)\n");
    3939    FREE (Host);
    4040    return (FALSE);
    … …  
    4848
    4949  JobID = AddJob (Host, Mode, Timeout, targc, targv);
    50   fprintf (stdout, "JobID: %d\n", (int) JobID);
     50  gprint (GP_LOG, "JobID: %d\n", (int) JobID);
    5151  return (TRUE);
    5252}

  • trunk/Ohana/src/opihi/pcontrol/jobstack.c

    r4714 r7917  
    88
    99  if (argc != 2) {
    10     fprintf (stdout, "USAGE: jobstack (jobstack)\n");
    11     fprintf (stdout, "       (jobstack) : pending, busy, exit, crash, hung, done\n");
     10    gprint (GP_ERR, "USAGE: jobstack (jobstack)\n");
     11    gprint (GP_ERR, "       (jobstack) : pending, busy, exit, crash, hung, done\n");
    1212    return (FALSE);
    1313  }
    … …  
    1616  stack = GetJobStackByName (argv[1]);
    1717  if (stack == NULL) {
    18     fprintf (stderr, "jobstack not found\n");
     18    gprint (GP_ERR, "jobstack not found\n");
    1919    return (FALSE);
    2020  }
    2121
    2222  /* print list */
    23   fprintf (stdout, "Njobs: %d\n", stack[0].Nobject);
     23  gprint (GP_LOG, "Njobs: %d\n", stack[0].Nobject);
    2424  for (i = 0; i < stack[0].Nobject; i++) {
    2525    job = stack[0].object[i];
    26     /* PrintID (stdout, job[0].JobID); */
    27     fprintf (stdout, "%lld ", job[0].JobID);
    28     fprintf (stdout, "%s  %s\n", job[0].argv[0], job[0].hostname);
     26    /* PrintID (GP_LOG, job[0].JobID); */
     27    gprint (GP_LOG, "%lld ", job[0].JobID);
     28    gprint (GP_LOG, "%s  %s\n", job[0].argv[0], job[0].hostname);
    2929  }
    3030  return (TRUE);

  • trunk/Ohana/src/opihi/pcontrol/kill.c

    r4689 r7917  
    77
    88  if (argc < 2) {
    9     fprintf (stderr, "USAGE: kill (JobID)\n");
     9    gprint (GP_ERR, "USAGE: kill (JobID)\n");
    1010    return (FALSE);
    1111  }
    … …  
    1515  job = PullJob (JobID, PCONTROL_JOB_BUSY);
    1616  if (job == NULL) {
    17     fprintf (stderr, "job %s not BUSY\n", argv[1]);
     17    gprint (GP_ERR, "job %s not BUSY\n", argv[1]);
    1818    /* make output message more readable by scheduler */
    1919    return (FALSE);

  • trunk/Ohana/src/opihi/pcontrol/pclient.c

    r4762 r7917  
    3232  if (status ==  0) return (PCLIENT_DOWN);
    3333  if (status == -1) return (PCLIENT_HUNG);
    34   /* fprintf (stderr, "buffer.buffer: %s\n", buffer[0].buffer); */
     34  /* gprint (GP_ERR, "buffer.buffer: %s\n", buffer[0].buffer); */
    3535  return (PCLIENT_GOOD);
    3636}

  • trunk/Ohana/src/opihi/pcontrol/pcontrol.c

    r5919 r7917  
    3838/* standard welcome message */
    3939void welcome () {
    40   fprintf (stderr, "\n");
    41   fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
     40  gprint (GP_ERR, "\n");
     41  gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description);
    4242}
    4343
    … …  
    4949
    5050void gotsignal (int signum) {
    51   fprintf (stderr, "got signal : %d\n", signum);
     51  gprint (GP_ERR, "got signal : %d\n", signum);
    5252  return;
    5353}

  • trunk/Ohana/src/opihi/pcontrol/pulse.c

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

  • trunk/Ohana/src/opihi/pcontrol/rconnect.c

    r4762 r7917  
    3434  pid = fork ();
    3535  if (!pid) { /* must be child process */
    36     if (VerboseMode()) fprintf (stderr, "starting remote connection to %s...", hostname);
     36    if (VerboseMode()) gprint (GP_ERR, "starting remote connection to %s...", hostname);
    3737
    3838    /* close the other ends of the pipes */
    … …  
    5252
    5353    status = execvp (argv[0], argv);
    54     fprintf (stderr, "error starting remote shell process\n");
     54    gprint (GP_ERR, "error starting remote shell process\n");
    5555    exit (1);
    5656  }
    … …  
    8585  if (status == 0) goto connect_error;
    8686  if (status == -1) goto connect_error;
    87   if (VerboseMode()) fprintf (stderr, "%d cycles to connect\n", i);
     87  if (VerboseMode()) gprint (GP_ERR, "%d cycles to connect\n", i);
    8888  FreeIOBuffer (&buffer);
    8989
    90   if (VerboseMode()) fprintf (stderr, "Connected\n");
     90  if (VerboseMode()) gprint (GP_ERR, "Connected\n");
    9191
    9292  stdio[0] = stdin_fd[1];
    … …  
    101101
    102102connect_error:
    103   if (VerboseMode()) fprintf (stderr, "error while connecting\n");
     103  if (VerboseMode()) gprint (GP_ERR, "error while connecting\n");
    104104
    105105  /* avoid blocking on waitpid, test every 100 usec, up to 50 msec */
    … …  
    116116
    117117  if ((result == -1) && (errno != ECHILD)) {
    118     fprintf (stderr, "unexpected error from waitpid (%d): programming error\n", errno);
     118    gprint (GP_ERR, "unexpected error from waitpid (%d): programming error\n", errno);
    119119    exit (1);
    120120  }
    121121  if (result == 0) {
    122     if (VerboseMode()) fprintf (stderr, "child did not exit??");
     122    if (VerboseMode()) gprint (GP_ERR, "child did not exit??");
    123123  }
    124124  if (result > 0) {
    125125    if (result != pid) {
    126       fprintf (stderr, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, pid);
     126      gprint (GP_ERR, "waitpid error: mis-matched PID (%d vs %d).  programming error\n", result, pid);
    127127      exit (1);
    128128    }
    129129    if (WIFSTOPPED(waitstatus)) {
    130       fprintf (stderr, "waitpid returns 'stopped': programming error\n");
     130      gprint (GP_ERR, "waitpid returns 'stopped': programming error\n");
    131131      exit (1);
    132132    }

  • trunk/Ohana/src/opihi/pcontrol/run.c

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

  • trunk/Ohana/src/opihi/pcontrol/status.c

    r4689 r7917  
    2828  stack = GetJobStack (Nstack);
    2929  Nobject = stack[0].Nobject;
    30   fprintf (stdout, "job stack %s:  %d objects\n", jobname[Nstack], Nobject);
     30  gprint (GP_LOG, "job stack %s:  %d objects\n", jobname[Nstack], Nobject);
    3131
    3232  for (i = 0; i < Nobject; i++) {
    3333    job = stack[0].object[i];
    34     fprintf (stdout, "%d  %s  %d  ", i, job[0].hostname, job[0].argc);
     34    gprint (GP_LOG, "%d  %s  %d  ", i, job[0].hostname, job[0].argc);
    3535    for (j = 0; j < job[0].argc; j++) {
    36       fprintf (stdout, "%s ", job[0].argv[j]);
     36      gprint (GP_LOG, "%s ", job[0].argv[j]);
    3737    }
    38     PrintID (stdout, job[0].JobID);
    39     fprintf (stdout, "\n");
     38    PrintID (GP_LOG, job[0].JobID);
     39    gprint (GP_LOG, "\n");
    4040  }
    4141  return (TRUE);
    … …  
    5050  stack = GetHostStack (Nstack);
    5151  Nobject = stack[0].Nobject;
    52   fprintf (stdout, "host stack %s:  %d objects\n", hostname[Nstack], Nobject);
     52  gprint (GP_LOG, "host stack %s:  %d objects\n", hostname[Nstack], Nobject);
    5353
    5454  for (i = 0; i < Nobject; i++) {
    5555    host = stack[0].object[i];
    56     fprintf (stdout, "%d  %s  ", i, host[0].hostname);
    57     PrintID (stdout, host[0].HostID);
    58     fprintf (stdout, "\n");
     56    gprint (GP_LOG, "%d  %s  ", i, host[0].hostname);
     57    PrintID (GP_LOG, host[0].HostID);
     58    gprint (GP_LOG, "\n");
    5959  }
    6060  return (TRUE);

  • trunk/Ohana/src/opihi/pcontrol/stdout.c

    r4689 r7917  
    88
    99  if (argc != 2) {
    10     fprintf (stderr, "USAGE: stdout (JobID)\n");
    11     fprintf (stdout, "STATUS %d\n", -1);
     10    gprint (GP_ERR, "USAGE: stdout (JobID)\n");
     11    gprint (GP_LOG, "STATUS %d\n", -1);
    1212    return (FALSE);
    1313  }
    … …  
    2323  buffer = &job[0].stdout;
    2424  fwrite (buffer[0].buffer, 1, buffer[0].Nbuffer, stdout);
    25   fprintf (stdout, "STATUS %d\n", 0);
     25  gprint (GP_LOG, "STATUS %d\n", 0);
    2626  return (TRUE);
    2727
    2828missing_stdout:
    29   fprintf (stderr, "job not found in EXIT or CRASH\n");
    30   fprintf (stdout, "STATUS %d\n", -2);
     29  gprint (GP_ERR, "job not found in EXIT or CRASH\n");
     30  gprint (GP_LOG, "STATUS %d\n", -2);
    3131  return (FALSE);
    3232}
    … …  
    3939
    4040  if (argc != 2) {
    41     fprintf (stderr, "USAGE: stderr (JobID)\n");
    42     fprintf (stdout, "STATUS %d\n", -1);
     41    gprint (GP_ERR, "USAGE: stderr (JobID)\n");
     42    gprint (GP_LOG, "STATUS %d\n", -1);
    4343    return (FALSE);
    4444  }
    … …  
    5454  buffer = &job[0].stderr;
    5555  fwrite (buffer[0].buffer, 1, buffer[0].Nbuffer, stdout);
    56   fprintf (stdout, "STATUS %d\n", 0);
     56  gprint (GP_LOG, "STATUS %d\n", 0);
    5757  return (TRUE);
    5858
    5959missing_stderr:
    60   fprintf (stderr, "job not found in EXIT or CRASH\n");
    61   fprintf (stdout, "STATUS %d\n", -2);
     60  gprint (GP_ERR, "job not found in EXIT or CRASH\n");
     61  gprint (GP_LOG, "STATUS %d\n", -2);
    6262  return (FALSE);
    6363}

  • trunk/Ohana/src/opihi/pcontrol/stop.c

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

  • trunk/Ohana/src/opihi/pcontrol/verbose.c

    r4575 r7917  
    77  if (argc == 1) {
    88    if (VERBOSE) {
    9       fprintf (stderr, "verbose mode ON\n");
     9      gprint (GP_ERR, "verbose mode ON\n");
    1010    } else {
    11       fprintf (stderr, "verbose mode OFF\n");
     11      gprint (GP_ERR, "verbose mode OFF\n");
    1212    }
    1313    return (TRUE);
    … …  
    2929  }
    3030
    31   fprintf (stderr, "USAGE: verbose (on/off/toggle)\n");
     31  gprint (GP_ERR, "USAGE: verbose (on/off/toggle)\n");
    3232  return (FALSE);
    3333}

  • trunk/Ohana/src/opihi/pcontrol/version.c

    r7080 r7917  
    44int version (int argc, char **argv) {
    55
    6   fprintf (stderr, "%s\n", name);
     6  gprint (GP_ERR, "%s\n", name);
    77
    8   fprintf (stderr, "%s\n", opihi_version());
    9   fprintf (stderr, "%s\n", ohana_version());
    10   fprintf (stderr, "%s\n", gfits_version());
     8  gprint (GP_ERR, "%s\n", opihi_version());
     9  gprint (GP_ERR, "%s\n", ohana_version());
     10  gprint (GP_ERR, "%s\n", gfits_version());
    1111
    12   fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__);
     12  gprint (GP_ERR, "compiled on %s %s\n", __DATE__, __TIME__);
    1313  return (TRUE);
    1414}
Note: See TracChangeset for help on using the changeset viewer.