I just tried out flymake and it is pretty neat. It highlights errors as advertised
and brings up a little pop-up window with the error message when your mouse is over 
the line.

If you have jde-compile setup correctly to compile the current file then this 
redefinition
for flymake-start-syntax-check-process will automatically run jde-compile.

Caveats :
        * flymake automatically saves your current buffer before it compiles
        * the error/warning message do not appear in the minibuffer when point is on a 
line
          which has been highlighted.
        * may not be very nice on a slower machine using javac




(defun flymake-start-syntax-check-process(buffer base-dir master-file-name patched-master-file-name source-file-name patched-source-file-name) "start syntax check-process"

  (let* ((process          nil)
         (file-to-compile  (flymake-get-file-to-compile patched-master-file-name 
patched-source-file-name source-file-name))
         (compiler (jde-compile-get-the-compiler))
         (program-name     (oref compiler :path))
         (program-args     (append (jde-compile-get-args compiler) (list 
file-to-compile))))
    (condition-case err
        (progn
          (setq process (get-process (apply 'start-process
                                            "flymake-proc"
                                                                                       
          nil
                                                                                       
          program-name
                                                                                       
          program-args)))
                                (set-process-sentinel process 
'flymake-process-sentinel)
                                (set-process-filter process 'flymake-process-filter)

                                (flymake-reg-names(process-id process) (buffer-name 
buffer) patched-master-file-name patched-source-file-name)
                                (flymake-set-buffer-base-dir buffer base-dir)
                                (flymake-set-buffer-master-file-name buffer 
master-file-name)
                                (flymake-set-buffer-is-running buffer t)
                                (flymake-set-buffer-last-change-time buffer nil)
                                (flymake-set-buffer-check-start-time buffer 
(float-time))

                                (flymake-report-status buffer nil "*")
                                (flymake-log 2 "started process %d, command=%s, dir=%s"
                                                   (process-id process) 
(process-command process) default-directory)
                                process
                        )
                (error
                            (let ((err-str (format "Failed to launch syntax check process 
'%s' with args %s: %s"
                                                         program-name program-args 
(error-message-string err))))
                                    (flymake-log 0 err-str)
                                    (flymake-safe-delete-file patched-master-file-name)
                                        (flymake-safe-delete-file 
patched-source-file-name)
                                        (flymake-set-buffer-last-change-time buffer 
nil)
                                        (flymake-report-fatal-status buffer "PROCERR" 
err-str)
                        )
                    )
            )
        )
)


Suraj


Eric M. Ludlam wrote:

The support for highlighting unmatched syntax is still rudimentary,
but it is a longterm goal to highlight all syntactic issues.  Parsing
an entire file is pretty slow.  Parsing only the visible parts, is one
option.  For missing ; after things already being parsed (method and
type declarations) you will get the highlighting.  The new incremental
parser helps with this.

Detecting missing imports or methods is not a part of any short term
plan.  The semantic analyzer has not been modified much as we've been
concentrating on low level APIs, and speed.

The version of eieio in the beta includes a feature similar to
something I think is called flymake.  You can run a build, and it will
detect the errors, and highlight them for you.  I think flymake may
have more user features.  The version in eieio is an example program
for using a line highlighting feature.

Eric




Reply via email to