chiark - git - mdw - mLib/blob - trace.c

   1 /* -*-c-*-
   2  *
   3  * $Id: trace.c,v 1.6 2001/02/03 16:23:55 mdw Exp $
   4  *
   5  * Tracing functions for debugging
   6  *
   7  * (c) 1998 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of the mLib utilities library.
  13  *
  14  * mLib is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU Library General Public License as
  16  * published by the Free Software Foundation; either version 2 of the
  17  * License, or (at your option) any later version.
  18  *
  19  * mLib is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Library General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Library General Public
  25  * License along with mLib; if not, write to the Free
  26  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  27  * MA 02111-1307, USA.
  28  */
  29
  30 /*----- Revision history --------------------------------------------------*
  31  *
  32  * $Log: trace.c,v $
  33  * Revision 1.6  2001/02/03 16:23:55  mdw
  34  * New custom trace output interface.
  35  *
  36  * Revision 1.5  1999/10/22 22:39:52  mdw
  37  * New documented interface for tracing.
  38  *
  39  * Revision 1.4  1999/05/19 20:27:11  mdw
  40  * Change naming to match newer mLib conventions.
  41  *
  42  * Revision 1.3  1999/05/06 19:51:35  mdw
  43  * Reformatted the LGPL notice a little bit.
  44  *
  45  * Revision 1.2  1999/05/05 18:50:31  mdw
  46  * Change licensing conditions to LGPL.
  47  *
  48  * Revision 1.1.1.1  1998/06/17 23:44:42  mdw
  49  * Initial version of mLib
  50  *
  51  */
  52
  53 /*----- Header files ------------------------------------------------------*/
  54
  55 /* --- ANSI headers --- */
  56
  57 #include <ctype.h>
  58 #include <stdarg.h>
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 /* --- Local headers --- */
  64
  65 #include "dstr.h"
  66 #include "quis.h"
  67 #include "trace.h"
  68
  69 /*----- Private state information -----------------------------------------*/
  70
  71 static void (*tracefunc)(const char *buf, size_t sz, void *v) = 0;
  72 static void *tracearg;
  73 static unsigned tracelvl = 0;           /* How much tracing gets done? */
  74
  75 /*----- Functions provided ------------------------------------------------*/
  76
  77 /* --- @t_file@ --- *
  78  *
  79  * Arguments:   @const char *buf@ = buffer to print
  80  *              @size_t sz@ = buffer size
  81  *              @void *v@ = file handle
  82  *
  83  * Returns:     ---
  84  *
  85  * Use:         Dumps tracing information to a file.
  86  */
  87
  88 static void t_file(const char *buf, size_t sz, void *v)
  89 {
  90   FILE *fp = v;
  91   fprintf(fp, "+ %s: ", QUIS);
  92   fwrite(buf, 1, sz, fp);
  93   fputc('\n', fp);
  94 }
  95
  96 /* --- @trace@ --- *
  97  *
  98  * Arguments:   @unsigned l@ = trace level for output
  99  *              @const char *f@ = a @printf@-style format string
 100  *              @...@ = other arguments
 101  *
 102  * Returns:     ---
 103  *
 104  * Use:         Reports a message to the trace output.
 105  */
 106
 107 void trace(unsigned l, const char *f, ...)
 108 {
 109   va_list ap;
 110   dstr d = DSTR_INIT;
 111   if ((l & tracing()) == 0)
 112     return;
 113   va_start(ap, f);
 114   dstr_vputf(&d, f, ap);
 115   va_end(ap);
 116   tracefunc(d.buf, d.len, tracearg);
 117   dstr_destroy(&d);
 118 }
 119
 120 /* --- @trace_block@ --- *
 121  *
 122  * Arguments:   @unsigned l@ = trace level for output
 123  *              @const char *s@ = some header string to write
 124  *              @const void *b@ = pointer to a block of memory to dump
 125  *              @size_t sz@ = size of the block of memory
 126  *
 127  * Returns:     ---
 128  *
 129  * Use:         Dumps the contents of a block to the trace output.
 130  */
 131
 132 void trace_block(unsigned l, const char *s, const void *b, size_t sz)
 133 {
 134   const unsigned char *p = b;
 135   size_t i;
 136   unsigned long o = 0;
 137   dstr d = DSTR_INIT;
 138   size_t c;
 139
 140   /* --- Skip if the trace level is too high --- */
 141
 142   if ((l & tracing()) == 0)
 143     return;
 144
 145   /* --- Now start work --- */
 146
 147   tracefunc(s, strlen(s), tracearg);
 148   while (sz) {
 149     dstr_reset(&d);
 150     dstr_putf(&d, "   %08lx : ", o);
 151     for (i = 0; i < 8; i++) {
 152       if (i < sz)
 153         dstr_putf(&d, "%02x ", p[i]);
 154       else
 155         dstr_puts(&d, "** ");
 156     }
 157     dstr_puts(&d, ": ");
 158     for (i = 0; i < 8; i++) {
 159       if (i < sz)
 160         dstr_putc(&d, isprint(p[i]) ? p[i] : '.');
 161       else
 162         dstr_putc(&d, '*');
 163     }
 164     dstr_putz(&d);
 165     tracefunc(d.buf, d.len, tracearg);
 166     c = (sz >= 8) ? 8 : sz;
 167     sz -= c, p += c, o += c;
 168   }
 169   dstr_destroy(&d);
 170 }
 171
 172 /* --- @trace_on@ --- *
 173  *
 174  * Arguments:   @FILE *fp@ = a file to trace on
 175  *              @unsigned l@ = trace level to set
 176  *
 177  * Returns:     ---
 178  *
 179  * Use:         Enables tracing to a file.
 180  */
 181
 182 void trace_on(FILE *fp, unsigned l)
 183 {
 184   tracefunc = t_file;
 185   tracearg = fp;
 186   if (!tracelvl)
 187     tracelvl = l;
 188 }
 189
 190 /* --- @trace_custom@ --- *
 191  *
 192  * Arguments:   @void (*func)(const char *buf, size_t sz, void *v)@ =
 193  *                      output function
 194  *              @void *v@ = magic handle to give to function
 195  *
 196  * Returns:     ---
 197  *
 198  * Use:         Sets up a custom trace handler.
 199  */
 200
 201 void trace_custom(void (*func)(const char */*buf*/,
 202                                size_t /*sz*/, void */*v*/),
 203                   void *v)
 204 {
 205   tracefunc = func;
 206   tracearg = v;
 207 }
 208
 209 /* --- @trace_level@ --- *
 210  *
 211  * Arguments:   @unsigned l@ = trace level to set
 212  *
 213  * Returns:     ---
 214  *
 215  * Use:         Sets the tracing level.
 216  */
 217
 218 void trace_level(unsigned l)
 219 {
 220   tracelvl = l;
 221 }
 222
 223 /* --- @tracing@ --- *
 224  *
 225  * Arguments:   ---
 226  *
 227  * Returns:     Zero if not tracing, tracing level if tracing.
 228  *
 229  * Use:         Informs the caller whether tracing is enabled.
 230  */
 231
 232 unsigned tracing(void)
 233 {
 234   return (tracefunc ? tracelvl : 0u);
 235 }
 236
 237 /*----- That's all, folks -------------------------------------------------*/