home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / gutil / trace.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-01-23  |  3.1 KB  |  227 lines
  1. # include    <useful.h>
  2. # include    <sccs.h>
  3.  
  4. SCCSID(@(#)trace.c    8.1    12/31/84)
  5.  
  6. # define    tTNCUTOFF    30
  7.  
  8. short        *tT;
  9. int        tTsize;
  10. char        *tTp, tTsav, tTany;
  11. int        (*tTsetf)();
  12. int        tTon(), tToff();
  13.  
  14. tTrace(argv, tflag, tvect, tsize)
  15. char    **argv;
  16. char    tflag;
  17. short    *tvect;
  18. int    tsize;
  19. {
  20.     register char    **pp;
  21.     register bool    rtval;
  22.  
  23.     tT = tvect;
  24.     tTsize = tsize;
  25.     tTsetf = tTon;
  26.     rtval = FALSE;
  27.  
  28.     for (pp = argv; *pp != NULL; pp++)
  29.     {
  30.         if ((*pp)[0] != '-' || (*pp)[1] != tflag)
  31.             continue;
  32.         tTflag(&(*pp)[2]);
  33.         rtval = TRUE;
  34.     }
  35.     return (rtval);
  36. }
  37. /*
  38. **  TTAMPER -- internal interface to set & clear trace flags
  39. **
  40. **    This routine is called from the ctlmod or whatever.
  41. **
  42. **    Parameters:
  43. **        line -- a line like the normal trace flag lines.
  44. **        tflag -- the trace flag to deal with.
  45. **        tvect -- a pointer to a trace vector.
  46. **        tsize -- the size of the trace vector.
  47. **
  48. **    Returns:
  49. **        ??
  50. **
  51. **    Side Effects:
  52. **        none.
  53. */
  54.  
  55. tTamper(line, tflag, tvect, tsize)
  56. char    *line;
  57. char    tflag;
  58. short    *tvect;
  59. int    tsize;
  60. {
  61.     register char    *p;
  62.     register char    *endp;
  63.     register bool    rtval;
  64.     char        save;
  65.     short        *otvect;
  66.     int        otsize;
  67.  
  68.     otvect = tT;
  69.     otsize = tTsize;
  70.     tT = tvect;
  71.     tTsize = tsize;
  72.     rtval = FALSE;
  73.  
  74.     for (p = line; *p != '\n' && *p != '\0'; p++)
  75.     {
  76.         switch (*p)
  77.         {
  78.           case '+':
  79.             tTsetf = tTon;
  80.             break;
  81.  
  82.           case '-':
  83.             tTsetf = tToff;
  84.             break;
  85.  
  86.           default:
  87.             continue;
  88.         }
  89.         if (*(++p) != tflag)
  90.         {
  91.             p--;
  92.             continue;
  93.         }
  94.  
  95.         for (endp = ++p; *endp != ' ' && *endp != '\t' && *endp != '\0' && *endp != '\n'; endp++)
  96.             continue;
  97.  
  98.         save = *endp;
  99.         *endp = '\0';
  100.  
  101.         tTflag(p);
  102.  
  103.         *endp = save;
  104.         p = --endp;
  105.         rtval = TRUE;
  106.     }
  107.     tT = otvect;
  108.     tTsize = otsize;
  109.     return (rtval);
  110. }
  111.  
  112. tTflag(args)
  113. char    *args;
  114. {
  115.     register int    fno;
  116.     int        f;
  117.  
  118.     tTany++;
  119.     tTp = args;
  120.     if (*tTp == '\0')
  121.     {
  122.         for (fno = tTNCUTOFF; fno < tTsize; fno++)
  123.             (*tTsetf)(fno, -1);
  124.         return;
  125.     }
  126.     do
  127.     {
  128.         fno = tTnext();
  129.         tTurn(fno);
  130.  
  131.         if (tTsav == '/')
  132.         {
  133.             f = fno + 1;
  134.             fno = tTnext();
  135.             while (f < fno)
  136.                 (*tTsetf)(f++, -1);
  137.             tTurn(fno);
  138.         }
  139.     }  while(tTsav != '\0');
  140. }
  141.  
  142. tTnext()
  143. {
  144.     register char    *c;
  145.     auto int    ix;
  146.  
  147.     c = tTp;
  148.     while (*tTp >= '0' && *tTp <= '9')
  149.         tTp++;
  150.     tTsav = *tTp;
  151.     *tTp = '\0';
  152.     ix = atoi(c);
  153.     *tTp++ = tTsav;
  154.     return (ix);
  155. }
  156.  
  157. tTurn(fno)
  158. register int    fno;
  159. {
  160.     register int    pt;
  161.  
  162.     if (tTsav == '.')
  163.     {
  164.         while (tTsav == '.')
  165.         {
  166.             pt = tTnext();
  167.             (*tTsetf)(fno, pt);
  168.         }
  169.     }
  170.     else
  171.         (*tTsetf)(fno, -1);
  172. }
  173.  
  174.  
  175. tTon(fun, pt)
  176. register int    fun;
  177. register int    pt;
  178. {
  179.     if (fun >= tTsize || fun < 0)
  180.         return;
  181.  
  182.     if (pt >= 0)
  183.         tT[fun] |= (1<<pt%16);
  184.     else
  185.         tT[fun] = 0177777;
  186. }
  187.  
  188.  
  189. tToff(fun, pt)
  190. register int    fun;
  191. register int    pt;
  192. {
  193.     if (fun >= tTsize || fun < 0)
  194.         return;
  195.  
  196.     if (pt >= 0)
  197.         tT[fun] ^= (1<<pt%16);
  198.     else
  199.         tT[fun] = 0;
  200. }
  201.  
  202.  
  203. /*
  204. **  CHECK TRACE FLAG AND PRINT INFORMATION
  205. **
  206. **    This routine is equivalent to
  207. **        if (tTf(m, n))
  208. **            printf(a1, a2, a3, a4, a5, a6);
  209. **
  210. **    and can be called to reduce process space.  The return value
  211. **    is the value of the flag.
  212. */
  213.  
  214. # define    tTf(a, b)    ((b < 0) ? tT[a] : (tT[a] & (1 << b)))
  215.  
  216. tTfp(m, n, a1, a2, a3, a4, a5, a6)
  217. int    m;
  218. int    n;
  219. char    *a1, *a2, *a3, *a4, *a5, *a6;
  220. {
  221.     register int    rtval;
  222.  
  223.     if (rtval = tTf(m, n))
  224.         printf(a1, a2, a3, a4, a5, a6);
  225.     return (rtval);
  226. }
  227.