IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 7917


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

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/libohana/include/ohana.h

    r7039 r7917  
    166166int EmptyIOBuffer (IOBuffer *buffer, int Nmax, int fd);
    167167void FreeIOBuffer (IOBuffer *buffer);
     168int PrintIOBuffer (IOBuffer *buffer, char *format, ...);
     169int vPrintIOBuffer (IOBuffer *buffer, char *format, va_list argp);
    168170
    169171/* communication functions */
    … …  
    173175int SendCommand (int device, int length, char *format, ...);
    174176int SendCommandV (int device, int length, char *format, va_list argp);
     177
     178char *CheckForMessage (IOBuffer *buffer);
    175179
    176180/*

  • trunk/Ohana/src/libohana/src/CommOps.c

    r5273 r7917  
    113113  return (TRUE);
    114114}
     115
     116/*
     117
     118 I need an alternative ExpectCommand function which appends to an existing buffer
     119 until the complete message is ready. 
     120
     121 A command looks like this (pre-determined length):
     122 NN bytes: XXXXX\0
     123
     124 A message looks like this (preceded by NBYTES command) :
     125 16 bytes: WORD NNN\0
     126 NNN bytes: message.... \0
     127
     128 the expect function needs to monitor the number of bytes already received
     129 we need to be able to call it repeatedly until the buffer is full.
     130
     131*/
     132
     133/* check if the first entry in the buffer corresponds to a message:
     134   A message looks like this (preceded by NBYTES command) :
     135    16 bytes: WORD NNN
     136    NNN bytes: message....
     137    note that the NULL bytes are not sent
     138  If a message is found, it is popped off the buffer and sent back as a
     139  complete line (the length portion is dropped)
     140*/
     141
     142char *CheckForMessage (IOBuffer *buffer) {
     143
     144  int Nbytes;
     145  char command[20], *line;
     146
     147  if (buffer[0].Nbuffer < 16) return NULL;
     148  memcpy (command, buffer[0].buffer, 16);
     149  command[16] = 0;
     150
     151  sscanf (command, "NBYTES: %d", &Nbytes);
     152
     153  if (buffer[0].Nbuffer < Nbytes + 16) return NULL;
     154
     155  ALLOCATE (line, char, Nbytes + 1);
     156  memcpy (line, &buffer[0].buffer[16], Nbytes);
     157  line[Nbytes] = 0;
     158
     159  buffer[0].Nbuffer -= Nbytes + 16;
     160  memmove (buffer[0].buffer, &buffer[0].buffer[Nbytes+16], buffer[0].Nbuffer);
     161  return (line);
     162}

  • trunk/Ohana/src/libohana/src/IOBufferOps.c

    r5273 r7917  
    8484  }
    8585}
     86
     87/* print to an IOBuffer (varargs form) */
     88int PrintIOBuffer (IOBuffer *buffer, char *format, ...) {
     89
     90  int status;
     91  va_list argp; 
     92
     93  va_start (argp, format);
     94  status = vPrintIOBuffer (buffer, format, argp);
     95  va_end (argp);
     96  return (status);
     97}
     98
     99/* print to an IOBuffer (va_list form) */
     100int vPrintIOBuffer (IOBuffer *buffer, char *format, va_list argp) {
     101
     102  /* add the output line to the given IOBuffer */
     103 
     104  int Nbyte, status;
     105  char tmp, *line;
     106
     107  Nbyte = vsnprintf (&tmp, 0, format, argp);
     108
     109  if (buffer[0].Nbuffer + Nbyte + 1 >= buffer[0].Nalloc) {
     110    buffer[0].Nalloc = buffer[0].Nbuffer + Nbyte + 64;
     111    REALLOCATE (buffer[0].buffer, char, buffer[0].Nalloc);
     112  }
     113
     114  vsnprintf (&buffer[0].buffer[buffer[0].Nbuffer], Nbyte + 1, format, argp);
     115  buffer[0].Nbuffer += Nbyte + 1;
     116  return (TRUE);
     117}
     118 

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