unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed
* [patch] Some fixes for flymake
@ 2013-02-23 14:06 Xue Fuqiao
  2013-05-10  1:20 ` Glenn Morris
  0 siblings, 1 reply; 3+ messages in thread
From: Xue Fuqiao @ 2013-02-23 14:06 UTC (permalink / raw)
  To: emacs-devel

[-- Attachment #1: Type: text/plain, Size: 199 bytes --]

I made some fixes for flymake, most of them are doc fixes.  If the attached
patches are OK, I will send the ChangeLog entries.

-- 
Best regards, Xue Fuqiao.
http://www.emacswiki.org/emacs/XueFuqiao

[-- Attachment #2: flymake.el.patch --]
[-- Type: text/x-diff, Size: 14696 bytes --]

*** trunk/lisp/progmodes/flymake.el	2013-02-03 09:46:50.383143000 +0800
--- trunk/lisp/progmodes/flymake.el.new	2013-02-23 21:49:13.333088549 +0800
***************
*** 1,4 ****
! ;;; flymake.el -- a universal on-the-fly syntax checker
  
  ;; Copyright (C) 2003-2013 Free Software Foundation, Inc.
  
--- 1,4 ----
! ;;; flymake.el --- a universal on-the-fly syntax checker
  
  ;; Copyright (C) 2003-2013 Free Software Foundation, Inc.
  
***************
*** 26,32 ****
  ;;
  ;; Flymake is a minor Emacs mode performing on-the-fly syntax
  ;; checks using the external syntax check tool (for C/C++ this
! ;; is usually the compiler)
  
  ;;; Bugs/todo:
  
--- 26,32 ----
  ;;
  ;; Flymake is a minor Emacs mode performing on-the-fly syntax
  ;; checks using the external syntax check tool (for C/C++ this
! ;; is usually the compiler).
  
  ;;; Bugs/todo:
  
***************
*** 66,73 ****
    "Same as `flymake-err-info', effective when a syntax check is in progress.")
  (make-variable-buffer-local 'flymake-new-err-info)
  
! ;;;; [[ cross-emacs compatibility routines
  (defsubst flymake-makehash (&optional test)
    (if (fboundp 'make-hash-table)
        (if test (make-hash-table :test test) (make-hash-table))
      (with-no-warnings
--- 66,76 ----
    "Same as `flymake-err-info', effective when a syntax check is in progress.")
  (make-variable-buffer-local 'flymake-new-err-info)
  
! ;;;; [[ cross-emacsen compatibility routines
  (defsubst flymake-makehash (&optional test)
+   "Create and return a new hash table using TEST to compare keys.
+ It uses the function `make-hash-table' to make a hash-table if
+ you use GNU Emacs, otherwise it uses `makehash'."
    (if (fboundp 'make-hash-table)
        (if test (make-hash-table :test test) (make-hash-table))
      (with-no-warnings
*************** Zero-length substrings at the beginning
*** 106,115 ****
      (lambda () temporary-file-directory)))
  
  (defun flymake-posn-at-point-as-event (&optional position window dx dy)
!   "Return pixel position of top left corner of glyph at POSITION,
! relative to top left corner of WINDOW, as a mouse-1 click
! event (identical to the event that would be triggered by clicking
! mouse button 1 at the top left corner of the glyph).
  
  POSITION and WINDOW default to the position of point in the
  selected window.
--- 109,120 ----
      (lambda () temporary-file-directory)))
  
  (defun flymake-posn-at-point-as-event (&optional position window dx dy)
!   "Return pixel position of top left corner of glyph at POSITION.
! 
! The position is relative to top left corner of WINDOW, as a
! mouse-1 click event (identical to the event that would be
! triggered by clicking mouse button 1 at the top left corner of
! the glyph).
  
  POSITION and WINDOW default to the position of point in the
  selected window.
*************** See `x-popup-menu' for the menu specifie
*** 164,170 ****
  
  (if (featurep 'xemacs) (progn
  
! (defun flymake-nop ())
  
  (defun flymake-make-xemacs-menu (menu-data)
    "Return a menu specifier using MENU-DATA."
--- 169,176 ----
  
  (if (featurep 'xemacs) (progn
  
! (defun flymake-nop ()
!   "Do nothing.")
  
  (defun flymake-make-xemacs-menu (menu-data)
    "Return a menu specifier using MENU-DATA."
*************** See `x-popup-menu' for the menu specifie
*** 187,192 ****
--- 193,199 ----
      (count-lines (window-start) (point))))
  
  (defun flymake-selected-frame ()
+   "Return the frame that is now selected."
    (if (fboundp 'window-edges)
        (selected-frame)
      (selected-window)))
*************** See `x-popup-menu' for the menu specifie
*** 217,247 ****
    :group 'flymake
    :type 'integer)
  
  (defun flymake-log (level text &rest args)
    "Log a message at level LEVEL.
  If LEVEL is higher than `flymake-log-level', the message is
  ignored.  Otherwise, it is printed using `message'.
  TEXT is a format control string, and the remaining arguments ARGS
! are the string substitutions (see `format')."
    (if (<= level flymake-log-level)
        (let* ((msg (apply 'format text args)))
  	(message "%s" msg)
  	;;(with-temp-buffer
  	;;    (insert msg)
  	;;   (insert "\n")
! 	;;   (flymake-save-buffer-in-file "d:/flymake.log" t)  ; make log file name customizable
  	;;)
  	)))
  
  (defun flymake-ins-after (list pos val)
!   "Insert VAL into LIST after position POS."
!   (let ((tmp (copy-sequence list)))	; (???)
      (setcdr (nthcdr pos tmp) (cons val (nthcdr (1+ pos) tmp)))
      tmp))
  
  (defun flymake-set-at (list pos val)
!   "Set VAL at position POS in LIST."
!   (let ((tmp (copy-sequence list)))	; (???)
      (setcar (nthcdr pos tmp) val)
      tmp))
  
--- 224,263 ----
    :group 'flymake
    :type 'integer)
  
+ ;; (defcustom flymake-log-file-name "~/flymake.log"
+ ;;   "Where to put the flymake log if logging is enabled.
+ 
+ ;;    See `flymake-log-level' if you want to control what is logged."
+ ;;   :group 'flymake
+ ;;   :type 'string)
+ 
  (defun flymake-log (level text &rest args)
    "Log a message at level LEVEL.
  If LEVEL is higher than `flymake-log-level', the message is
  ignored.  Otherwise, it is printed using `message'.
  TEXT is a format control string, and the remaining arguments ARGS
! are the string substitutions (see the function `format')."
    (if (<= level flymake-log-level)
        (let* ((msg (apply 'format text args)))
  	(message "%s" msg)
  	;;(with-temp-buffer
  	;;    (insert msg)
  	;;   (insert "\n")
! 	;;   (flymake-save-buffer-in-file "~/flymake.log")  ; make log file name customizable
  	;;)
  	)))
  
  (defun flymake-ins-after (list pos val)
!   "Insert VAL into LIST after position POS.
! POS counts from zero."
!   (let ((tmp (copy-sequence list)))	; Bind `tmp' to a copy of LIST
      (setcdr (nthcdr pos tmp) (cons val (nthcdr (1+ pos) tmp)))
      tmp))
  
  (defun flymake-set-at (list pos val)
!   "Set VAL at position POS in LIST.
! POS counts from zero."
!   (let ((tmp (copy-sequence list)))	; Bind `tmp' to a copy of LIST
      (setcar (nthcdr pos tmp) val)
      tmp))
  
*************** are the string substitutions (see `forma
*** 249,255 ****
    "List of currently active flymake processes.")
  
  (defvar flymake-output-residual nil)
- 
  (make-variable-buffer-local 'flymake-output-residual)
  
  (defgroup flymake nil
--- 265,270 ----
*************** are the string substitutions (see `forma
*** 284,294 ****
    :type '(repeat (string symbol symbol symbol)))
  
  (defun flymake-get-file-name-mode-and-masks (file-name)
!   "Return the corresponding entry from `flymake-allowed-file-name-masks'."
    (unless (stringp file-name)
      (error "Invalid file-name"))
    (let ((fnm flymake-allowed-file-name-masks)
! 	(mode-and-masks  nil))
      (while (and (not mode-and-masks) fnm)
        (if (string-match (car (car fnm)) file-name)
  	  (setq mode-and-masks (cdr (car fnm))))
--- 299,309 ----
    :type '(repeat (string symbol symbol symbol)))
  
  (defun flymake-get-file-name-mode-and-masks (file-name)
!   "Return the function(s) correspond(s) to FILE-NAME in `flymake-allowed-file-name-masks'."
    (unless (stringp file-name)
      (error "Invalid file-name"))
    (let ((fnm flymake-allowed-file-name-masks)
! 	(mode-and-masks nil))
      (while (and (not mode-and-masks) fnm)
        (if (string-match (car (car fnm)) file-name)
  	  (setq mode-and-masks (cdr (car fnm))))
*************** are the string substitutions (see `forma
*** 296,335 ****
      (flymake-log 3 "file %s, init=%s" file-name (car mode-and-masks))
      mode-and-masks))
  
- (defun flymake-can-syntax-check-file (file-name)
-   "Determine whether we can syntax check FILE-NAME.
- Return nil if we cannot, non-nil if we can."
-   (if (flymake-get-init-function file-name) t nil))
- 
  (defun flymake-get-init-function (file-name)
!   "Return init function to be used for the file."
    (let* ((init-f  (nth 0 (flymake-get-file-name-mode-and-masks file-name))))
      ;;(flymake-log 0 "calling %s" init-f)
      ;;(funcall init-f (current-buffer))
      init-f))
  
  (defun flymake-get-cleanup-function (file-name)
!   "Return cleanup function to be used for the file."
    (or (nth 1 (flymake-get-file-name-mode-and-masks file-name))
        'flymake-simple-cleanup))
  
  (defun flymake-get-real-file-name-function (file-name)
!   (or (nth 2 (flymake-get-file-name-mode-and-masks file-name))
        'flymake-get-real-file-name))
  
  (defvar flymake-find-buildfile-cache (flymake-makehash 'equal))
  
  (defun flymake-get-buildfile-from-cache (dir-name)
    (gethash dir-name flymake-find-buildfile-cache))
  
  (defun flymake-add-buildfile-to-cache (dir-name buildfile)
    (puthash dir-name buildfile flymake-find-buildfile-cache))
  
  (defun flymake-clear-buildfile-cache ()
    (clrhash flymake-find-buildfile-cache))
  
  (defun flymake-find-buildfile (buildfile-name source-dir-name)
!   "Find buildfile starting from current directory.
  Buildfile includes Makefile, build.xml etc.
  Return its file name if found, or nil if not found."
    (or (flymake-get-buildfile-from-cache source-dir-name)
--- 311,355 ----
      (flymake-log 3 "file %s, init=%s" file-name (car mode-and-masks))
      mode-and-masks))
  
  (defun flymake-get-init-function (file-name)
!   "Return init function to be used for the file FILE-NAME."
    (let* ((init-f  (nth 0 (flymake-get-file-name-mode-and-masks file-name))))
      ;;(flymake-log 0 "calling %s" init-f)
      ;;(funcall init-f (current-buffer))
      init-f))
  
+ (defun flymake-can-syntax-check-file (file-name)
+   "Determine whether we can syntax check FILE-NAME.
+ Return t if we can, nil if we cannot."
+   (if (flymake-get-init-function file-name) t nil))
+ 
  (defun flymake-get-cleanup-function (file-name)
!   "Return cleanup function to be used for the file FILE-NAME."
    (or (nth 1 (flymake-get-file-name-mode-and-masks file-name))
        'flymake-simple-cleanup))
  
  (defun flymake-get-real-file-name-function (file-name)
!   "Return function that translates FILE-NAME to real file name."
!   (or (nth 4 (flymake-get-file-name-mode-and-masks file-name))
        'flymake-get-real-file-name))
  
  (defvar flymake-find-buildfile-cache (flymake-makehash 'equal))
  
  (defun flymake-get-buildfile-from-cache (dir-name)
+   "Look up DIR-NAME in cache and return its associated value.
+ If DIR-NAME is not found, return nil."
    (gethash dir-name flymake-find-buildfile-cache))
  
  (defun flymake-add-buildfile-to-cache (dir-name buildfile)
+   "Associate DIR-NAME with BUILDFILE in the buildfile cache."
    (puthash dir-name buildfile flymake-find-buildfile-cache))
  
  (defun flymake-clear-buildfile-cache ()
+   "Clear the buildfile cache."
    (clrhash flymake-find-buildfile-cache))
  
  (defun flymake-find-buildfile (buildfile-name source-dir-name)
!   "Find BUILDFILE-NAME starting from current directory.
  Buildfile includes Makefile, build.xml etc.
  Return its file name if found, or nil if not found."
    (or (flymake-get-buildfile-from-cache source-dir-name)
*************** Return its file name if found, or nil if
*** 344,350 ****
              nil)))))
  
  (defun flymake-fix-file-name (name)
!   "Replace all occurrences of '\' with '/'."
    (when name
      (setq name (expand-file-name name))
      (setq name (abbreviate-file-name name))
--- 364,370 ----
              nil)))))
  
  (defun flymake-fix-file-name (name)
!   "Replace all occurrences of '\' with '/' in filename NAME."
    (when name
      (setq name (expand-file-name name))
      (setq name (abbreviate-file-name name))
*************** Return t if so, nil if not."
*** 371,377 ****
  (defvar flymake-included-file-name)
  
  (defun flymake-find-possible-master-files (file-name master-file-dirs masks)
!   "Find (by name and location) all possible master files.
  Master files include .cpp and .c for .h.  Files are searched for
  starting from the .h directory and max max-level parent dirs.
  File contents are not checked."
--- 391,397 ----
  (defvar flymake-included-file-name)
  
  (defun flymake-find-possible-master-files (file-name master-file-dirs masks)
!   "Find (by FILE-NAME and MASTER-FILE-DIRS) all possible master files.
  Master files include .cpp and .c for .h.  Files are searched for
  starting from the .h directory and max max-level parent dirs.
  File contents are not checked."
*************** instead of reading master file from disk
*** 516,522 ****
      (current-buffer)))
  
  (defun flymake-check-include (source-file-name inc-name include-dirs)
!   "Check if SOURCE-FILE-NAME can be found in include path.
  Return t if it can be found via include path using INC-NAME."
    (if (file-name-absolute-p inc-name)
        (flymake-same-files source-file-name inc-name)
--- 536,542 ----
      (current-buffer)))
  
  (defun flymake-check-include (source-file-name inc-name include-dirs)
!   "Check if SOURCE-FILE-NAME can be found in INCLUDE-DIRS.
  Return t if it can be found via include path using INC-NAME."
    (if (file-name-absolute-p inc-name)
        (flymake-same-files source-file-name inc-name)
*************** Return t if so, nil if not."
*** 537,543 ****
  	(get-buffer buffer-name))))
  
  (defun flymake-create-master-file (source-file-name patched-source-file-name get-incl-dirs-f create-temp-f masks include-regexp)
!   "Save SOURCE-FILE-NAME with a different name.
  Find master file, patch and save it."
    (let* ((possible-master-files     (flymake-find-possible-master-files source-file-name flymake-master-file-dirs masks))
  	 (master-file-count         (length possible-master-files))
--- 557,563 ----
  	(get-buffer buffer-name))))
  
  (defun flymake-create-master-file (source-file-name patched-source-file-name get-incl-dirs-f create-temp-f masks include-regexp)
!   "Save SOURCE-FILE-NAME with a different name PATCHED-SOURCE-FILE-NAME.
  Find master file, patch and save it."
    (let* ((possible-master-files     (flymake-find-possible-master-files source-file-name flymake-master-file-dirs masks))
  	 (master-file-count         (length possible-master-files))
*************** Find master file, patch and save it."
*** 571,576 ****
--- 591,598 ----
  	nil))))
  
  (defun flymake-save-buffer-in-file (file-name)
+   "Save the entire buffer contents into file FILE-NAME.
+ It also creates optionally any nonexistent parent directories."
    (make-directory (file-name-directory file-name) 1)
    (write-region nil nil file-name nil 566)
    (flymake-log 3 "saved buffer %s in file %s" (buffer-name) file-name))
*************** Use CREATE-TEMP-F for creating temp copy
*** 1842,1844 ****
--- 1864,1868 ----
  (provide 'flymake)
  
  ;;; flymake.el ends here
+ 
+ ;;  LocalWords:  DIRS POS odl tex init GNUmakefile Makefile

[-- Attachment #3: flymake.texi.patch --]
[-- Type: text/x-diff, Size: 34149 bytes --]

*** trunk/doc/misc/flymake.texi	2013-02-17 22:42:17.309803000 +0800
--- trunk/doc/misc/flymake.texi.new	2013-02-23 21:20:27.468530453 +0800
*************** modify this GNU manual.''
*** 63,75 ****
  @cindex Overview of Flymake
  
  Flymake is a universal on-the-fly syntax checker implemented as an
! Emacs minor mode. Flymake runs the pre-configured syntax check tool
  (compiler for C++ files, @code{perl} for perl files, etc.)@: in the
  background, passing it a temporary copy of the current buffer, and
! parses the output for known error/warning message patterns. Flymake
  then highlights erroneous lines (i.e., lines for which at least one
  error or warning has been reported by the syntax check tool), and
! displays an overall buffer status in the mode line. Status information
  displayed by Flymake contains total number of errors and warnings
  reported for the buffer during the last syntax check.
  
--- 63,75 ----
  @cindex Overview of Flymake
  
  Flymake is a universal on-the-fly syntax checker implemented as an
! Emacs minor mode.  Flymake runs the pre-configured syntax check tool
  (compiler for C++ files, @code{perl} for perl files, etc.)@: in the
  background, passing it a temporary copy of the current buffer, and
! parses the output for known error/warning message patterns.  Flymake
  then highlights erroneous lines (i.e., lines for which at least one
  error or warning has been reported by the syntax check tool), and
! displays an overall buffer status in the mode line.  Status information
  displayed by Flymake contains total number of errors and warnings
  reported for the buffer during the last syntax check.
  
*************** line, respectively.
*** 79,92 ****
  
  Calling @code{flymake-display-err-menu-for-current-line} will popup a
  menu containing error messages reported by the syntax check tool for
! the current line. Errors/warnings belonging to another file, such as a
  @code{.h} header file included by a @code{.c} file, are shown in the
! current buffer as belonging to the first line. Menu items for such
! messages also contain a filename and a line number. Selecting such a
  menu item will automatically open the file and jump to the line with
  error.
  
! Syntax check is done 'on-the-fly'. It is started whenever
  
  @itemize @bullet
  @item buffer is loaded
--- 79,92 ----
  
  Calling @code{flymake-display-err-menu-for-current-line} will popup a
  menu containing error messages reported by the syntax check tool for
! the current line.  Errors/warnings belonging to another file, such as a
  @code{.h} header file included by a @code{.c} file, are shown in the
! current buffer as belonging to the first line.  Menu items for such
! messages also contain a filename and a line number.  Selecting such a
  menu item will automatically open the file and jump to the line with
  error.
  
! Syntax check is done 'on-the-fly'.  It is started whenever
  
  @itemize @bullet
  @item buffer is loaded
*************** patterns. @xref{Configuring Flymake}.
*** 107,113 ****
  Flymake is packaged in a single file, @code{flymake.el}.
  
  To install/update Flymake, place @code{flymake.el} to a directory
! somewhere on Emacs load path. You might also want to byte-compile
  @code{flymake.el} to improve performance.
  
  Also, place the following line in the @code{.emacs} file.
--- 107,113 ----
  Flymake is packaged in a single file, @code{flymake.el}.
  
  To install/update Flymake, place @code{flymake.el} to a directory
! somewhere on Emacs load path.  You might also want to byte-compile
  @code{flymake.el} to improve performance.
  
  Also, place the following line in the @code{.emacs} file.
*************** You might also map the most frequently u
*** 141,153 ****
  @section Flymake mode
  @cindex flymake-mode
  
! Flymake is an Emacs minor mode. To use Flymake, you
  must first activate @code{flymake-mode} by using the
  @code{flymake-mode} function.
  
  Instead of manually activating @code{flymake-mode}, you can configure
  Flymake to automatically enable @code{flymake-mode} upon opening any
! file for which syntax check is possible. To do so, place the following
  line in @code{.emacs}:
  
  @lisp
--- 141,153 ----
  @section Flymake mode
  @cindex flymake-mode
  
! Flymake is an Emacs minor mode.  To use Flymake, you
  must first activate @code{flymake-mode} by using the
  @code{flymake-mode} function.
  
  Instead of manually activating @code{flymake-mode}, you can configure
  Flymake to automatically enable @code{flymake-mode} upon opening any
! file for which syntax check is possible.  To do so, place the following
  line in @code{.emacs}:
  
  @lisp
*************** line in @code{.emacs}:
*** 159,167 ****
  @cindex Manually starting the syntax check
  
  When @code{flymake-mode} is active, syntax check is started
! automatically on any of the three conditions mentioned above. Syntax
  check can also be started manually by using the
! @code{flymake-start-syntax-check-for-current-buffer} function. This
  can be used, for example, when changes were made to some other buffer
  affecting the current buffer.
  
--- 159,167 ----
  @cindex Manually starting the syntax check
  
  When @code{flymake-mode} is active, syntax check is started
! automatically on any of the three conditions mentioned above.  Syntax
  check can also be started manually by using the
! @code{flymake-start-syntax-check-for-current-buffer} function.  This
  can be used, for example, when changes were made to some other buffer
  affecting the current buffer.
  
*************** affecting the current buffer.
*** 171,177 ****
  
  After syntax check is completed, lines for which at least one error or
  warning has been reported are highlighted, and total number of errors
! and warning is shown in the mode line. Use the following functions to
  navigate the highlighted lines.
  
  @multitable @columnfractions 0.25 0.75
--- 171,177 ----
  
  After syntax check is completed, lines for which at least one error or
  warning has been reported are highlighted, and total number of errors
! and warning is shown in the mode line.  Use the following functions to
  navigate the highlighted lines.
  
  @multitable @columnfractions 0.25 0.75
*************** navigate the highlighted lines.
*** 184,190 ****
  
  @end multitable
  
! These functions treat erroneous lines as a linked list. Therefore,
  @code{flymake-goto-next-error} will go to the first erroneous line
  when invoked in the end of the buffer.
  
--- 184,190 ----
  
  @end multitable
  
! These functions treat erroneous lines as a linked list.  Therefore,
  @code{flymake-goto-next-error} will go to the first erroneous line
  when invoked in the end of the buffer.
  
*************** when invoked in the end of the buffer.
*** 193,199 ****
  @cindex Viewing error messages
  
  To view error messages belonging to the current line, use the
! @code{flymake-display-err-menu-for-current-line} function. If there's
  at least one error or warning reported for the current line, this
  function will display a popup menu with error/warning texts.
  Selecting the menu item whose error belongs to another file brings
--- 193,199 ----
  @cindex Viewing error messages
  
  To view error messages belonging to the current line, use the
! @code{flymake-display-err-menu-for-current-line} function.  If there's
  at least one error or warning reported for the current line, this
  function will display a popup menu with error/warning texts.
  Selecting the menu item whose error belongs to another file brings
*************** The following statuses are defined.
*** 209,220 ****
  
  @multitable @columnfractions 0.25 0.75
  @item Flymake* or Flymake:E/W*
! @tab  Flymake is currently running. For the second case, E/W contains the
        error and warning count for the previous run.
  
  @item Flymake
! @tab  Syntax check is not running. Usually this means syntax check was
!       successfully passed (no errors, no warnings). Other possibilities are:
        syntax check was killed as a result of executing
        @code{flymake-compile}, or syntax check cannot start as compilation
        is currently in progress.
--- 209,220 ----
  
  @multitable @columnfractions 0.25 0.75
  @item Flymake* or Flymake:E/W*
! @tab  Flymake is currently running.  For the second case, E/W contains the
        error and warning count for the previous run.
  
  @item Flymake
! @tab  Syntax check is not running.  Usually this means syntax check was
!       successfully passed (no errors, no warnings).  Other possibilities are:
        syntax check was killed as a result of executing
        @code{flymake-compile}, or syntax check cannot start as compilation
        is currently in progress.
*************** OFF for the buffer.
*** 232,238 ****
  @multitable @columnfractions 0.25 0.75
  @item CFGERR
  @tab  Syntax check process returned nonzero exit code, but no
!       errors/warnings were reported. This indicates a possible configuration
        error (for example, no suitable error message patterns for the
        syntax check tool).
  
--- 232,238 ----
  @multitable @columnfractions 0.25 0.75
  @item CFGERR
  @tab  Syntax check process returned nonzero exit code, but no
!       errors/warnings were reported.  This indicates a possible configuration
        error (for example, no suitable error message patterns for the
        syntax check tool).
  
*************** OFF for the buffer.
*** 253,265 ****
  @cindex Troubleshooting
  
  Flymake uses a simple logging facility for indicating important points
! in the control flow. The logging facility sends logging messages to
! the @code{*Messages*} buffer. The information logged can be used for
  resolving various problems related to Flymake.
  
! Logging output is controlled by the @code{flymake-log-level}
! variable. @code{3} is the  most verbose level, and @code{-1} switches
! logging off.
  
  @node Configuring Flymake
  @chapter Configuring and Extending Flymake
--- 253,265 ----
  @cindex Troubleshooting
  
  Flymake uses a simple logging facility for indicating important points
! in the control flow.  The logging facility sends logging messages to
! the @code{*Messages*} buffer.  The information logged can be used for
  resolving various problems related to Flymake.
  
! Logging output is controlled by the @code{flymake-log-level} variable.
! @code{3} is the most verbose level, and @code{-1} switches logging
! off.
  
  @node Configuring Flymake
  @chapter Configuring and Extending Flymake
*************** started after @code{flymake-no-changes-t
*** 321,327 ****
  
  @item flymake-gui-warnings-enabled
  A boolean flag indicating whether Flymake will show message boxes for
! non-recoverable errors. If @code{flymake-gui-warnings-enabled} is
  @code{nil}, these errors will only be logged to the @code{*Messages*}
  buffer.
  
--- 321,327 ----
  
  @item flymake-gui-warnings-enabled
  A boolean flag indicating whether Flymake will show message boxes for
! non-recoverable errors.  If @code{flymake-gui-warnings-enabled} is
  @code{nil}, these errors will only be logged to the @code{*Messages*}
  buffer.
  
*************** Which fringe (if any) should show the wa
*** 360,366 ****
  @end menu
  
  Syntax check tools are configured using the
! @code{flymake-allowed-file-name-masks} list. Each item of this list
  has the following format:
  
  @lisp
--- 360,366 ----
  @end menu
  
  Syntax check tools are configured using the
! @code{flymake-allowed-file-name-masks} list.  Each item of this list
  has the following format:
  
  @lisp
*************** has the following format:
*** 371,384 ****
  @item filename-regexp
  This field is used as a key for locating init/cleanup/getfname
  functions for the buffer.  Items in
! @code{flymake-allowed-file-name-masks} are searched sequentially. The
  first item with @code{filename-regexp} matching buffer filename is
! selected. If no match is found, @code{flymake-mode} is switched off.
  
  @item init-function
  @code{init-function} is required to initialize the syntax check,
! usually by creating a temporary copy of the buffer contents. The
! function must return @code{(list cmd-name arg-list)}. If
  @code{init-function} returns null, syntax check is aborted, by
  @code{flymake-mode} is not switched off.
  
--- 371,384 ----
  @item filename-regexp
  This field is used as a key for locating init/cleanup/getfname
  functions for the buffer.  Items in
! @code{flymake-allowed-file-name-masks} are searched sequentially.  The
  first item with @code{filename-regexp} matching buffer filename is
! selected.  If no match is found, @code{flymake-mode} is switched off.
  
  @item init-function
  @code{init-function} is required to initialize the syntax check,
! usually by creating a temporary copy of the buffer contents.  The
! function must return @code{(list cmd-name arg-list)}.  If
  @code{init-function} returns null, syntax check is aborted, by
  @code{flymake-mode} is not switched off.
  
*************** usually deleting a temporary copy create
*** 389,395 ****
  
  @item getfname-function
  This function is used for translating filenames reported by the syntax
! check tool into ``real'' filenames. Filenames reported by the tool
  will be different from the real ones, as actually the tool works with
  the temporary copy.  In most cases, the default implementation
  provided by Flymake, @code{flymake-get-real-file-name}, can be used as
--- 389,395 ----
  
  @item getfname-function
  This function is used for translating filenames reported by the syntax
! check tool into ``real'' filenames.  Filenames reported by the tool
  will be different from the real ones, as actually the tool works with
  the temporary copy.  In most cases, the default implementation
  provided by Flymake, @code{flymake-get-real-file-name}, can be used as
*************** provided by Flymake, @code{flymake-get-r
*** 400,407 ****
  To add support for a new syntax check tool, write corresponding
  @code{init-function}, and, optionally @code{cleanup-function} and
  @code{getfname-function}.  If the format of error messages reported by
! the new tool is not yet supported by Flymake, add a new entry to
! the @code{flymake-err-line-patterns} list.
  
  The following sections contain some examples of configuring Flymake
  support for various syntax check tools.
--- 400,407 ----
  To add support for a new syntax check tool, write corresponding
  @code{init-function}, and, optionally @code{cleanup-function} and
  @code{getfname-function}.  If the format of error messages reported by
! the new tool is not yet supported by Flymake, add a new entry to the
! @code{flymake-err-line-patterns} list.
  
  The following sections contain some examples of configuring Flymake
  support for various syntax check tools.
*************** support for various syntax check tools.
*** 411,417 ****
  @cindex Adding support for perl
  
  In this example, we will add support for @code{perl} as a syntax check
! tool. @code{perl} supports the @code{-c} option which does syntax
  checking.
  
  First, we write the @code{init-function}:
--- 411,417 ----
  @cindex Adding support for perl
  
  In this example, we will add support for @code{perl} as a syntax check
! tool.  @code{perl} supports the @code{-c} option which does syntax
  checking.
  
  First, we write the @code{init-function}:
*************** In this example we will add support for
*** 463,469 ****
  @command{gcc} called via @command{make}.
  
  We're not required to write any new functions, as Flymake already has
! functions for @command{make}. We just add a new entry to the
  @code{flymake-allowed-file-name-masks}:
  
  @lisp
--- 463,469 ----
  @command{gcc} called via @command{make}.
  
  We're not required to write any new functions, as Flymake already has
! functions for @command{make}.  We just add a new entry to the
  @code{flymake-allowed-file-name-masks}:
  
  @lisp
*************** command line:
*** 489,495 ****
  
  @code{base-dir} is a directory containing @code{Makefile}, see @ref{Locating the buildfile}.
  
! Thus, @code{Makefile} must contain the @code{check-syntax} target. In
  our case this target might look like this:
  
  @verbatim
--- 489,495 ----
  
  @code{base-dir} is a directory containing @code{Makefile}, see @ref{Locating the buildfile}.
  
! Thus, @code{Makefile} must contain the @code{check-syntax} target.  In
  our case this target might look like this:
  
  @verbatim
*************** check-syntax:
*** 527,538 ****
  
  Syntax check is started by calling @code{flymake-start-syntax-check-for-current-buffer}.
  Flymake first determines whether it is able to do syntax
! check. It then saves a copy of the buffer in a temporary file in the
  buffer's directory (or in the system temp directory, for java
  files), creates a syntax check command and launches a process with
! this command. The output is parsed using a list of error message patterns,
  and error information (file name, line number, type and text) is
! saved. After the process has finished, Flymake highlights erroneous
  lines in the buffer using the accumulated error information.
  
  @node Determining whether syntax check is possible
--- 527,538 ----
  
  Syntax check is started by calling @code{flymake-start-syntax-check-for-current-buffer}.
  Flymake first determines whether it is able to do syntax
! check.  It then saves a copy of the buffer in a temporary file in the
  buffer's directory (or in the system temp directory, for java
  files), creates a syntax check command and launches a process with
! this command.  The output is parsed using a list of error message patterns,
  and error information (file name, line number, type and text) is
! saved.  After the process has finished, Flymake highlights erroneous
  lines in the buffer using the accumulated error information.
  
  @node Determining whether syntax check is possible
*************** Two syntax check modes are distinguished
*** 550,564 ****
  
  @item
  Buffer can be syntax checked in a standalone fashion, that is, the
! file (its temporary copy, in fact) can be passed over to the compiler to
! do the syntax check. Examples are C/C++ (.c, .cpp) and Java (.java)
! sources.
  
  @item
  Buffer can be syntax checked, but additional file, called master file,
! is required to perform this operation. A master file is a file that
  includes the current file, so that running a syntax check tool on it
! will also check syntax in the current file. Examples are C/C++ (.h,
  .hpp) headers.
  
  @end enumerate
--- 550,564 ----
  
  @item
  Buffer can be syntax checked in a standalone fashion, that is, the
! file (its temporary copy, in fact) can be passed over to the compiler
! to do the syntax check.  Examples are C/C++ (.c, .cpp) and Java
! (.java) sources.
  
  @item
  Buffer can be syntax checked, but additional file, called master file,
! is required to perform this operation.  A master file is a file that
  includes the current file, so that running a syntax check tool on it
! will also check syntax in the current file.  Examples are C/C++ (.h,
  .hpp) headers.
  
  @end enumerate
*************** copies, finding master files, etc.), as
*** 579,585 ****
  
  After the possibility of the syntax check has been determined, a
  temporary copy of the current buffer is made so that the most recent
! unsaved changes could be seen by the syntax check tool. Making a copy
  is quite straightforward in a standalone case (mode @code{1}), as it's
  just saving buffer contents to a temporary file.
  
--- 579,585 ----
  
  After the possibility of the syntax check has been determined, a
  temporary copy of the current buffer is made so that the most recent
! unsaved changes could be seen by the syntax check tool.  Making a copy
  is quite straightforward in a standalone case (mode @code{1}), as it's
  just saving buffer contents to a temporary file.
  
*************** name.
*** 595,605 ****
  Locating a master file is discussed in the following section.
  
  Patching just changes all appropriate lines of the master file so that they
! use the new (temporary) name of the current file. For example, suppose current
  file name is @code{file.h}, the master file is @code{file.cpp}, and
! it includes current file via @code{#include "file.h"}. Current file's copy
  is saved to file @code{file_flymake.h}, so the include line must be
! changed to @code{#include "file_flymake.h"}. Finally, patched master file
  is saved to @code{file_flymake_master.cpp}, and the last one is passed to
  the syntax check tool.
  
--- 595,605 ----
  Locating a master file is discussed in the following section.
  
  Patching just changes all appropriate lines of the master file so that they
! use the new (temporary) name of the current file.  For example, suppose current
  file name is @code{file.h}, the master file is @code{file.cpp}, and
! it includes current file via @code{#include "file.h"}.  Current file's copy
  is saved to file @code{file_flymake.h}, so the include line must be
! changed to @code{#include "file_flymake.h"}.  Finally, patched master file
  is saved to @code{file_flymake_master.cpp}, and the last one is passed to
  the syntax check tool.
  
*************** the syntax check tool.
*** 609,655 ****
  
  Master file is located in two steps.
  
! First, a list of possible master files is built. A simple name
! matching is used to find the files. For a C++ header @code{file.h},
  Flymake searches for all @code{.cpp} files in the directories whose relative paths are
  stored in a customizable variable @code{flymake-master-file-dirs}, which
! usually contains something like @code{("." "./src")}. No more than
  @code{flymake-master-file-count-limit} entries is added to the master file
! list. The list is then sorted to move files with names @code{file.cpp} to
  the top.
  
  Next, each master file in a list is checked to contain the appropriate
! include directives. No more than @code{flymake-check-file-limit} of each
  file are parsed.
  
  For @code{file.h}, the include directives to look for are
! @code{#include "file.h"}, @code{#include "../file.h"}, etc. Each
  include is checked against a list of include directories
  (see @ref{Getting the include directories}) to be sure it points to the
  correct @code{file.h}.
  
! First matching master file found stops the search. The master file is then
! patched and saved to disk. In case no master file is found, syntax check is
  aborted, and corresponding status (!) is reported in the mode line.
  
  @node Getting the include directories
  @section Getting the include directories
  @cindex Include directories (C/C++ specific)
  
! Two sets of include directories are distinguished: system include directories
! and project include directories. The former is just the contents of the
! @code{INCLUDE} environment variable. The latter is not so easy to obtain,
! and the way it can be obtained can vary greatly for different projects.
! Therefore, a customizable variable
! @code{flymake-get-project-include-dirs-function} is used to provide the
! way to implement the desired behavior.
  
  The default implementation, @code{flymake-get-project-include-dirs-imp},
! uses a @command{make} call. This requires a correct base directory, that is, a
  directory containing a correct @file{Makefile}, to be determined.
  
  As obtaining the project include directories might be a costly operation, its
! return value is cached in the hash table. The cache is cleared in the beginning
  of every syntax check attempt.
  
  @node Locating the buildfile
--- 609,655 ----
  
  Master file is located in two steps.
  
! First, a list of possible master files is built.  A simple name
! matching is used to find the files.  For a C++ header @code{file.h},
  Flymake searches for all @code{.cpp} files in the directories whose relative paths are
  stored in a customizable variable @code{flymake-master-file-dirs}, which
! usually contains something like @code{("." "./src")}.  No more than
  @code{flymake-master-file-count-limit} entries is added to the master file
! list.  The list is then sorted to move files with names @code{file.cpp} to
  the top.
  
  Next, each master file in a list is checked to contain the appropriate
! include directives.  No more than @code{flymake-check-file-limit} of each
  file are parsed.
  
  For @code{file.h}, the include directives to look for are
! @code{#include "file.h"}, @code{#include "../file.h"}, etc.  Each
  include is checked against a list of include directories
  (see @ref{Getting the include directories}) to be sure it points to the
  correct @code{file.h}.
  
! First matching master file found stops the search.  The master file is then
! patched and saved to disk.  In case no master file is found, syntax check is
  aborted, and corresponding status (!) is reported in the mode line.
  
  @node Getting the include directories
  @section Getting the include directories
  @cindex Include directories (C/C++ specific)
  
! Two sets of include directories are distinguished: system include
! directories and project include directories.  The former is just the
! contents of the @code{INCLUDE} environment variable.  The latter is
! not so easy to obtain, and the way it can be obtained can vary greatly
! for different projects.  Therefore, a customizable variable
! @code{flymake-get-project-include-dirs-function} is used to provide
! the way to implement the desired behavior.
  
  The default implementation, @code{flymake-get-project-include-dirs-imp},
! uses a @command{make} call.  This requires a correct base directory, that is, a
  directory containing a correct @file{Makefile}, to be determined.
  
  As obtaining the project include directories might be a costly operation, its
! return value is cached in the hash table.  The cache is cleared in the beginning
  of every syntax check attempt.
  
  @node Locating the buildfile
*************** of every syntax check attempt.
*** 659,676 ****
  @cindex Makefile, locating
  
  Flymake can be configured to use different tools for performing syntax
! checks. For example, it can use direct compiler call to syntax check a perl
  script or a call to @command{make} for a more complicated case of a
! @code{C/C++} source. The general idea is that simple files, like perl
  scripts and html pages, can be checked by directly invoking a
! corresponding tool. Files that are usually more complex and generally
  used as part of larger projects, might require non-trivial options to
  be passed to the syntax check tool, like include directories for
! C++. The latter files are syntax checked using some build tool, like
  Make or Ant.
  
  All Make configuration data is usually stored in a file called
! @code{Makefile}. To allow for future extensions, flymake uses a notion of
  buildfile to reference the 'project configuration' file.
  
  Special function, @code{flymake-find-buildfile} is provided for locating buildfiles.
--- 659,676 ----
  @cindex Makefile, locating
  
  Flymake can be configured to use different tools for performing syntax
! checks.  For example, it can use direct compiler call to syntax check a perl
  script or a call to @command{make} for a more complicated case of a
! @code{C/C++} source.  The general idea is that simple files, like perl
  scripts and html pages, can be checked by directly invoking a
! corresponding tool.  Files that are usually more complex and generally
  used as part of larger projects, might require non-trivial options to
  be passed to the syntax check tool, like include directories for
! C++.  The latter files are syntax checked using some build tool, like
  Make or Ant.
  
  All Make configuration data is usually stored in a file called
! @code{Makefile}.  To allow for future extensions, flymake uses a notion of
  buildfile to reference the 'project configuration' file.
  
  Special function, @code{flymake-find-buildfile} is provided for locating buildfiles.
*************** for possible master files.
*** 679,685 ****
  @ignore
  A customizable variable
  @code{flymake-buildfile-dirs} holds a list of relative paths to the
! buildfile. They are checked sequentially until a buildfile is found.
  @end ignore
  In case there's no build file, syntax check is aborted.
  
--- 679,685 ----
  @ignore
  A customizable variable
  @code{flymake-buildfile-dirs} holds a list of relative paths to the
! buildfile.  They are checked sequentially until a buildfile is found.
  @end ignore
  In case there's no build file, syntax check is aborted.
  
*************** Buildfile values are also cached.
*** 690,696 ****
  @cindex Syntax check process
  
  The command line (command name and the list of arguments) for launching a process is returned by the
! initialization function. Flymake then just calls @code{start-process}
  to start an asynchronous process and configures process filter and
  sentinel which is used for processing the output of the syntax check
  tool.
--- 690,696 ----
  @cindex Syntax check process
  
  The command line (command name and the list of arguments) for launching a process is returned by the
! initialization function.  Flymake then just calls @code{start-process}
  to start an asynchronous process and configures process filter and
  sentinel which is used for processing the output of the syntax check
  tool.
*************** tool.
*** 701,724 ****
  
  The output generated by the syntax check tool is parsed in the process
  filter/sentinel using the error message patterns stored in the
! @code{flymake-err-line-patterns} variable. This variable contains a
  list of items of the form @code{(regexp file-idx line-idx
  err-text-idx)}, used to determine whether a particular line is an
  error message and extract file name, line number and error text,
! respectively. Error type (error/warning) is also guessed by matching
! error text with the '@code{^[wW]arning}' pattern. Anything that was not
! classified as a warning is considered an error. Type is then used to
  sort error menu items, which shows error messages first.
  
  Flymake is also able to interpret error message patterns missing err-text-idx
! information. This is done by merely taking the rest of the matched line
! (@code{(substring line (match-end 0))}) as error text. This trick allows
  to make use of a huge collection of error message line patterns from
! @code{compile.el}. All these error patterns are appended to
  the end of @code{flymake-err-line-patterns}.
  
  The error information obtained is saved in a buffer local
! variable. The buffer for which the process output belongs is
  determined from the process-id@w{}->@w{}buffer mapping updated
  after every process launch/exit.
  
--- 701,724 ----
  
  The output generated by the syntax check tool is parsed in the process
  filter/sentinel using the error message patterns stored in the
! @code{flymake-err-line-patterns} variable.  This variable contains a
  list of items of the form @code{(regexp file-idx line-idx
  err-text-idx)}, used to determine whether a particular line is an
  error message and extract file name, line number and error text,
! respectively.  Error type (error/warning) is also guessed by matching
! error text with the '@code{^[wW]arning}' pattern.  Anything that was not
! classified as a warning is considered an error.  Type is then used to
  sort error menu items, which shows error messages first.
  
  Flymake is also able to interpret error message patterns missing err-text-idx
! information.  This is done by merely taking the rest of the matched line
! (@code{(substring line (match-end 0))}) as error text.  This trick allows
  to make use of a huge collection of error message line patterns from
! @code{compile.el}.  All these error patterns are appended to
  the end of @code{flymake-err-line-patterns}.
  
  The error information obtained is saved in a buffer local
! variable.  The buffer for which the process output belongs is
  determined from the process-id@w{}->@w{}buffer mapping updated
  after every process launch/exit.
  
*************** after every process launch/exit.
*** 727,733 ****
  @cindex Erroneous lines, faces
  
  Highlighting is implemented with overlays and happens in the process
! sentinel, after calling the cleanup function. Two customizable faces
  are used: @code{flymake-errline} and
  @code{flymake-warnline}.  Errors belonging outside the current
  buffer are considered to belong to line 1 of the current buffer.
--- 727,733 ----
  @cindex Erroneous lines, faces
  
  Highlighting is implemented with overlays and happens in the process
! sentinel, after calling the cleanup function.  Two customizable faces
  are used: @code{flymake-errline} and
  @code{flymake-warnline}.  Errors belonging outside the current
  buffer are considered to belong to line 1 of the current buffer.
*************** and @code{flymake-warning-bitmap}.
*** 749,759 ****
  The only mode flymake currently knows about is @code{compile}.
  
  Flymake can be configured to not start syntax check if it thinks the
! compilation is in progress. The check is made by the
  @code{flymake-compilation-is-running}, which tests the
! @code{compilation-in-progress} variable. The reason why this might be
  useful is saving CPU time in case both syntax check and compilation
! are very CPU intensive. The original reason for adding this feature,
  though, was working around a locking problem with MS Visual C++ compiler.
  
  Flymake also provides an alternative command for starting compilation,
--- 749,759 ----
  The only mode flymake currently knows about is @code{compile}.
  
  Flymake can be configured to not start syntax check if it thinks the
! compilation is in progress.  The check is made by the
  @code{flymake-compilation-is-running}, which tests the
! @code{compilation-in-progress} variable.  The reason why this might be
  useful is saving CPU time in case both syntax check and compilation
! are very CPU intensive.  The original reason for adding this feature,
  though, was working around a locking problem with MS Visual C++ compiler.
  
  Flymake also provides an alternative command for starting compilation,

^ permalink raw reply	[flat|nested] 3+ messages in thread
end of thread, other threads:[~2013-05-10  8:19 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2013-02-23 14:06 [patch] Some fixes for flymake Xue Fuqiao
2013-05-10  1:20 ` Glenn Morris
2013-05-10  8:19   ` Xue Fuqiao

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).