home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / x / xtrapv33.zip / extensions / lib / xtrap / XEPrInfo.c < prev    next >
C/C++ Source or Header  |  1992-09-14  |  11KB  |  409 lines
  1. /*****************************************************************************
  2. Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
  3.  
  4. Permission to use, copy, modify, and distribute this software and its 
  5. documentation for any purpose and without fee is hereby granted, 
  6. provided that the above copyright notice appear in all copies and that
  7. both that copyright notice and this permission notice appear in 
  8. supporting documentation, and that the name of Digital not be
  9. used in advertising or publicity pertaining to distribution of the
  10. software without specific, written prior permission.  
  11.  
  12. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  13. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  14. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  15. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  16. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  17. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  18. SOFTWARE.
  19.  
  20. *****************************************************************************/
  21. #include "Xos.h"
  22. #include "Xlib.h"
  23. #include "xtraplib.h"
  24. #include "xtraplibp.h"
  25.  
  26. #ifndef lint
  27. static char SCCSID[] = "@(#)XEPrintInfo.c    1.15 - 90/09/18  ";
  28. static char RCSID[] = "$Header$";
  29. #endif
  30.  
  31. #ifndef TRUE
  32. # define TRUE 1L
  33. #endif
  34. #ifndef FALSE
  35. # define FALSE 0L
  36. #endif
  37.  
  38. #ifdef FUNCTION_PROTOS
  39. void XEPrintRelease( FILE *ofp, XETrapGetAvailRep *pavail)
  40. #else
  41. void XEPrintRelease(ofp, pavail)
  42.     FILE *ofp;
  43.     XETrapGetAvailRep *pavail;
  44. #endif
  45. {
  46.  
  47.     fprintf(ofp,"\tRelease:   %d.%d-%d\n", XETrapGetAvailRelease(pavail),
  48.         XETrapGetAvailVersion(pavail), XETrapGetAvailRevision(pavail));
  49. }
  50. #ifdef FUNCTION_PROTOS
  51. void XEPrintTkRelease( FILE *ofp, XETC *tc)
  52. #else
  53. void XEPrintTkRelease(ofp, tc)
  54.     FILE *ofp;
  55.     XETC *tc;
  56. #endif
  57. {
  58.     fprintf(ofp,"\tRelease:   %d.%d-%d\n", XEGetRelease(tc), XEGetVersion(tc),
  59.         XEGetRevision(tc));
  60. }
  61.  
  62. #ifdef FUNCTION_PROTOS
  63. void XEPrintPlatform( FILE *ofp, XETrapGetAvailRep *pavail)
  64. #else
  65. void XEPrintPlatform(ofp, pavail)
  66.     FILE *ofp;
  67.     XETrapGetAvailRep *pavail;
  68. #endif
  69. {
  70.     fprintf(ofp,"\tPlatform:  %s (0x%02x)\n",
  71.         XEPlatformIDToString(XETrapGetAvailPFIdent(pavail)), 
  72.         XETrapGetAvailPFIdent(pavail));
  73. }
  74.  
  75. #ifdef FUNCTION_PROTOS
  76. void XEPrintAvailFlags( FILE *ofp, XETrapGetAvailRep *pavail)
  77. #else
  78. void XEPrintAvailFlags(ofp, pavail)
  79.     FILE *ofp;
  80.     XETrapGetAvailRep *pavail;
  81. #endif
  82. {
  83.  
  84.     CARD8 f[4L];
  85.  
  86.     XETrapGetAvailFlags(pavail,f);
  87.     fprintf(ofp,"\tFlags: ");
  88.     XETrapGetAvailFlagTimestamp(pavail) && fputs("Timestamps ", ofp);
  89.     XETrapGetAvailFlagCmd(pavail) && fputs("CmdKey ", ofp);
  90.     XETrapGetAvailFlagCmdKeyMod(pavail) && fputs("CmdKeyMod ", ofp);
  91.     XETrapGetAvailFlagRequest(pavail) && fputs("Requests ", ofp);
  92.     XETrapGetAvailFlagEvent(pavail) && fputs("Events ", ofp);
  93.     XETrapGetAvailFlagMaxPacket(pavail) && fputs("MaxPkt ", ofp);
  94.     XETrapGetAvailFlagStatistics(pavail) && fputs("Statistics ", ofp);
  95.     XETrapGetAvailFlagWinXY(pavail) && fputs("WinXY ", ofp);
  96.     XETrapGetAvailFlagCursor(pavail) && fputs("Cursor ", ofp);
  97.     XETrapGetAvailFlagXInput(pavail) && fputs("XInput ", ofp);
  98.     XETrapGetAvailFlagVecEvt(pavail) && fputs("Vect_Evnts ", ofp);
  99.     XETrapGetAvailFlagColorReplies(pavail) && fputs("ColorRep ", ofp);
  100.     XETrapGetAvailFlagGrabServer(pavail) && fputs("GrabServer ", ofp);
  101.     fprintf(ofp," (0x%02x%02x%02x%02x)\n", f[0], f[1], f[2], f[3]);
  102. }
  103.  
  104. #ifdef FUNCTION_PROTOS
  105. void XEPrintAvailPktSz( FILE *ofp, XETrapGetAvailRep *pavail)
  106. #else
  107. void XEPrintAvailPktSz(ofp, pavail)
  108.     FILE *ofp;
  109.     XETrapGetAvailRep *pavail;
  110. #endif
  111. {
  112.  
  113.     fprintf(ofp,"\tMax Packet Size: %d\n", XETrapGetAvailMaxPktSize(pavail));
  114. }
  115. #ifdef FUNCTION_PROTOS
  116. void XEPrintStateFlags( FILE *ofp, XETrapGetCurRep *pcur)
  117. #else
  118. void XEPrintStateFlags(ofp, pcur)
  119.     FILE *ofp;
  120.     XETrapGetCurRep *pcur;
  121. #endif
  122. {
  123.  
  124.     CARD8   f[2];
  125.     XETrapGetCurSFlags(pcur, f);
  126.     fputs("\tFlags: ",ofp); 
  127.     (BitIsTrue(f,XETrapTrapActive)) && fputs("I/O Active ", ofp);
  128.     fprintf(ofp," (0x%02x%02x)\n", f[0], f[1]);    
  129. }
  130.  
  131. #ifdef FUNCTION_PROTOS
  132. void XEPrintMajOpcode( FILE *ofp, XETrapGetAvailRep *pavail)
  133. #else
  134. void XEPrintMajOpcode(ofp, pavail)
  135.     FILE *ofp;
  136.     XETrapGetAvailRep *pavail;
  137. #endif
  138. {
  139.  
  140.     fprintf(ofp,"\tMajor Opcode:  %d\n", XETrapGetAvailOpCode(pavail));
  141. }
  142. #ifdef FUNCTION_PROTOS
  143. void XEPrintCurXY( FILE *ofp, XETrapGetAvailRep *pavail)
  144. #else
  145. void XEPrintCurXY(ofp, pavail)
  146.     FILE *ofp;
  147.     XETrapGetAvailRep *pavail;
  148. #endif
  149. {
  150.  
  151.     fprintf(ofp,"\tCurrent (x,y):  (%d,%d)\n", XETrapGetCurX(pavail), 
  152.         XETrapGetCurY(pavail));
  153. }
  154.  
  155. #ifdef FUNCTION_PROTOS
  156. void XEPrintTkFlags( FILE *ofp, XETC *tc)
  157. #else
  158. void XEPrintTkFlags(ofp, tc)
  159.     FILE *ofp;
  160.     XETC *tc;
  161. #endif
  162. {
  163.  
  164.     CARD8   f[2];
  165.     XETrapGetTCLFlags(tc, f);
  166.     fputs("\tFlags: ",ofp); 
  167.     (XETrapGetTCFlagDeltaTimes(tc)) && fputs("Delta Times ", ofp);
  168.     (XETrapGetTCFlagTrapActive(tc)) && fputs("Trap Active ", ofp);
  169.     fprintf(ofp," (0x%02x%02x)\n", f[0], f[1]);    
  170. }
  171.  
  172. #ifdef FUNCTION_PROTOS
  173. void XEPrintLastTime( FILE *ofp, XETC *tc)
  174. #else
  175. void XEPrintLastTime(ofp, tc)
  176.     FILE *ofp;
  177.     XETC *tc;
  178. #endif
  179. {
  180.  
  181.     fprintf(ofp,"\tLast Relative Time:  %d\n", XETrapGetTCTime(tc));
  182. }
  183.  
  184. #ifdef FUNCTION_PROTOS
  185. void XEPrintCfgFlags( FILE *ofp, XETrapGetCurRep *pcur)
  186. #else
  187. void XEPrintCfgFlags(ofp, pcur)
  188.     FILE *ofp;
  189.     XETrapGetCurRep *pcur;
  190. #endif
  191. {
  192.  
  193.     CARD8 f[4L];
  194.  
  195.     XETrapGetCurCFlags(pcur,data,f);
  196.     fprintf(ofp,"\tFlags: ");
  197.     XETrapGetCurFlagTimestamp(pcur,data)
  198.         && fputs("Timestamps ", ofp);
  199.     XETrapGetCurFlagCmd(pcur,data) && fputs("CmdKey ", ofp);
  200.     XETrapGetCurFlagCmdKeyMod(pcur,data)
  201.         && fputs("CmdKeyMod ", ofp);
  202.     XETrapGetCurFlagRequest(pcur,data)
  203.         && fputs("Requests ", ofp);
  204.     XETrapGetCurFlagEvent(pcur,data) && fputs("Events ", ofp);
  205.     XETrapGetCurFlagMaxPacket(pcur,data)
  206.         && fputs("MaxPkt ", ofp);
  207.     XETrapGetCurFlagStatistics(pcur,data)
  208.         && fputs("Statistics ", ofp);
  209.     XETrapGetCurFlagWinXY(pcur,data) && fputs("WinXY ", ofp);
  210.     XETrapGetCurFlagCursor(pcur,data) && fputs("Cursor ", ofp);
  211.     XETrapGetCurFlagXInput(pcur,data) && fputs("XInput ", ofp);
  212.     XETrapGetCurFlagColorReplies(pcur,data) && fputs("ColorReplies ", ofp);
  213.     XETrapGetCurFlagGrabServer(pcur,data) && fputs("GrabServer ", ofp);
  214.     fprintf(ofp," (0x%02x%02x%02x%02x)\n", f[0], f[1], f[2], f[3]);
  215. }
  216.  
  217. #ifdef FUNCTION_PROTOS
  218. void XEPrintRequests( FILE *ofp, XETrapGetCurRep *pcur)
  219. #else
  220. void XEPrintRequests(ofp, pcur)
  221.     FILE *ofp;
  222.     XETrapGetCurRep *pcur;
  223. #endif
  224. {
  225.  
  226.     long i;
  227.     fprintf(ofp,"\tX Requests:  ");
  228.     for (i=0L; i<=XETrapMaxRequest-1; i++)
  229.     {   /* Not using the macro cause we're doing things
  230.          * a byte at a time rather than a bit.
  231.          */
  232.         fprintf(ofp,"%02x ", pcur->config.flags.req[i]);
  233.         if ((i+1L)%4L == 0L)
  234.         { 
  235.             fprintf(ofp,"  "); 
  236.         }
  237.         if ((i+1L)%16L == 0L)
  238.         { 
  239.             fprintf(ofp,"\n\t\t     "); 
  240.         }
  241.     }
  242.     fprintf(ofp,"\n");
  243. }
  244.  
  245. #ifdef FUNCTION_PROTOS
  246. void XEPrintEvents( FILE *ofp, XETrapGetCurRep *pcur)
  247. #else
  248. void XEPrintEvents(ofp, pcur)
  249.     FILE *ofp;
  250.     XETrapGetCurRep *pcur;
  251. #endif
  252. {
  253.  
  254.     int i;
  255.     fprintf(ofp,"\tX Events:  ");
  256.     for (i=0L; i<XETrapMaxEvent; i++)
  257.     {   /* Not using the macro cause we're doing things
  258.          * a byte at a time rather than a bit.
  259.          */
  260.         fprintf(ofp,"%02x ", pcur->config.flags.event[i]);
  261.         if ((i+1L)%4L == 0L)
  262.         { 
  263.             fprintf(ofp,"  "); 
  264.         }
  265.         if ((i+1L)%16L == 0L)
  266.         { 
  267.             fprintf(ofp,"\n\t\t     "); 
  268.         }
  269.     }
  270.     fprintf(ofp,"\n");
  271. }
  272.  
  273. #ifdef FUNCTION_PROTOS
  274. void XEPrintCurPktSz( FILE *ofp, XETrapGetCurRep *pcur)
  275. #else
  276. void XEPrintCurPktSz(ofp, pcur)
  277.     FILE *ofp;
  278.     XETrapGetCurRep *pcur;
  279. #endif
  280. {
  281.  
  282.     fprintf(ofp,"\tMax Packet Size: %d\n", XETrapGetCurMaxPktSize(pcur));
  283. }
  284.  
  285. #ifdef FUNCTION_PROTOS
  286. void XEPrintCmdKey( FILE *ofp, XETrapGetCurRep *pcur)
  287. #else
  288. void XEPrintCmdKey(ofp, pcur)
  289.     FILE *ofp;
  290.     XETrapGetCurRep *pcur;
  291. #endif
  292. {
  293.  
  294.     fprintf(ofp,"\tcmd_key: 0x%02x\n", XETrapGetCurCmdKey(pcur));
  295. }
  296.  
  297. #ifdef FUNCTION_PROTOS
  298. void XEPrintEvtStats( FILE *ofp, XETrapGetStatsRep *pstats)
  299. #else
  300. void XEPrintEvtStats(ofp, pstats)
  301.     FILE *ofp;
  302.     XETrapGetStatsRep *pstats;
  303. #endif
  304. {
  305.  
  306.     int i;
  307.     fprintf(ofp,"\tX Events:\n");
  308.     for (i=0; i<XETrapCoreEvents; i++)
  309.     {   
  310.         if (XETrapGetStatsEvt(pstats,i))
  311.         {
  312.             fprintf(ofp,"\t   %-20s :  %d\n", XEEventIDToString(i),
  313.                 XETrapGetStatsEvt(pstats,i));
  314.         }
  315.     }
  316.     fprintf(ofp,"\n");
  317. }
  318.  
  319. #ifdef FUNCTION_PROTOS
  320. void XEPrintReqStats( FILE *ofp, XETrapGetStatsRep *pstats)
  321. #else
  322. void XEPrintReqStats(ofp, pstats)
  323.     FILE *ofp;
  324.     XETrapGetStatsRep *pstats;
  325. #endif
  326. {
  327.  
  328.     int i;
  329.     fprintf(ofp,"\tX Requests:\n");
  330.     for (i=0L; i<256L; i++)
  331.     {   
  332.         if (XETrapGetStatsReq(pstats,i))
  333.         {
  334.             fprintf(ofp,"\t   %-20s :  %d\n", XERequestIDToString(i),
  335.                 XETrapGetStatsReq(pstats,i));
  336.         }
  337.     }
  338.     fprintf(ofp,"\n");
  339. }
  340.  
  341.  
  342. #ifdef FUNCTION_PROTOS
  343. void XEPrintAvail( FILE *ofp, XETrapGetAvailRep *pavail)
  344. #else
  345. void XEPrintAvail(ofp, pavail)
  346.     FILE *ofp;
  347.     XETrapGetAvailRep *pavail;
  348. #endif
  349. {
  350.  
  351.     fprintf(ofp,"Available Information:\n");
  352.     XEPrintRelease(ofp, pavail);
  353.     XEPrintPlatform(ofp, pavail);
  354.     XEPrintMajOpcode(ofp, pavail);
  355.     XEPrintAvailFlags(ofp, pavail);
  356.     XEPrintAvailPktSz(ofp, pavail);
  357.     XEPrintCurXY(ofp, pavail);
  358.     return;
  359. }
  360.  
  361. #ifdef FUNCTION_PROTOS
  362. void XEPrintTkState( FILE *ofp, XETC *tc)
  363. #else
  364. void XEPrintTkState(ofp, tc)
  365.     FILE *ofp;
  366.     XETC *tc;
  367. #endif
  368. {
  369.  
  370.     fprintf(ofp,"Toolkit State:\n");
  371.     XEPrintTkFlags(ofp, tc);
  372.     XEPrintLastTime(ofp, tc);
  373.     XEPrintTkRelease(ofp, tc);
  374. }
  375.  
  376. #ifdef FUNCTION_PROTOS
  377. void XEPrintCurrent( FILE *ofp, XETrapGetCurRep *pcur)
  378. #else
  379. void XEPrintCurrent(ofp, pcur)
  380.     FILE *ofp;
  381.     XETrapGetCurRep *pcur;
  382. #endif
  383. {
  384.  
  385.     fprintf(ofp,"Current State:\n");
  386.     XEPrintStateFlags(ofp, pcur);
  387.     fprintf(ofp,"Current Config:\n");
  388.     XEPrintCfgFlags(ofp, pcur);
  389.     XEPrintRequests(ofp, pcur);
  390.     XEPrintEvents(ofp, pcur);
  391.     XEPrintCurPktSz(ofp, pcur);
  392.     XEPrintCmdKey(ofp, pcur);
  393. }
  394.  
  395. #ifdef FUNCTION_PROTOS
  396. void XEPrintStatistics( FILE *ofp, XETrapGetStatsRep *pstats)
  397. #else
  398. void XEPrintStatistics(ofp, pstats)
  399.     FILE *ofp;
  400.     XETrapGetStatsRep *pstats;
  401. #endif
  402. {
  403.  
  404.     fprintf(ofp,"Statistics:\n");
  405.     XEPrintEvtStats(ofp, pstats);
  406.     XEPrintReqStats(ofp, pstats);
  407. }
  408.  
  409.