vcl/os2/source/app/printf.c

   1 /* ----------------------------------------------------------------- */
   2 /* PRINTF: diverts PRINTF calls to an OS/2 Named Queue               */
   3 /* Copyright (c) IBM Corporation, 1991, 1992                         */
   4 /* ----------------------------------------------------------------- */
   5 /* This version for OS/2 2.x, 32-bit programs.        Mike Cowlishaw */
   6 /*                                                                   */
   7 /* This routine, when linked into an .EXE instead of the usual C     */
   8 /* runtime, sends the edited result string to a named queue (if      */
   9 /* it exists).  If the queue does not exist, then all printf data    */
  10 /* are discarded (ignored).                                          */
  11 /*                                                                   */
  12 /* The result string is accumulated until a line feed (LF) character */
  13 /* is received; the whole line is then sent to the queue.  Lines are */
  14 /* automatically broken at a set (tailorable) length, if necessary.  */
  15 /*                                                                   */
  16 /* This routine may be tailored by altering the #defines at the      */
  17 /* top:                                                              */
  18 /*                                                                   */
  19 /*   PRINTFID      - An ID string that is prefixed to each line of   */
  20 /*                   data before being sent to the queue.  This      */
  21 /*                   can be any string, or the null string.          */
  22 /*   PRINTFMAXLEN  - Maximum length of string that can be formatted  */
  23 /*                   in a single call.                               */
  24 /*                   Results are unpredictable if this length is     */
  25 /*                   exceeded.  Default is 250.                      */
  26 /*   PRINTFLINELEN - Maximum length of a line that will be sent.     */
  27 /*                   This excludes the prefix and its blank.  If the */
  28 /*                   calls to printf cause a line to be generated    */
  29 /*                   that is longer than this, the line will be      */
  30 /*                   broken at this point.                           */
  31 /*   PRINTFTHREADS - Maximum number of threads expected.  This may   */
  32 /*                   need to be increased if the process limitation  */
  33 /*                   is removed, or you can save a little storage    */
  34 /*                   by decreasing it.  PRINTFs from threads larger  */
  35 /*                   than this number are ignored.                   */
  36 /*   PRINTFQNAME   - The name of the public queue that the result    */
  37 /*                   is to be sent to.  Normally '\QUEUES\PRINTF32'. */
  38 /*                   Note that the \QUEUES\ part is required.        */
  39 /*                                                                   */
  40 /* Returns:                                                          */
  41 /*   n: Count of data characters, if successfully received           */
  42 /*   0: If no queue existed (i.e., no server)                        */
  43 /*  <0: An error occurred (e.g., out of memory)                      */
  44 /*                                                                   */
  45 /* Restrictions:                                                     */
  46 /*   1. Total length of data (length of PRINTFID, + PRINTFMAXLEN)    */
  47 /*      must be less than 32K-1.                                     */
  48 /*   2. This has only been tested under IBM C Set/2 compiler.  It    */
  49 /*      may need modification for other compilers.                   */
  50 /*   3. This version uses a static array to point to the per-thread  */
  51 /*      data.  The code could be made read-only by hanging this      */
  52 /*      array (and the other static information) off a system-owned  */
  53 /*      anchor of some kind.                                         */
  54 /*   4. To use PRINTF within other than the main thread in a         */
  55 /*      program, that thread must be started with _beginthread       */
  56 /*      (not DosCreateThread).  This restriction is a consequence of */
  57 /*      the use of C library routines (sprintf) in PRINTF, and may   */
  58 /*      not apply to all compilers.                                  */
  59 /*   5. If the last PRINTF done by a thread does not end in '\n'     */
  60 /*      then the final part-line may be lost, or appear later.       */
  61 /*                                                                   */
  62 /* Protocol:                                                         */
  63 /*   PRINTF writes its data to the named queue using the following   */
  64 /*   protocol:                                                       */
  65 /*     Address -- Holds the address of the string to be sent. This   */
  66 /*                is a 0-terminated string) starting at offset 0.    */
  67 /*     Length  -- The length of the data, including terminator.      */
  68 /*                A negative length indicates a BELL in the data.    */
  69 /*     Request -- Timestamp (when queue was written) in C long       */
  70 /*                integer format (as returned by time()).            */
  71 /*                This may be 0L if not required.                    */
  72 /*                                                                   */
  73 /* Notes:                                                            */
  74 /*   1. PMPRINTF uses a queue and shared memory messages because:    */
  75 /*        (a) It makes collection at the receiving end very easy.    */
  76 /*        (b) I wanted to experiment with queues and shared memory.  */
  77 /*      This make not be the most cost-effective method.             */
  78 /*   2. Typical IBM C Set/2 compiler invocation:                     */
  79 /*        icc /c /Gm /O+ /Q /J /Kabgop                               */
  80 /*      If you get linking errors (duplicate symbols, etc.), try     */
  81 /*      recompiling PRINTF.C with the same options as you use for    */
  82 /*      your main program.                                           */
  83 /*   3. PRINTF sends the timestamp across the queue as a GMT long    */
  84 /*      integer, the result from a call to the C function time().    */
  85 /*      This will only be correct if the environment variable TZ has */
  86 /*      been set (e.g., TZ=EST5EDT), or you are in the same time     */
  87 /*      zone as the default for your compiler.                       */
  88 /*      For more information, see the tzset() function description   */
  89 /*      in your C compiler manual.                                   */
  90
  91 /* ----- Customization variables ----- */
  92 #define PRINTFID      ""
  93 #define PRINTFMAXLEN  300
  94 #define PRINTFLINELEN 100
  95 #define PRINTFTHREADS  54
  96 #define PRINTFQNAME   "\\QUEUES\\PRINTF32"
  97
  98 /* ----- Includes and externals ----- */
  99 #include <stdlib.h>                /* standard C functions */
 100 #include <stddef.h>                /* .. */
 101 #include <string.h>                /* .. */
 102 #include <time.h>                  /* .. */
 103 #include <stdarg.h>                /* .. */
 104 #include <stdio.h>                 /* (needed to pick up real name) */
 105 #define INCL_DOS                   /* Operating system definitions */
 106 #include <os2.h>                   /* For OS/2 functions */
 107
 108 #define max(a,b) (a>b ? a : b)
 109
 110 /* ----- Local defines ----- */
 111 #define PRINTFIDSIZE sizeof(PRINTFID)
 112 #define PRINTFMAXBUF PRINTFIDSIZE+PRINTFLINELEN
 113
 114 /* ----- Per-thread output buffer and current indices into line ---- */
 115 struct perthread {
 116   LONG   lineindex;                /* where next char */
 117   LONG   tidemark;                 /* rightmost char */
 118   int    bell;                     /* TRUE if line has bell */
 119   UCHAR  line[PRINTFMAXBUF];       /* accumulator */
 120   };
 121
 122 /* ----- Local static variables ----- */
 123 static ULONG  ourpid=0;            /* our process ID */
 124 static ULONG  servepid=0;          /* process IDs of the server */
 125 static HQUEUE qhandle=0;           /* handle for the queue */
 126 static struct perthread *tps[PRINTFTHREADS+1]; /* -> per-thread data */
 127
 128 /* ----- Local subroutine ----- */
 129 static int printf_(struct perthread *);
 130
 131 /* ----------------------------------------------------------------- */
 132 /* The "printf" function.  Note this has a variable number of        */
 133 /* arguments.                                                        */
 134 /* ----------------------------------------------------------------- */
 135 int debug_printf(const char *f, ...)
 136   {
 137   TIB    *ptib;                    /* process/thread id structures */
 138   PIB    *ppib;                    /* .. */
 139   TID    ourtid;                   /* thread ID */
 140   struct perthread *tp;            /* pointer to per-thread data */
 141   int    rc;                       /* returncode */
 142   ULONG  urc;                      /* returncode */
 143
 144   urc=DosOpenQueue(&servepid, &qhandle, PRINTFQNAME);  /* Open the Q */
 145   /* Non-0 RC means Q does not exist or cannot be opened */
 146   if (urc==343) return 0;          /* queue does not exist, so quit */
 147   if (urc!=0)   return -1;         /* report any other error */
 148
 149   /* First determine our thread ID (and hence get access to the      */
 150   /* correct per-thread data.  If the per-thread data has not been   */
 151   /* allocated, then allocate it now.  It is never freed, once       */
 152   /* allocated, as PRINTF is not notified of end-of-thread.          */
 153   DosGetInfoBlocks(&ptib,&ppib);   /* get process/thread info */
 154   ourtid=ptib->tib_ptib2->tib2_ultid;   /* .. and copy TID */
 155   if (ourtid>PRINTFTHREADS)        /* too many threads .. */
 156     return 0;                      /* .. so quit, quietly */
 157   tp=tps[ourtid];                  /* copy to local pointer */
 158   if (tp==NULL) {                  /* uninitialized (NULL=0) */
 159     /* allocate a per-thread structure */
 160     tp=(struct perthread *)malloc(sizeof(struct perthread));
 161     if (tp==NULL) return -1;       /* out of memory -- return error */
 162     tps[ourtid]=tp;                /* save for future calls */
 163     strcpy(tp->line,PRINTFID);     /* initialize: line.. */
 164     tp->lineindex=PRINTFIDSIZE-1;  /* ..where next char */
 165     tp->tidemark =PRINTFIDSIZE-2;  /* ..rightmost char */
 166     tp->bell=FALSE;                /* ..if line has bell */
 167     if (ourpid==0) ourpid=ppib->pib_ulpid;   /* save PID for all to use */
 168     }
 169
 170   { /* Block for declarations -- only needed if queue exists, etc. */
 171     LONG  count;                   /* count of characters formatted */
 172     UCHAR buffer[PRINTFMAXLEN+1];  /* formatting area */
 173     LONG  i, newind;               /* work */
 174     UCHAR ch;                      /* .. */
 175     va_list argptr;                /* -> variable argument list */
 176
 177     va_start(argptr, f);           /* get pointer to argument list */
 178     count=vsprintf(buffer, f, argptr);
 179     va_end(argptr);                /* done with variable arguments */
 180
 181     if (count<0) return count-1000;/* bad start */
 182
 183     if (count>PRINTFMAXLEN) {
 184       /* Disaster -- we are probably "dead", but just in case we */
 185       /* are not, carry on with truncated data. */
 186       count=PRINTFMAXLEN;
 187       }
 188     buffer[count]='\0';            /* ensure terminated */
 189     /* OK, ready to go with the data now in BUFFER                    */
 190     /* We copy from the formatted string to the output (line) buffer, */
 191     /* taking note of certain control characters and sending a line   */
 192     /* the queue whenever we see a LF control, or when the line       */
 193     /* fills (causing a forced break).                                */
 194     for (i=0; ; i++) {
 195       ch=buffer[i]; if (!ch) break;
 196       switch(ch) {
 197         case '\r':                 /* carriage return */
 198           tp->lineindex=PRINTFIDSIZE-1; /* back to start of line */
 199           break;
 200         case '\n':                 /* new line */
 201         case '\f':                 /* form feed */
 202           rc=printf_(tp);          /* print a line */
 203           if (rc!=0) return rc;    /* error */
 204           break;
 205         case '\t':                 /* tab */
 206           newind=tp->lineindex-PRINTFIDSIZE+1;   /* offset into data */
 207           newind=tp->lineindex+5-newind%5;    /* new index requested */
 208           if (newind>=PRINTFMAXBUF) newind=PRINTFMAXBUF;    /* clamp */
 209           for (; tp->lineindex<newind; tp->lineindex++) {
 210             if (tp->lineindex>tp->tidemark) {  /* beyond current end */
 211               tp->line[tp->lineindex]=' ';              /* add space */
 212               tp->tidemark=tp->lineindex;
 213               }
 214             }
 215           break;
 216         case '\v':                 /* vertical tab */
 217           /* ignore it */
 218           break;
 219         case '\b':                 /* backspace */
 220           tp->lineindex=max(tp->lineindex-1,PRINTFIDSIZE);
 221           break;
 222         case '\a':                 /* alert (bell) */
 223           tp->bell=TRUE;
 224           break;
 225         default:                   /* ordinary character */
 226           tp->line[tp->lineindex]=ch;
 227           if (tp->lineindex>tp->tidemark)  /* is rightmost.. */
 228             tp->tidemark=tp->lineindex;
 229           tp->lineindex++;                 /* step for next */
 230         } /* switch */
 231       if (tp->lineindex>=PRINTFMAXBUF) {
 232         rc=printf_(tp);            /* print a line */
 233         if (rc!=0) return rc;      /* error */
 234         }
 235
 236       } /* copy loop */
 237     return count;                  /* all formatted data processed */
 238     } /* block */
 239   } /* printf */
 240
 241 /* ----- printf_(tp) -- Local subroutine to send a line ------------ */
 242 /* A line has been completed (or overflowed): write it to the queue. */
 243 int printf_(struct perthread *tp)  /* pointer to per-thread data */
 244   {
 245   ULONG   urc;                     /* unsigned returncode */
 246   PSZ     pszTo, pszFrom;          /* character pointers */
 247   PVOID   addr;                    /* address of output data */
 248   long    size;                    /* total size of output data */
 249   time_t  timenow;                 /* holds current time */
 250
 251   tp->line[tp->tidemark+1]='\0';   /* add terminator */
 252   size=tp->tidemark+2;             /* total length of data */
 253
 254   /* Get some shared memory that can be given away */
 255   urc=DosAllocSharedMem(&addr, NULL, (unsigned)size,
 256     OBJ_GIVEABLE|PAG_WRITE|PAG_COMMIT);
 257   if (urc!=0) return -2;           /* error */
 258
 259   pszTo=addr;                      /* copy for clarity */
 260   pszFrom=&(tp->line[0]);          /* pointer to source */
 261   strcpy(pszTo,pszFrom);           /* copy the string to shared memory */
 262
 263   if (ourpid!=servepid) {          /* (no giveaway needed if to self) */
 264     urc=DosGiveSharedMem(addr, servepid, PAG_READ); /* give access */
 265     if (urc!=0) return -3;}        /* error */
 266
 267   /* Write the selector, size, and timestamp to the queue */
 268   if (tp->bell) size=-size;        /* BELL passed by negation */
 269   time(&timenow);                  /* optional - else use 0 */
 270   urc=DosWriteQueue(qhandle,       /* handle */
 271          (unsigned)timenow,        /* 'request' (timestamp) */
 272          (unsigned)size,           /* 'length'  (length/bell) */
 273                    addr,           /* 'address' (address) */
 274                    0);             /* priority (FIFO if enabled) */
 275   if (urc!=0) return -4;           /* error */
 276   if (ourpid!=servepid) {          /* if given away.. */
 277     urc=DosFreeMem(addr);          /* .. *we* are done with it */
 278     if (urc!=0) return -5;}        /* error */
 279   /* Reset the line buffer and indices */
 280   tp->lineindex=PRINTFIDSIZE-1;    /* where next char */
 281   tp->tidemark =PRINTFIDSIZE-2;    /* rightmost char */
 282   tp->bell     =FALSE;             /* true if line has bell */
 283   return 0;                        /* success! */
 284   } /* printf_ */