home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / misc / compsci / arcsgm.cpt / ARC SGML 1.0 / sgmlc / traceset.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  22.2 KB  |  628 lines
  1. #ifdef applec
  2. #pragma segment SegC
  3. #endif
  4. /******************************************************************************/
  5. /* C88 call to environ() replaced with call to (non-ANSI) getenv().           */
  6. /******************************************************************************/
  7. /* Traceend and tracegi: changed HITS to %08x.                                */
  8. /* TO DO: Revise all pointer formats (%04x) to work with far pointers also.   */
  9. /******************************************************************************/
  10. #include "sgmlincl.h"         /* #INCLUDE statements for SGML parser. */
  11. /******************************************************************************/
  12. /*lint -library                  Ignore failure to use library functions. */
  13. #include <stdio.h>            /* Stream I/O functions. */
  14. /*lint -restore                  End of library function declarations. */
  15. /******************************************************************************/
  16. /* Trace variables.
  17. */
  18. int  trace = 0;               /* Switch: 1=trace state transitions; 0=don't. */
  19. int atrace = 0;               /* Switch: 1=trace attribute activity; 0=don't. */
  20. int ctrace = 0;               /* Switch: 1=trace context checking; 0=don't. */
  21. int dtrace = 0;               /* Switch: 1=trace declaration parsing; 0=don't.*/
  22. int etrace = 0;               /* Switch: 1=trace entity activity; 0=don't.*/
  23. int gtrace = 0;               /* Switch: 1=trace group creations; 0=don't. */
  24. int itrace = 0;               /* Switch: 1=trace ID activity; 0=don't. */
  25. int mtrace = 0;               /* Switch: 1=trace MS activity; 0=don't. */
  26. int ntrace = 0;               /* Switch: 1=trace notation activity; 0=don't. */
  27. UNCH emd[] = "EMD";           /* For "EMD" parameter type in dtrace calls. */
  28. UNCH estype1[] =              /* For estore values in trace messages. */
  29.      " TMMMSEIXCNFPDLK";
  30. UNCH estype2[] =              /* For estore values in trace messages. */
  31.      "  DS            ";
  32. #ifdef THINK_C
  33. int TCgetenv(char *envv);                /* Mac THINK C trace toggling */
  34. int compar(const void *v1,const void *v2);
  35. #endif
  36. /******************************************************************************/
  37. #ifdef THINK_C
  38. #define TESTENV(name) (TCgetenv(name)!=0)
  39. #else
  40. #define TESTENV(name) (getenv(name)!=0)
  41. #endif
  42. /******************************************************************************/
  43. /* TRACESET: Set switches for tracing body of document.
  44.              If any environment value has been
  45.              set for a switch, the switch is set to 1.
  46. */
  47. void traceset()
  48. {
  49.       trace = TESTENV("T");
  50.      atrace = TESTENV("A");
  51.      ctrace = TESTENV("C");
  52.      dtrace = TESTENV("D");
  53.      etrace = TESTENV("E");
  54.      gtrace = TESTENV("G");
  55.      itrace = TESTENV("I");
  56.      mtrace = TESTENV("M");
  57.      ntrace = TESTENV("N");
  58.  
  59.      if (trace||atrace||ctrace||dtrace||etrace||gtrace||itrace||mtrace||ntrace)
  60.           printf(
  61. "\nTRACESET: state=%d;att=%d;con=%d;dcl=%d;ent=%d;grp=%d;id=%d;ms=%d;dcn=%d.",
  62.              trace,   atrace,ctrace,dtrace,etrace,gtrace,itrace,mtrace,ntrace);
  63. }
  64. /******************************************************************************/
  65. /* TRACEPRO: Set switches for tracing prolog.  If any environment value has been
  66.              set for a switch, the switch is set to 1.
  67. */
  68. void tracepro()
  69. {
  70.       trace = TESTENV("PT");
  71.      atrace = TESTENV("PA");
  72.      dtrace = TESTENV("PD");
  73.      etrace = TESTENV("PE");
  74.      gtrace = TESTENV("PG");
  75.      mtrace = TESTENV("PM");
  76.      ntrace = TESTENV("PN");
  77.  
  78.      if (trace||atrace||dtrace||etrace||gtrace||mtrace||ntrace) printf(
  79. "\nTRACEPRO: state=%d; att=%d; dcl=%d; ent=%d; grp=%d; ms=%d;  dcn=%d.",
  80.              trace,    atrace, dtrace, etrace, gtrace, mtrace, ntrace);
  81. }
  82. /******************************************************************************/
  83. /* TRACEPCB: Trace character just parsed and other pcb data.
  84. */
  85. void tracepcb(pcb)
  86. struct parse *pcb;
  87. {
  88.     int i;
  89.     
  90.     i = RSCC+FPOS+1-FBUF;
  91.      printf ("\n%-8s %2u-%2u-%2u-%2u from %c [%3d] in %s, %d:%d.",
  92.             (char *)pcb->pname, pcb->state, pcb->input, pcb->action,
  93.             pcb->newstate, ZAPEOL(*FPOS), *FPOS, (char *)ENTITY+1, RCNT,
  94.             i);
  95. }
  96. /******************************************************************************/
  97. /* TRACETKN: Trace character just read during token parse.
  98. */
  99. void tracetkn(scope, lextoke)
  100. int scope;
  101. UNCH lextoke[];               /* Lexical table for token and name parses. */
  102. { 
  103.     int i;
  104.     
  105.     i = RSCC+FPOS+1-FBUF;
  106.      printf("\nTOKEN    %2d-%2d       from %c [%3d] in %s, %d:%d.",
  107.             scope, lextoke[*FPOS],
  108.             ZAPEOL(*FPOS), *FPOS, (char *)(ENTITY+1), RCNT,
  109.             i);
  110. }
  111. /******************************************************************************/
  112. /* TRACEGML: Trace state of main SGML driver routine.
  113. */
  114. void tracegml(scb, pss, conactsw, conact)
  115. struct restate *scb;
  116. int pss, conactsw, conact;
  117. {
  118.   printf("\nSGML%02d   %2d-%2d-%2d-%2d in main driver; conactsw=%d; conact=%d.",
  119.          pss, scb[pss].sstate, scb[pss].sinput, scb[pss].saction,
  120.          scb[pss].snext, conactsw, conact);
  121. }
  122. /******************************************************************************/
  123. /* TRACEVAL: Trace parse of an attribute value that is a token list.
  124. */
  125. void traceval(pcb, atype, aval, tokencnt)
  126. struct parse *pcb;
  127. UNS atype;                    /* Type of token list expected. */
  128. UNCH *aval;                   /* Value string to be parsed as token list. */
  129. int tokencnt;                 /* Number of tokens found in attribute value. */
  130. { 
  131.      printf("\n%-8s %2d-%2d-%2d-%2d at %04x, atype=%02x, tokencnt=%d: ",
  132.             (char *)pcb->pname, pcb->state, pcb->input, pcb->action,
  133.             pcb->newstate, aval, atype, tokencnt);
  134.      printf("%s", (char *)aval);
  135. }
  136. /******************************************************************************/
  137. /* TRACESTK: Trace entry just placed on tag stack.
  138. */
  139. void tracestk(pts, ts2, etictr)
  140. struct tag *pts;              /* Stack entry for this tag. */
  141. int ts2;                      /* Stack depth. */
  142. int etictr;                   /* Number of "netok" tags on stack. */
  143. {
  144.      char *st2;
  145.  
  146.      printf("\nSTACK    %s begun; stack depth %d; tflag=%02x; etictr=%d",
  147.             (char *)(pts->tetd->etdgi+1), ts2, pts->tflags, etictr);
  148.           
  149.      if (pts->tsrm != SRMNULL)
  150.          st2 = (char *)(pts->tsrm[0]->ename+1);
  151.      else
  152.          st2 = "#EMPTY";
  153.          
  154.      printf(" srm=%s.", st2);
  155. }
  156. /******************************************************************************/
  157. /* TRACEDSK: Trace entry just removed from tag stack.
  158. */
  159. void tracedsk(pts, ptso, ts3, etictr)
  160. struct tag *pts;              /* Stack entry for new open tag. */
  161. struct tag *ptso;             /* Stack entry for tag just ended. */
  162. int ts3;                      /* Stack depth. */
  163. int etictr;                   /* Number of "netok" tags on stack. */
  164. {
  165.      char *st2;
  166.     
  167.      printf(
  168. "\nDESTACK  %s ended; otflag=%02x; %s resumed; depth=%d; tflag=%02x; etictr=%d",
  169.            (char *)(ptso->tetd->etdgi+1), ptso->tflags,
  170.            pts->tetd->etdgi+1, ts3, pts->tflags, etictr);
  171.       
  172.      if (pts->tsrm != SRMNULL)
  173.          st2 = (char *)(pts->tsrm[0]->ename+1);
  174.      else
  175.          st2 = "#EMPTY";
  176.          
  177.      printf(" srm=%s.", st2);
  178. }
  179. /******************************************************************************/
  180. /* TRACECON: Trace interactions between content parse and stag/context
  181.              processing.
  182. */
  183. void tracecon(etagimct, dostag, datarc, pcb, conrefsw, didreq)
  184. int etagimct;                 /* Implicitly ended elements left on stack. */
  185. int dostag;                   /* 1=retry newetd instead of parsing; 0=parse. */
  186. int datarc;                   /* Return code for data: DAF_ or REF_ or zero. */
  187. struct parse *pcb;            /* Parse control block for this parse. */
  188. int conrefsw;                 /* 1=content reference att specified; 0=no. */
  189. int didreq;                   /* 1=required implied empty tag processed; 0=no.*/
  190. {
  191.      printf("\nCONTENT  etagimct=%d dostag=%d datarc=%d pname=%s action=%d \
  192. conrefsw=%d didreq=%d",
  193.            etagimct, dostag, datarc, pcb->pname, pcb->action, conrefsw, didreq);
  194. }
  195. /******************************************************************************/
  196. /* TRACESTG: Trace start-tag context validation input and results.
  197. */
  198. void tracestg(curetd, dataret, rc, nextetd, mexts)
  199. struct etd *curetd;           /* The etd for this tag. */
  200. int dataret;                  /* Data pending: DAF_ REF_ 0=not #PCDATA. */
  201. int rc;                       /* Return code from context or other test. */
  202. struct etd *nextetd;          /* The etd for a forced start-tag (if rc==2). */
  203. int mexts;                    /* >0=stack level of minus grp; -1=plus; 0=none.*/
  204. {
  205.     printf("\nSTARTTAG newetd=%08lx; dataret=%d; rc=%d; nextetd=%08lx; mexts=%d.",
  206.            curetd, dataret, rc, nextetd, mexts);
  207. }
  208. /******************************************************************************/
  209. /* TRACEETG: Trace end-tag matching test on stack.
  210. */
  211. void traceetg(pts, curetd, tsl, etagimct)
  212. struct tag *pts;              /* Stack entry for this tag. */
  213. struct etd *curetd;           /* The etd for this tag. */
  214. int tsl;                      /* Temporary stack level for looping. */
  215. int etagimct;                 /* Num of implicitly ended tags left on stack. */
  216. {
  217.      printf(
  218. "\nENDTAG   tsl=%d; newetd=%08lx; stacketd=%08lx; tflags=%02x; etagimct=%d.",
  219.             tsl, curetd, pts->tetd, pts->tflags, etagimct);
  220. }
  221. /******************************************************************************/
  222. /* TRACEECB: Trace entity control block activity.
  223. */
  224. void traceecb(action, p)
  225. UNCH *action;
  226. struct entity *p;
  227. {
  228.      char *st2;
  229.     
  230.      printf("\n%-8s (es=%d) type %c%c entity %s at %08lx containing ",
  231.            action, es, estype1[p->estore], estype2[p->estore], (char *)(p->ename+1), p);
  232.      if (p->estore==ESS || p->estore==ESE) {
  233.             if (p->etx.e == ETDNULL)
  234.                     st2 = "null";
  235.                 else
  236.                     st2 = (char *)(p->etx.e->etdgi+1);
  237.                 printf("%s tag.", st2);
  238.      } else if (p->estore==ESN && strcmp((char *)action, "ENTDEF")) traceesn(p->etx.n);
  239.      else if (p->etx.x==0) printf("[NOTHING]");
  240.      else {
  241.              if (*(p->etx.c+1))
  242.                  st2 = (char *)(p->etx.c+1);
  243.              else
  244.                  st2 = "[EMPTY]";
  245.              printf("%s", st2);
  246.      }
  247. }
  248. /******************************************************************************/
  249. /* TRACEDCN: Trace data content notation activity.
  250. */
  251. void tracedcn(p)
  252. struct dcncb *p;
  253. {
  254.      char *st1;
  255.      
  256.      if (p->dcnid != 0)
  257.          st1 = (char *)((UNCH *)p->dcnid+1);
  258.      else
  259.          st1 = "[UNDEFINED]";
  260.      
  261.      printf(
  262. "\nDCN      dcn=%08lx; adl=%04x; notation is %s=>%s",
  263.             p, p->adl, (char *)(p->ename+1), st1);
  264.      if (p->adl) traceadl(p->adl);
  265. }
  266. /******************************************************************************/
  267. /* TRACEESN: Print a data entity control block.
  268. */
  269. void traceesn(p)
  270. PNE p;
  271. {
  272.      char *st1, *st2, *st3;
  273.      
  274.      if (NEENAME(p) != 0)
  275.          st1 = (char *)(((STRING)NEENAME(p))+1);
  276.      else
  277.          st1 = "[UNDEFINED]";
  278.          
  279.      if (NEXTYPE(p) == 1)
  280.          st2 = "CDATA";
  281.      else if (NEXTYPE(p) == 2)
  282.          st2 = "NDATA";
  283.      else
  284.          st2 = "SDATA";
  285.          
  286.      if (NEID(p) != 0)
  287.          st3 = (char *)(((STRING)NEID(p))+1);
  288.      else
  289.          st3 = "[UNDEFINED]";
  290.          
  291.      printf("\nESN      Entity name is %s; entity type is %s.", st1, st2);
  292.      printf("\n         System ID is %s", st3);
  293.      if (p->nedcn!=0) tracedcn(p->nedcn);
  294. }
  295. /******************************************************************************/
  296. /* TRACESRM: Print the members of a short reference map.
  297. */
  298. void tracesrm(action, pg, gi)
  299. UNCH *action;
  300. TECB pg;
  301. UNCH *gi;
  302. {
  303.           char *st2;
  304.           int i = 0;               /* Loop counter. */
  305.  
  306.      
  307.  
  308.      if (pg==SRMNULL) printf("\n%-8s SHORTREF table empty for %s.", action, gi);
  309.      else {
  310.            st2 = gi ? (char *)gi : "definition";
  311.           printf("\n%-8s %s at %08lx mapped for %s.",
  312.                  action, (char *)(pg[0]->ename+1), (unsigned long)pg, st2);
  313.           while (++i<=lex.s.dtb[0].mapdata)
  314.               if (pg[i]) {
  315.                printf("\n%14s%02u %08lx %s", "SR", i, (unsigned long)pg[i],
  316.                            (char *)(pg[i]->ename+1));
  317.           }
  318.      }
  319. }
  320. /******************************************************************************/
  321. /* TRACEADL: Print an attribute definition list.
  322. */
  323. void traceadl(al)
  324. struct ad al[];
  325. {
  326.      char *st1, *st2;
  327.      unsigned long addr1, addr2, addr3;
  328.      int v1;
  329.      unsigned int u1;
  330.      int i=0;
  331.  
  332.      if (AN == 1)
  333.          st1 = "e";
  334.      else
  335.          st1 = "es";
  336.      if (ADN == 1)
  337.          st2 = "r";
  338.      else
  339.          st2 = "rs";
  340.      addr1 = (unsigned long)al;
  341.      printf("\nADLIST   %08lx %d membe%s; %d attribut%s",
  342.            addr1, ADN, st2, AN, st1);
  343.      while (++i<=ADN) {
  344.            if (BITOFF(ADFLAGS(i), AGROUP) && ADTYPE(i)<=ANOTEGRP)
  345.                st1 = "\n          %08lx %-8s %02x %02x %2d %02x %08lx %08lx";
  346.            else
  347.                st1 = "\n    %08lx %-8s %02x %02x %2d %02x %08lx %08lx ";
  348.            st2 = (char *)ADNAME(i);
  349.            addr3 = (unsigned long)&al[i];
  350.            addr1 = (unsigned long)ADVAL(i);
  351.            addr2 = (unsigned long)ADDATA(i).x;
  352.            u1 = ADLEN(i);
  353.           printf(st1,
  354.                addr3, st2, ADFLAGS(i), ADTYPE(i), ADNUM(i), u1, addr1, addr2);
  355.           if (ADVAL(i)) {
  356.           /*   write(stdout, ADVAL(i)+1, *ADVAL(i)-2); */
  357.                  v1 = (unsigned char)*ADVAL(i)-2;
  358.                printf("%*s", v1, (char *)(ADVAL(i)+1));
  359.                if (ADTYPE(i)==AENTITY && ADDATA(i).n!=0) {
  360.                     printf("=>");
  361.                     traceesn(ADDATA(i).n);
  362.                } else if (ADTYPE(i)==ANOTEGRP) {
  363.                        if (ADDATA(i).x!=0)
  364.                            st1 = (char *)(((STRING)ADDATA(i).x)+1);
  365.                        else
  366.                            st1 = "[UNDEFINED]";
  367.                     printf("=>%s", st1);
  368.                }
  369.           } else {
  370.                  if (GET(ADFLAGS(i), AREQ))
  371.                          st1 = "REQUIRED";
  372.                  else if (GET(ADFLAGS(i), ACURRENT))
  373.                          st1 = "CURRENT";
  374.                  else
  375.                          st1 = "NULL";
  376.                  printf("[%s]",st1);
  377.           }
  378.      }
  379.     printf("\n");
  380. }
  381. /******************************************************************************/
  382. /* TRACEMOD: Print the members of a model.
  383. */
  384. void tracemod(pg)
  385. struct thdr pg[];
  386. {
  387.      int i=0;
  388.  
  389.      printf("\nMODEL    %08lx %02x %d", (unsigned long)&pg[0], (int)&pg[0].ttype, (int)pg[0].tu.tnum);
  390.      while (++i <= pg[0].tu.tnum) {
  391.           if (GET(pg[i].ttype, TTMASK)==TTETD) {
  392.                printf("\n                      %08lx %02x %s",
  393.                            (unsigned long)&pg[i], (int)(pg[i].ttype),
  394.                            (char *)(pg[i].tu.thetd->etdgi+1));
  395.           } else if (GET(pg[i].ttype, TTMASK)==TTCHARS) {
  396.                printf("\n                      %08lx %02x %s", (unsigned long)&pg[i],
  397.                            (int)pg[i].ttype, "#PCDATA");
  398.           } else {
  399.                 printf("\n         %08lx %02x %d", (unsigned long)&pg[i],
  400.                             (int)pg[i].ttype, (int)pg[i].tu.tnum);
  401.            }
  402.      }
  403.      printf("\n");
  404. }
  405. /******************************************************************************/
  406. /* TRACEGRP: Print the members of a name (i.e., etd) group.
  407. */
  408. void tracegrp(pg)
  409. struct etd *pg[];
  410. {
  411.      int i = -1;              /* Loop counter. */
  412.  
  413.      printf("\nETDGRP   %08lx", (unsigned long)pg);
  414.      while (pg[++i]!=0) {
  415.          printf("\n         %08lx %s", (unsigned long)pg[i], (char *)(pg[i]->etdgi+1));
  416.      }
  417. }
  418. /******************************************************************************/
  419. /* TRACENGR: Print the members of a notation (i.e., dcncb) group.
  420. */
  421. void tracengr(pg)
  422. struct dcncb *pg[];
  423. {
  424.      int i = -1;              /* Loop counter. */
  425.  
  426.      printf("\nDCNGRP   %08lx", pg);
  427.      while (pg[++i]!=0) {
  428.          printf("\n         %08lx %s", pg[i], (char *)(pg[i]->ename+1));
  429.      }
  430. }
  431. /******************************************************************************/
  432. /* TRACEETD: Print an element type definition.
  433. */
  434. void traceetd(p)
  435. struct etd *p;                /* Pointer to an etd. */
  436. {
  437.      char *stp2;
  438.      
  439.      if (p->etdsrm == SRMNULL) 
  440.          stp2 = "#EMPTY";
  441.      else if (p->etdsrm != 0)
  442.          stp2 = (char *)(p->etdsrm[0]->ename+1);
  443.      else
  444.          stp2 = "#CURRENT";
  445.      
  446.      printf(
  447. "\nETD      etd=%08lx %s min=%04x cmod=%08lx ttype=%02x mex=%08lx,\n",
  448.             (unsigned long)p, (char *)(p->etdgi+1), (unsigned int)p->etdmin,
  449.             (unsigned long)p->etdmod, (int)p->etdmod->ttype, (unsigned long)p->etdmex);
  450.      printf("         pex=%08lx, adl=%08lx, srm=%s.", (unsigned long)p->etdpex,
  451.              (unsigned long)p->adl, stp2);
  452. }
  453. /******************************************************************************/
  454. /* TRACEID: Print an ID control block.
  455. */
  456. void traceid(action, p)
  457. UNCH *action;
  458. struct id *p;                 /* Pointer to an ID. */
  459. {
  460.      
  461.      printf("\n%-8s %s at %08lx is ", action, (char *)(p->idname+1), p);
  462.      if (p->idl) {
  463.          printf("ID of %s in %s, %d:%d; ", (char *)(p->idl->letdgi+1),
  464.                  (char *)(p->idl->lename+1), p->idl->lrcnt, p->idl->lccnt);
  465.      } else
  466.          printf("an undefined ID; ");
  467.      printf("hits=%08lx last ref=%04x", idrefl, p->idrl);
  468. }
  469. /******************************************************************************/
  470. /* TRACEMD: Trace a markup declaration parameter.
  471. */
  472. void tracemd(parmid)
  473. UNCH *parmid;                 /* Parameter identifier. */
  474. {
  475.      char *st2;
  476.      
  477.      if (subdcl)
  478.          st2 = (char *)subdcl;
  479.      else
  480.          st2 = "[NONE]";
  481.          
  482.      printf("\nMDPARM   %-8s for %-8s, token %02d, type %02u, %s.",
  483.            (char *)mdname, st2, parmno, pcbmd.action, (char *)parmid);
  484. }
  485. /******************************************************************************/
  486. /* TRACEMAP: Trace a map search.
  487. */
  488. void tracemap(mapnm, key, data)
  489. UNCH *mapnm;                  /* Name in map being searched. */
  490. UNCH *key;                    /* Search key. */
  491. int data;                     /* Data associated with key in map. */
  492. {
  493.      printf("\nMAPSRCH  %s == %-8s=>%d", key, mapnm, data);
  494. }
  495. /******************************************************************************/
  496. /* TRACEMS: Trace marked section activity.
  497. */
  498. void tracems(action, code, mslevel, msplevel)
  499. int action;                   /* 1=began new level; 0=resumed previous. */
  500. int code;
  501. int mslevel;                  /* Nesting level of marked sections. */
  502. int msplevel;                 /* Nested MS levels subject to special parse. */
  503. {
  504.      printf("\nMS%c      %2d                 %s nesting level %d (msp %d).",
  505.           (action ? ' ' : 'E'), code, (action ? "began" : "resumed"),
  506.           mslevel, msplevel);
  507. }
  508. /******************************************************************************/
  509. #define STATUX tags[ts].status/* Token status: RCHIT RCMISS RCEND RCREQ RCNREQ*/
  510. #define M      pos[0].g       /* Index of current token in model. */
  511. #define P      pos[0].t       /* Index of current group in pos. */
  512. #define G      pos[P].g       /* Index of current group in model. */
  513. #define T      pos[P].t       /* Index of current token in its group. */
  514. #define H      pos[P].h       /* Hit bits for current group's tokens (1=hit). */
  515. #define GHDR   mod[G]         /* Current group header. */
  516. #define TOKEN  mod[M]         /* Current token. */
  517. #define TTYPE (GET(TOKEN.ttype, TTMASK))  /* Token type of current token. */
  518. #define TOCC  (GET(TOKEN.ttype, TOREP))   /* Occurrence for current token. */
  519. #define GTYPE (GET(GHDR.ttype, TTMASK))   /* Token type of current group. */
  520. #define GOCC  (GET(GHDR.ttype, TOREP))    /* Occurrence for current group. */
  521. #define GNUM  GHDR.tu.tnum                /* Number of tokens in current grp. */
  522. /******************************************************************************/
  523. /* TRACEGI: Trace GI testing stages in CONTEXT.C processing.
  524. */
  525. void tracegi(stagenm, gi, mod, pos, Tstart)
  526. UNCH *stagenm;
  527. struct etd *gi;               /* ETD of new GI. */
  528. struct thdr mod[];            /* Model of current open element. */
  529. struct mpos pos[];            /* Position in open element's model. */
  530. int Tstart;                   /* Initial T for this group. */
  531. {
  532.      char *st2, *st3;
  533.      int i = 0;               /* Loop counter. */
  534.  
  535.      printf("\n%-10s %d:", (char *)stagenm, P);
  536.      while (++i<=P) printf(" %d-%d", pos[i].g, pos[i].t);
  537.      printf(" (%u) gocc=%02x gtype=%02x gnum=%d H=%08lx status=%d Tstart=%d",
  538.             M, GOCC, GTYPE, GNUM, (unsigned long)H, STATUX, Tstart);
  539.      if (TTYPE)
  540.          if (TTYPE==TTETD)
  541.              st2 = (char *)(TOKEN.tu.thetd->etdgi+1);
  542.          else
  543.              st2 = "#GROUP";
  544.      else
  545.          st2 = "#PCDATA";
  546.      if (gi==ETDCDATA)
  547.          st3 = "#PCDATA";
  548.      else
  549.          st3 = (char *)(gi->etdgi+1);
  550.      printf("\n=>%-8s tocc=%02x ttype=%02x thetd=%08lx (%s) gietd=%08lx (%s)",
  551.           (char *)(tags[ts].tetd->etdgi+1), TOCC, TTYPE, (unsigned long)TOKEN.tu.thetd,
  552.           st2, (unsigned long)gi, st3);
  553. }
  554. /******************************************************************************/
  555. /* TRACEEND: Trace testing for end of group in CONTEXT.C processing.
  556. */
  557. void traceend(stagenm, mod, pos, rc, opt, Tstart)
  558. UNCH *stagenm;
  559. struct thdr mod[];            /* Model of current open element. */
  560. struct mpos pos[];            /* Position in open element's model. */
  561. int rc;                       /* Return code: RCNREQ RCHIT RCMISS RCEND */
  562. int opt;                      /* ALLHIT parm: 1=test optionals; 0=ignore. */
  563. int Tstart;                   /* Initial T for this group. */
  564. {
  565.      char *st2;
  566.      int i = 0;               /* Loop counter. */
  567.  
  568.      printf("\n%-10s %d:", stagenm, P);
  569.      while (++i<=P) printf(" %d-%d", pos[i].g, pos[i].t);
  570.      printf(" (%u) gocc=%02x gtype=%02x gnum=%d H=%08lx status=%d Tstart=%d",
  571.             M, GOCC, GTYPE, GNUM, (unsigned long)H, STATUX, Tstart);
  572.      if (TTYPE) {
  573.          if (TTYPE==TTETD)
  574.              st2 = (char *)(TOKEN.tu.thetd->etdgi+1);
  575.          else
  576.              st2 = "#GROUP";
  577.      } else
  578.          st2 = "#PCDATA";
  579.      printf("\n=>%-8s tocc=%02x ttype=%02x thetd=%08lx (%s)",
  580.            (char *)(tags[ts].tetd->etdgi+1), TOCC, TTYPE, (unsigned long)TOKEN.tu.thetd,
  581.            st2);
  582.      printf(" rc=%d offbitT=%d allhit=%d",
  583.            rc, (int)offbit(H, (int)T, GNUM), (int)allhit(&GHDR, H, 0, opt));
  584. }
  585. /******************************************************************************/
  586. #ifdef THINK_C
  587. /* Routines to toggle tracing in THINK C environment for Macintosh */
  588. struct tvs {
  589.     char *tvname;
  590.     int    tvval;
  591. } tvs[] = {
  592.     "A",    1,
  593.     "C",    1,
  594.     "D",    1,
  595.     "E",    1,
  596.     "G",    1,
  597.     "I",    1,
  598.     "M",    1,
  599.     "N",    1,
  600.     "PA",    1,
  601.     "PD",    1,
  602.     "PE",    1,
  603.     "PG",    1,
  604.     "PM",    1,
  605.     "PN",    1,
  606.     "PT",    1,
  607.     "T",    1
  608. };
  609.  
  610. int TCgetenv(char *envv)
  611. {
  612.     struct tvs *bp;
  613.  
  614.     if ((bp = bsearch(envv, &tvs[0], 16, (size_t)sizeof(struct tvs), compar)) == NULL)
  615.         return 0;
  616.     else
  617.         return bp->tvval;
  618.  
  619.     return 1;    /* Comment out preceding 6 lines to turn on everything. WW */
  620. }
  621.  
  622. int compar(const void *v1,const void *v2)
  623. {
  624.     char *t1 = (char *)v1;
  625.     struct tvs *t2 = (struct tvs *)v2;
  626.     return strcmp(t1, t2->tvname);
  627. }
  628. #endif