2:08 a.m.
On Wed, 21 Jun 2000, Stephen J. Turnbull <turnbull(a)sk.tsukuba.ac.jp>
wrote:
>>>>> "John" == John A Turner
<turner(a)blueskystudios.com> writes:
John> Would anyone like to look at sniff.el to see if anything
John> jumps out about it? It's over 600 lines long, so I hate to
John> just post the thing...
Is this kind of reticence necessary on this list? I basically "live
in the sewer of the Japanese Internet" so I don't much notice how much
s2t floats by. If it's not necessary, I'd rather have the stuff
accessible in case I want to look....
But if bandwidth is something that worries anybody, how about creating
an "xemacs-beta-large" where kyle can post multimedia editorial
comments and Ben can _literally_ talk us through our problems, and
people with something "large" like a 600 line lisp file or a 1000 line
inflooping backtrace can post it?
Maybe somewhere on ftp.xemacs.org that let people drop files for a few
days? That way those who don't have their own web server (or spcae)
could post an URL?
Daniel
--
A good poet is someone who manages, in a lifetime of standing out in
thunderstorms, to be struck by lightning five or six times; a dozen or two
dozen times and he is great.
-- Randall Jarrell
2:56 a.m.
New subject: "Large" posts
Daniel Pittman writes:
Maybe somewhere on ftp.xemacs.org that let people drop files for a few
days? That way those who don't have their own web server (or spcae)
could post an URL?
But wouldn't this be likely to attract, um, `unwelcome'
contributions. (Hey kidz, here's an FTP server that allows
anonymous uploadz!) Stephen's suggestion about automatically
diverting large messages to a -large list seems to me to be a good
one. Of course like all good suggestions the problem is that you have
to get somebody to implement it.
Certainly we all have our own standards and it's good to be
considerate of those on slow links, but to me 600 lines of text just
isn't that large. Hey, if we go on discussing this a little longer,
the traffic dealing with this issue will exceed the 600 lines that
John was reticent to post in the first place! I'm trying to do my
share to increase the line count, but I think I've run out of things
to say.
-c
6:58 p.m.
New subject: unrecognized selection-conversion type
>>>> "CGW" == Charles G Waldman
<cgw(a)fnal.gov>:
CGW> Certainly we all have our own standards and it's good to be
CGW> considerate of those on slow links, but to me 600 lines of text just
CGW> isn't that large.
you're right, of course... here's the file:
;;; sniff-mode.el --- Minor mode for interacting with SNiFF+
;; Author: Gheorghe Chita <gil(a)TakeFive.co.at>
;; Maintainer: Josef Leherbauer <joe(a)TakeFive.co.at>
;; Created: 26 Jul 1993
;; Revision: 2.3
;; Keywords: tools sniff
;;; Commentary:
;; This file defines a minor mode to be used when editing C/C++ source files.
;; It creates a communication channel between Emacs and SNiFF+.
;; Usage
;; =====
;; 1) Load sniff-mode.el, or put a line like (load "sniff-mode") in
;; your .emacs file.
;; 2) Start SNiFF+ (v2.x) and enable Emacs in the Editor Preferences.
;; 3) M-x sniff-connect RET
;; 4) Load a project in SNiFF+ and double click on the desired symbol.
;; The corresponding file will be loaded in an Emacs buffer, and the
;; buffer will be put in Sniff mode.
;;
;; You can now use Sniff mode-specific commands. Do `C-h b'
;; (`describe-bindings') to see the new commands available.
;; Do `C-h k' (`describe-key') to get the documentation of the
;; individual commands.
;; Author: Gheorghe Chita
;; TakeFive Software GesmbH
;; Jakob Haringer Str. 8
;; Salzburg, A-5020
;; A U S T R I A
;; Phone: +43 662 457 915
;; Fax: +43 662 457 915 6
;; Email: gil(a)TakeFive.co.at
;;; Acknowledgements:
;; Thanks to Jordan K. Hubbard <jkh(a)whisker.lotus.ie> and
;; Michael Scharf <Michael.Scharf(a)embl-Heidelberg.de> for many useful ideas.
;;
;; The idea of using a buffer to gather bytes from a process until a regexp
;; is seen at the head of the buffer is taken from the transaction queue
;; library tq.el (thanks Scott Draves <spot(a)cs.cmu.edu>).
;;
;; The function sniff-symbol-around-point is the same as find-tag-default
;; in etags.el (thanks Roland McGrath <roland(a)gnu.ai.mit.edu>).
;;; Code:
(provide 'sniff-mode)
(defvar sniff-mode nil)
(make-variable-buffer-local 'sniff-mode)
(or (assq 'sniff-mode minor-mode-alist)
(setq minor-mode-alist
(cons '(sniff-mode " Sniff") minor-mode-alist)))
(defvar sniff-mode-map ()
"Keymap used in Sniff mode.")
(if sniff-mode-map
()
(setq sniff-mode-map (make-sparse-keymap))
(define-key sniff-mode-map "\C-c\C-e" 'sniff-toggle)
(define-key sniff-mode-map "\C-c\C-s" 'sniff-superclass)
(define-key sniff-mode-map "\C-c\C-o" 'sniff-overridden)
(define-key sniff-mode-map "\C-c\C-r" 'sniff-retrieve)
(define-key sniff-mode-map "\C-c\C-\M-r" 'sniff-retrieve-next)
(define-key sniff-mode-map "\C-c\C-g" 'sniff-goto-symbol)
(define-key sniff-mode-map "\C-c\C-f" 'sniff-find-symbol)
(define-key sniff-mode-map "\C-c\C-b" 'sniff-browse-class)
(define-key sniff-mode-map "\C-c\C-h" 'sniff-hierarchy)
(define-key sniff-mode-map "\C-c\C-\M-h" 'sniff-restr-hier)
(define-key sniff-mode-map "\C-c\C-x" 'sniff-xref-to)
(define-key sniff-mode-map "\C-c\C-\M-x" 'sniff-xref-by)
(define-key sniff-mode-map "\C-c\C-c" 'sniff-xref-has)
(define-key sniff-mode-map "\C-c\C-\M-c" 'sniff-xref-usedby)
(define-key sniff-mode-map "\C-c\C-d" 'sniff-show-docu)
(define-key sniff-mode-map "\C-c\C-\M-d" 'sniff-gen-docu))
(or (assq 'sniff-mode minor-mode-map-alist)
(setq minor-mode-map-alist
(cons (cons 'sniff-mode sniff-mode-map) minor-mode-map-alist)))
(defvar sniff-symbol-history nil
"History of symbols entered in the minibuffer.")
(defconst sniff-is-xemacs (string-match "Lucid\\|XEmacs" emacs-version)
"Non-nil means the running Emacs is a version of XEmacs or Lucid Emacs.")
;;; Symbol highlighting, font management
(defvar sniff-want-fonts t
"*Non-nil means highlight symbols and comments according to
sniff-font-table.")
(defvar sniff-font-table nil
"*Vector of font codes. See sniff-mode.el for details.")
;; Change the table below to suit your needs.
(if sniff-font-table
()
(setq sniff-font-table [
italic ; comment
bold ; macro
bold ; class, struct, union
bold-italic ; member variable
bold ; member function declaration
bold ; member function definition
bold ; function definition
bold ; friend
bold ; typedef
bold ; variable definition
bold ; constant
bold ; enum
bold ; enum item
bold ; user def object
]))
(defun sniff-change-font (symbol-code from to)
(if sniff-is-xemacs
;; XEmacs
(let ((ext (make-extent from (1+ to))))
(set-extent-property ext 'face (aref sniff-font-table symbol-code))
(set-extent-property ext 'sniff t))
;; FSF Emacs
(let ((ovl (make-overlay from (1+ to))))
(overlay-put ovl 'face (aref sniff-font-table symbol-code))
(overlay-put ovl 'sniff t))))
(defun sniff-delete-fonts ()
"Delete fonts from the current buffer."
(interactive)
(if sniff-is-xemacs
;; XEmacs
(map-extents (function (lambda (ext arg)
(if (extent-property ext 'sniff)
(delete-extent ext))
nil)))
;; FSF Emacs
(let ((pos (next-overlay-change 1)) (max-pos (point-max)) ovl)
(while (< pos max-pos)
(mapcar (function (lambda (ovl)
(if (overlay-get ovl 'sniff)
(delete-overlay ovl))
nil))
(overlays-at pos))
(setq pos (next-overlay-change pos))))))
;;; Support for Japanese characters when running under MULE (MUlti Lingual Emacs)
;; Vector containing the buffer position of those (EUC or SJIS encoded)
;; multi-byte characters whose MULE-internal encoding requires one additional byte.
;; This is the case for Kanji characters in both encodings, for half-width Katakana
;; characters only in SJIS encoding. See `sniff-mule-make-table'.
;; The table is sorted in ascending order and recreated whenever the buffer is saved.
;;
(defvar sniff-mule-table nil)
(make-variable-buffer-local 'sniff-mule-table)
(defconst sniff-is-mule (fboundp 'mule-version)
"Non-nil means the running Emacs is a version of MULE (MUlti Lingual
Emacs).")
;; Sniff ---> MULE
;; Translate Sniff file position to MULE buffer position
(defun sniff-mule-xlate-down (pos)
(if sniff-is-mule
(let (i (shift 1) (low 0) (high (length (sniff-mule-make-table))))
(while (and (< low high) (> shift 0))
(setq i (sniff-mule-find-pos pos low high)
shift (- i low)
pos (+ pos shift)
low i))))
pos)
;; Sniff <--- MULE
;; Translate MULE buffer position to Sniff file position
(defun sniff-mule-xlate-up (pos)
(if sniff-is-mule
(setq pos (- pos (sniff-mule-find-pos pos 0 (length (sniff-mule-make-table))))))
pos)
;; Binary search `pos' in `sniff-mule-table' between indices `low' and
`high'
;; Return index of first element which is >= `pos'
(defun sniff-mule-find-pos (pos low high)
(let (i mb-pos)
(while (progn (setq i (/ (+ low high) 2))
(< low high))
(setq mb-pos (aref sniff-mule-table i))
(cond ((> pos mb-pos) (setq low (1+ i)))
((< pos mb-pos) (setq high i))
((= pos mb-pos) (setq low i high i))))
i))
;; Create the multi-byte translation table
(defun sniff-mule-make-table ()
(if sniff-mule-table
()
(let ((i 1) (max-pos (buffer-size)) (tail (cons nil nil)) mb-flag
(is-sjis (eq file-coding-system '*sjis*unix)))
(setq sniff-mule-table tail)
(while (< i max-pos)
(setq mb-flag (char-boundary-p i))
(if (or (and (= mb-flag 1) is-sjis) ; 2-byte char (half-width Katakana)
(= mb-flag 2)) ; 3-byte char (Kanji)
(setq tail (setcdr tail (cons i nil))))
(setq i (+ 1 i mb-flag)))
(setq sniff-mule-table (vconcat (cdr sniff-mule-table)))))
sniff-mule-table)
;;; The sniff process
(defvar sniff-process nil)
(defconst sniff-process-name "Sniff")
(defconst sniff-buffer-name "*Sniff*")
(defconst sniff-comm "sniffemacs")
(defun sniff-connect ()
"Open connection to SNiFF+."
(interactive)
(cond ((not sniff-process)
(setq sniff-process
(start-process sniff-process-name sniff-buffer-name sniff-comm))
(set-process-filter sniff-process 'sniff-filter)
(set-process-sentinel sniff-process 'sniff-sentinel)
(process-kill-without-query sniff-process))))
(defun sniff-sentinel (process event)
(sniff-filter process "") ; flush the message queue
(setq sniff-process nil)
(kill-buffer sniff-buffer-name))
(defun sniff-disconnect ()
"Close connection to SNiFF+."
(interactive)
(if sniff-process
(process-send-string sniff-process "q\n")))
(defun sniff-simple-request (request-code)
(if sniff-process
(process-send-string sniff-process
(format "%c%s\n" request-code (buffer-file-name)))))
(defun sniff-context-request (request-code symbol)
(if (and sniff-process (> (length symbol) 0))
(process-send-string sniff-process
(format "%c%s %d %s\n"
request-code
(buffer-file-name)
(sniff-mule-xlate-up (point))
symbol))))
(defsubst sniff-read-arg (prompt)
(list (read-from-minibuffer prompt (sniff-symbol-around-point)
nil nil 'sniff-symbol-history)))
(defun sniff-mode (&optional arg)
"Minor mode for editing C/C++ code with the help of SNiFF+.
Commands marked with a `*' read an argument from the minibuffer.
The string around point is inserted as the default argument.
Available commands:
\\<sniff-mode-map>* \\[sniff-goto-symbol] Show the source code of a symbol.
* \\[sniff-superclass] Show the baseclass of a class.
\\[sniff-overridden] Show the overridden method.
\\[sniff-toggle] Toggle declaration/implementation of a symbol.
* \\[sniff-browse-class] Browse a class in the Class Browser.
* \\[sniff-hierarchy] Show a class in the entire class hierarchy.
* \\[sniff-restr-hier] Show the relatives of a class in the class hierarchy.
* \\[sniff-retrieve] Retrieve from this file.
* \\[sniff-retrieve-proj] Retrieve from this project.
* \\[sniff-retrieve-allprojs] Retrieve from all projects.
\\[sniff-retrieve-next] Retrieve (using Retriever settings).
* \\[sniff-find-symbol] Find all symbols matching a string.
* \\[sniff-xref-to] Show refers-to relationships in the Cross Referencer.
* \\[sniff-xref-by] Show referred-by relationships in the Cross Referencer.
* \\[sniff-xref-has] Show has-a relationships in the Cross Referencer.
* \\[sniff-xref-usedby] Show used-by relationships in the Cross Referencer.
* \\[sniff-show-docu] Show the documentation of a symbol.
* \\[sniff-gen-docu] Generate the documentation for a symbol."
(interactive)
(setq sniff-mode
(if (null arg) (not sniff-mode)
(> (prefix-numeric-value arg) 0)))
(if sniff-mode
(progn
(sniff-connect)
(sniff-update)
(and sniff-is-xemacs
current-menubar
(not (assoc "Sniff" current-menubar))
(add-menu nil "Sniff" sniff-mode-menu)))))
(defun sniff-filter (proc string)
"Append STRING to Sniff's buffer; then process the new data."
(let ((message nil))
(save-excursion
(set-buffer sniff-buffer-name)
(goto-char (point-max))
(insert string)
(setq message (sniff-process-buffer)))
(while message
(sniff-dispatch message)
(save-excursion
(set-buffer sniff-buffer-name)
(setq message (sniff-process-buffer))))))
(defun sniff-process-buffer ()
"Check current buffer for a new message."
(goto-char (point-min))
(if (re-search-forward "\\(.*\\)\n" nil t)
(let ((message (buffer-substring (point-min) (1- (point)))))
(delete-region (point-min) (point))
message)))
(defun sniff-dispatch (string)
"Extract the command and the arguments from the STRING."
(let ((command (aref string 0))
(arguments (substring string 1)))
(cond ((or (= command ?o) (= command ?O)) ; Open file, position at character/line
(raise-frame)
(if (string-match "\\([^ ]+\\) \\([0-9]+\\) \\([0-9]+\\)" arguments)
(let* ((file-name (substring arguments
(match-beginning 1)
(match-end 1)))
(position (string-to-int (substring arguments
(match-beginning 2)
(match-end 2))))
(writable (string-to-int (substring arguments
(match-beginning 3)
(match-end 3))))
(file-buffer (find-file-noselect file-name)))
(let ((old-buf (current-buffer)))
(unwind-protect
(progn
(set-buffer file-buffer)
(setq buffer-read-only (= writable 0))
(if (not sniff-mode)
(sniff-mode 1))
(if (> position 0)
(if (= command ?o)
(goto-char (sniff-mule-xlate-down position))
(goto-line position))))
(set-buffer old-buf)))
(if (= (minibuffer-depth) 0)
(switch-to-buffer file-buffer)
;;(display-buffer file-buffer)
(message "File %s loaded; type \"C-x b %s\" to view it."
(buffer-name file-buffer) (buffer-name file-buffer))))))
((= command ?p) ; Path of a file has changed
(if (string-match "\\([^ ]+\\) \\([^ ]+\\)" arguments)
(let* ((old-file-name (substring arguments
(match-beginning 1)
(match-end 1)))
(new-file-name (substring arguments
(match-beginning 2)
(match-end 2)))
(already-loaded (get-file-buffer old-file-name)))
(if already-loaded
(save-excursion
(set-buffer already-loaded)
(delete-auto-save-file-if-necessary)
(set-visited-file-name new-file-name)
(set-buffer-modified-p nil)
(revert-buffer nil t)
(sniff-mode 1))))))
((= command ?w) ; Writability of file has changed
(if (string-match "\\([^ ]+\\) \\([0-9]+\\)" arguments)
(let* ((file-name (substring arguments
(match-beginning 1)
(match-end 1)))
(writable (string-to-int
(substring arguments
(match-beginning 2)
(match-end 2))))
(already-loaded (get-file-buffer file-name)))
(if already-loaded
(save-excursion
(set-buffer already-loaded)
(setq buffer-read-only (= writable 0)))))))
((= command ?h) ; Highlight info
(if (string-match "\\([^ ]+\\) \\([0-9]+\\) \\([0-9]+\\) \\([0-9]+\\)"
arguments)
(let* ((file-name (substring arguments
(match-beginning 1)
(match-end 1)))
(symbol-code (string-to-int (substring arguments
(match-beginning 2)
(match-end 2))))
(from (string-to-int (substring arguments
(match-beginning 3)
(match-end 3))))
(to (string-to-int (substring arguments
(match-beginning 4)
(match-end 4))))
(already-loaded (get-file-buffer file-name)))
(if already-loaded
(save-excursion
(set-buffer already-loaded)
(sniff-change-font symbol-code
(sniff-mule-xlate-down from)
(sniff-mule-xlate-down to)))))))
((= command ?t) ; Tab width
(if (string-match "\\([^ ]+\\) \\([0-9]+\\)" arguments)
(let* ((file-name (substring arguments
(match-beginning 1)
(match-end 1)))
(already-loaded (get-file-buffer file-name)))
(if already-loaded
(save-excursion (set-buffer already-loaded)
(setq tab-width
(string-to-int
(substring arguments
(match-beginning 2)
(match-end 2)))))))))
((or (= command ?a) ; Error message
(= command ?A)) ; Warning message
(message "sniff: %s" arguments)))))
;;; Find and return the symbol around the point.
;;; Copied from etags.el.
(defun sniff-symbol-around-point ()
"Return the string around point."
(save-excursion
(while (looking-at "\\sw\\|\\s_")
(forward-char 1))
(if (or (re-search-backward "\\sw\\|\\s_"
(save-excursion (beginning-of-line) (point))
t)
(re-search-forward "\\(\\sw\\|\\s_\\)+"
(save-excursion (end-of-line) (point))
t))
(progn (goto-char (match-end 0))
(buffer-substring (point)
(progn (forward-sexp -1)
(while (looking-at "\\s'")
(forward-char 1))
(point))))
nil)))
;;; Sniff requests
(setq sniff-fastsave nil)
(defun sniff-after-save ()
(if sniff-mode
(sniff-update))
(setq sniff-mule-table nil))
(add-hook 'after-save-hook 'sniff-after-save)
(defun sniff-filechanged ()
"Update file status."
(interactive)
(sniff-simple-request ?U))
(defun sniff-reparse ()
"Reparse the file."
(interactive)
(sniff-simple-request ?u)
(sniff-fonts))
(defun sniff-writebuffer ()
"Save buffer w/o reparse."
(interactive)
(setq sniff-fastsave 1)
(save-buffer)
(setq sniff-fastsave nil))
(defun sniff-update ()
""
(interactive)
(sniff-filechanged)
(if (not sniff-fastsave)
(sniff-reparse)))
(defun sniff-fonts ()
"Ask SNiFF+ to send font information."
(interactive)
(if (and window-system sniff-want-fonts)
(progn
(sniff-delete-fonts)
(sniff-simple-request ?z))))
(defun sniff-toggle ()
"Toggle between declaration and implementation."
(interactive)
(sniff-context-request ?e " "))
(defun sniff-superclass (symbol)
"Show the Baseclass of a class."
(interactive (sniff-read-arg "Show Baseclass Of: "))
(sniff-context-request ?s symbol))
(defun sniff-overridden ()
"Show Overridden Method."
(interactive)
(sniff-context-request ?m " "))
(defun sniff-retrieve (symbol)
"Retrieve selection from this file."
(interactive (sniff-read-arg "Retrieve: "))
(sniff-context-request ?r symbol))
(defun sniff-retrieve-proj (symbol)
"Retrieve selection from this project."
(interactive (sniff-read-arg "Retrieve: "))
(sniff-context-request ?p symbol))
(defun sniff-retrieve-allprojs (symbol)
"Retrieve selection from all projects."
(interactive (sniff-read-arg "Retrieve: "))
(sniff-context-request ?P symbol))
(defun sniff-retrieve-next (symbol)
"Retrieve selection (using Retriever settings)."
(interactive (sniff-read-arg "Retrieve: "))
(sniff-context-request ?R symbol))
(defun sniff-goto-symbol (symbol)
"Show the source code of a symbol."
(interactive (sniff-read-arg "Show Symbol: "))
(sniff-context-request ?g symbol))
(defun sniff-find-symbol (symbol)
"Find all symbols matching a string."
(interactive (sniff-read-arg "Find Symbols Matching: "))
(sniff-context-request ?f symbol))
(defun sniff-browse-class (symbol)
"Browse a class in the Class Browser."
(interactive (sniff-read-arg "Browse Class: "))
(sniff-context-request ?w symbol))
(defun sniff-hierarchy (symbol)
"Show a class in the entire class hierarchy."
(interactive (sniff-read-arg "Show In Entire Hierarchy: "))
(sniff-context-request ?t symbol))
(defun sniff-restr-hier (symbol)
"Show the relatives of a class in the class hierarchy."
(interactive (sniff-read-arg "Show Relatives In Hierarchy: "))
(sniff-context-request ?T symbol))
(defun sniff-xref-to (symbol)
"Show refers-to relationships in the Cross Referencer."
(interactive (sniff-read-arg "Symbol Refers-to: "))
(sniff-context-request ?x symbol))
(defun sniff-xref-by (symbol)
"Show referred-by relationships in the Cross Referencer."
(interactive (sniff-read-arg "Symbol Referred-by: "))
(sniff-context-request ?X symbol))
(defun sniff-xref-has (symbol)
"Show has-a relationships in the Cross Referencer."
(interactive (sniff-read-arg "Symbol Refers-to Components: "))
(sniff-context-request ?c symbol))
(defun sniff-xref-usedby (symbol)
"Show used-by relationships in the Cross Referencer."
(interactive (sniff-read-arg "Symbol Referred-by As Component: "))
(sniff-context-request ?C symbol))
(defun sniff-show-docu (symbol)
"Show the documentation of a symbol."
(interactive (sniff-read-arg "Show Documentation Of: "))
(sniff-context-request ?d symbol))
(defun sniff-gen-docu (symbol)
"Generate the documentation for a symbol."
(interactive (sniff-read-arg "Generate Documentation For: "))
(sniff-context-request ?D symbol))
;;---------------------------------------------------
;; Menu Bar
(if sniff-is-xemacs
;; Menu for XEmacs
(defvar sniff-mode-menu
'(
["Show Symbol ..." sniff-goto-symbol t]
["Show Baseclass Of ..." sniff-superclass t]
["Show Overridden Method" sniff-overridden t]
["Show Declaration/Implementation" sniff-toggle t]
"-"
["Browse Class ..." sniff-browse-class t]
["Show In Entire Hierarchy ..." sniff-hierarchy t]
["Show Relatives In Hierarchy ..." sniff-restr-hier t]
"-"
["Retrieve From This File..." sniff-retrieve t]
["Retrieve From This Project..." sniff-retrieve-proj t]
["Retrieve From All Projects..." sniff-retrieve-allprojs t]
["Retrieve (Using Retriever Settings)" sniff-retrieve-next t]
["Find Symbols Matching ..." sniff-find-symbol t]
"-"
["Symbol Refers-to ..." sniff-xref-to t]
["Symbol Referred-by ..." sniff-xref-by t]
["Symbol Refers-to Components ..." sniff-xref-has t]
["Symbol Referred-by As Component ..." sniff-xref-usedby t]
"-"
["Show Documentation Of ..." sniff-show-docu t]
["Generate Documentation For ..." sniff-gen-docu t]
"-"
["Save w/o Reparse..." sniff-writebuffer t]
["Reparse..." sniff-reparse t]
"-"
["Connect" sniff-connect (not sniff-process)]
["Disconnect" sniff-disconnect sniff-process]
)
"XEmacs pulldown menu for Sniff mode.")
;; Menu for FSF Emacs
(progn
(define-key sniff-mode-map [menu-bar sniff]
(cons "Sniff" (make-sparse-keymap "Sniff")))
(define-key sniff-mode-map [menu-bar sniff disconnect]
'("Disconnect" . sniff-disconnect))
(define-key sniff-mode-map [menu-bar sniff connect]
'("Connect" . sniff-connect))
(define-key sniff-mode-map [menu-bar sniff separator-conn]
'("--"))
(define-key sniff-mode-map [menu-bar sniff reparse]
'("Reparse ..." . sniff-reparse))
(define-key sniff-mode-map [menu-bar sniff writebuffer]
'("Save w/o Reparse" . sniff-writebuffer))
(define-key sniff-mode-map [menu-bar sniff separator-save]
'("--"))
(define-key sniff-mode-map [menu-bar sniff gen-docu]
'("Generate Documentation For ..." . sniff-gen-docu))
(define-key sniff-mode-map [menu-bar sniff show-docu]
'("Show Documentation Of ..." . sniff-show-docu))
(define-key sniff-mode-map [menu-bar sniff separator-docu]
'("--"))
(define-key sniff-mode-map [menu-bar sniff xref-usedby]
'("Symbol Referred-by as Component ..." . sniff-xref-usedby))
(define-key sniff-mode-map [menu-bar sniff xref-has]
'("Symbol Refers-to Components ..." . sniff-xref-has))
(define-key sniff-mode-map [menu-bar sniff xref-by]
'("Symbol Referred-by ..." . sniff-xref-by))
(define-key sniff-mode-map [menu-bar sniff xref-to]
'("Symbol Refers-to ..." . sniff-xref-to))
(define-key sniff-mode-map [menu-bar sniff separator-xref]
'("--"))
(define-key sniff-mode-map [menu-bar sniff find-symbol]
'("Find Symbols Matching ..." . sniff-find-symbol))
(define-key sniff-mode-map [menu-bar sniff retrieve-next]
'("Retrieve (Using Retriever Settings)" . sniff-retrieve-next))
(define-key sniff-mode-map [menu-bar sniff retrieve-allprojs]
'("Retrieve From All Projects ..." . sniff-retrieve-allprojs))
(define-key sniff-mode-map [menu-bar sniff retrieve-proj]
'("Retrieve From This Project ..." . sniff-retrieve-proj))
(define-key sniff-mode-map [menu-bar sniff retrieve]
'("Retrieve From This File ..." . sniff-retrieve))
(define-key sniff-mode-map [menu-bar sniff separator-xref]
'("--"))
(define-key sniff-mode-map [menu-bar sniff restr-hierarchy]
'("Show Relatives In Hierarchy ..." . sniff-restr-hier))
(define-key sniff-mode-map [menu-bar sniff hierarchy]
'("Show In Entire Hierarchy ..." . sniff-hierarchy))
(define-key sniff-mode-map [menu-bar sniff browse-class]
'("Browse Class ..." . sniff-browse-class))
(define-key sniff-mode-map [menu-bar sniff separator-xref]
'("--"))
(define-key sniff-mode-map [menu-bar sniff toggle]
'("Toggle Declaration/Implementation" . sniff-toggle))
(define-key sniff-mode-map [menu-bar sniff overridden]
'("Show Overridden Method" . sniff-overridden))
(define-key sniff-mode-map [menu-bar sniff superclass]
'("Show Baseclass Of ..." . sniff-superclass))
(define-key sniff-mode-map [menu-bar sniff goto-symbol]
'("Show Symbol(s) ..." . sniff-goto-symbol))
(put 'sniff-connect 'menu-enable '(not sniff-process))
(put 'sniff-disconnect 'menu-enable 'sniff-process)
)
)
;;; sniff-mode.el ends here
3:43 a.m.
New subject: unrecognized selection-conversion type
>>>> "John" == John A Turner
<turner(a)blueskystudios.com> writes:
[rest of sniff.el deleted]
John> ;;; Support for Japanese characters when running under MULE
John> (MUlti Lingual Emacs)
This code looks strange to me, and the comments are quite possibly
incorrect about differences between EUC and SJIS. I don't have time
to check for bogosity right now, but in the interest of narrowing the
possibilities:
Are you using Mule? If so, are there any Japanese characters in the
files or are they straight ASCII? Does the error show up with a
no-mule build?
Even if the sniff.el code is entirely correct, it's possible that
using Mule would cause X selections to behave differently.
--
University of Tsukuba Tennodai 1-1-1 Tsukuba 305-8573 JAPAN
Institute of Policy and Planning Sciences Tel/fax: +81 (298) 53-5091
_________________ _________________ _________________ _________________
What are those straight lines for? "XEmacs rules."
4:21 p.m.
New subject: unrecognized selection-conversion type
>>>> "SJT" == Stephen J Turnbull
<turnbull(a)sk.tsukuba.ac.jp>:
John> ;;; Support for Japanese characters when running under MULE
John> (MUlti Lingual Emacs)
SJT> This code looks strange to me, and the comments are quite possibly
SJT> incorrect about differences between EUC and SJIS. I don't have time
SJT> to check for bogosity right now, but in the interest of narrowing the
SJT> possibilities:
SJT>
SJT> Are you using Mule? If so, are there any Japanese characters in the
SJT> files or are they straight ASCII? Does the error show up with a
SJT> no-mule build?
SJT>
SJT> Even if the sniff.el code is entirely correct, it's possible that
SJT> using Mule would cause X selections to behave differently.
I'm not building with Mule...
-JT
8703
days inactive
8704
days old
4 comments
4 participants
participants (4)
-
Charles G Waldman -
Daniel Pittman -
John A. Turner -
Stephen J. Turnbull