home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / unix / vim-6.2.tar.bz2 / vim-6.2.tar / vim62 / src / wsdebug.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-13  |  4.3 KB  |  180 lines
  1. /* vi:set ts=8 sts=8 sw=8:
  2.  *
  3.  * VIM - Vi IMproved    by Bram Moolenaar
  4.  *            Visual Workshop integration by Gordon Prieur
  5.  *
  6.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  7.  * Do ":help credits" in Vim to see a list of people who contributed.
  8.  * See README.txt for an overview of the Vim source code.
  9.  */
  10.  
  11. /*
  12.  * WorkShop Debugging Tools. What are these tools and why are they important?
  13.  * There are two main tools here. The first tool is a tool for delaying or
  14.  * stopping gvim during startup.  The second tool is a protocol log tool.
  15.  *
  16.  * The startup delay tool is called wsdebug_wait(). This is very important for
  17.  * debugging startup problems because gvim will be started automatically from
  18.  * workshop and cannot be run directly from a debugger. The only way to debug
  19.  * a gvim started by workshop is by attaching a debugger to it. Without this
  20.  * tool all starup code will have completed before you can get the pid and
  21.  * attach.
  22.  *
  23.  * The second tool is a protocol log tool. The workshop editor server and gvim
  24.  * pass information back and forth during a workshop session. Sometimes it is
  25.  * very important to peruse this conversation in order to understand what is
  26.  * happening. The wsdebug_log_init() call sets up this protocol log tool and
  27.  * wsdebug() and wstrace() calls output the information to the log.
  28.  *
  29.  * This code must have WSDEBUG defined for it to be compiled into vim/gvim.
  30.  */
  31.  
  32. #ifdef WSDEBUG
  33.  
  34. #include <stdarg.h>
  35.  
  36. #include "vim.h"
  37.  
  38. FILE        *ws_debug = NULL;
  39. u_int         ws_dlevel = 0;        /* ws_debug verbosity level */
  40.  
  41. void         wsdebug(char *, ...);
  42. void         wstrace(char *, ...);
  43.  
  44. static int     lookup(char *);
  45. static int     errorHandler(Display *, XErrorEvent *);
  46.  
  47.  
  48. /*
  49.  * wsdebug_wait    -   This function can be used to delay or stop execution of vim.
  50.  *            Its normally used to delay startup while attaching a
  51.  *            debugger to a running process. Since workshop starts gvim
  52.  *            from a background process this is the only way to debug
  53.  *            startup problems.
  54.  */
  55.  
  56. void wsdebug_wait(
  57.     u_int         wait_flags,    /* tells what to do */
  58.     char        *wait_var,    /* wait environment variable */
  59.     u_int         wait_secs)    /* how many seconds to wait */
  60. {
  61.  
  62.     init_homedir();            /* not inited yet */
  63. #ifdef USE_WDDUMP
  64.     WDDump(0, 0, 0);
  65. #endif
  66.  
  67.     /* for debugging purposes only */
  68.     if (wait_flags & WT_ENV && wait_var && getenv(wait_var) != NULL) {
  69.         sleep(atoi(getenv(wait_var)));
  70.     } else if (wait_flags & WT_WAIT && lookup("~/.gvimwait")) {
  71.         sleep(wait_secs > 0 && wait_secs < 120 ? wait_secs : 20);
  72.     } else if (wait_flags & WT_STOP && lookup("~/.gvimstop")) {
  73.         int w = 1;
  74.         while (w) {
  75.             ;
  76.         }
  77.     }
  78. }    /* end wsdebug_wait */
  79.  
  80.  
  81. void
  82. wsdebug_log_init(
  83.     char        *log_var,    /* env var with log file */
  84.     char        *level_var)    /* env var with ws_debug level */
  85. {
  86.     char        *file;        /* possible ws_debug output file */
  87.     char        *cp;        /* ws_dlevel pointer */
  88.  
  89.     if (log_var && (file = getenv(log_var)) != NULL) {
  90.         char buf[BUFSIZ];
  91.  
  92.         sprintf(buf, "date > %s", file);
  93.         system(buf);
  94.         ws_debug = fopen(file, "a");
  95.         if (level_var && (cp = getenv(level_var)) != NULL) {
  96.             ws_dlevel = strtoul(cp, NULL, 0);
  97.         } else {
  98.             ws_dlevel = WS_TRACE;    /* default level */
  99.         }
  100.         /* XSetErrorHandler(errorHandler); */
  101.     }
  102.  
  103. }    /* end wsdebug_log_init */
  104.  
  105.  
  106.  
  107.  
  108. void
  109. wstrace(
  110.     char        *fmt,
  111.     ...)
  112. {
  113.     va_list         ap;
  114.  
  115.     if (ws_debug!= NULL && (ws_dlevel & (WS_TRACE | WS_TRACE_VERBOSE))) {
  116.         va_start(ap, fmt);
  117.         vfprintf(ws_debug, fmt, ap);
  118.         va_end(ap);
  119.         fflush(ws_debug);
  120.     }
  121.  
  122. }    /* end wstrace */
  123.  
  124.  
  125. void
  126. wsdebug(
  127.     char        *fmt,
  128.     ...)
  129. {
  130.     va_list         ap;
  131.  
  132.     if (ws_debug != NULL) {
  133.         va_start(ap, fmt);
  134.         vfprintf(ws_debug, fmt, ap);
  135.         va_end(ap);
  136.         fflush(ws_debug);
  137.     }
  138.  
  139. }    /* end wsdebug */
  140.  
  141.  
  142. static int
  143. lookup(
  144.     char        *file)
  145. {
  146.     char         buf[BUFSIZ];
  147.  
  148.     expand_env((char_u *) file, (char_u *) buf, BUFSIZ);
  149.     return (access(buf, F_OK) == 0);
  150.  
  151. }    /* end lookup */
  152.  
  153. static int
  154. errorHandler(
  155.     Display        *dpy,
  156.     XErrorEvent    *err)
  157. {
  158.     char         msg[256];
  159.     char         buf[256];
  160.  
  161.     XGetErrorText(dpy, err->error_code, msg, sizeof(msg));
  162.     wsdebug("\n\nWSDEBUG Vim: X Error of failed request: %s\n", msg);
  163.  
  164.     sprintf(buf, "%d", err->request_code);
  165.     XGetErrorDatabaseText(dpy,
  166.         "XRequest", buf, "Unknown", msg, sizeof(msg));
  167.     wsdebug("\tMajor opcode of failed request: %d (%s)\n",
  168.         err->request_code, msg);
  169.     if (err->request_code > 128) {
  170.         wsdebug("\tMinor opcode of failed request: %d\n",
  171.             err->minor_code);
  172.     }
  173.  
  174.     return 0;
  175. }
  176.  
  177.  
  178.  
  179. #endif /* WSDEBUG */
  180.