(semantic-analyze-current-context): Autoload.
lisp/cedet/semantic/ctxt.el: Add local vars for autoloading.
Don't eval-when-compile semantic/db
(semantic-ctxt-current-mode): Autoload.
(semantic-up-context): Require semantic/find.
lisp/cedet/semantic/find.el (semantic-current-tag-parent)
(semantic-find-tags-by-scope-protection): Autoload.
lisp/cedet/semantic/format.el (semantic-format-tag-prototype)
(semantic-format-tag-summarize): Autoload.
lisp/cedet/semantic/idle.el: Declare external functions.
(semantic-idle-work-for-one-buffer, semantic-idle-work-core-handler):
Require semantic/db-mode.
(semantic-idle-work-core-handler): Synch to upstream.
(semantic-idle-scheduler-refresh-tags): Require semantic/decorate/mode.
(semantic-idle-summary-find-current-symbol-tag): Require semantic/db-find.
(semantic-idle-summary-current-symbol-info-context): Require
semantic/analyze.
(semantic-idle-summary-maybe-highlight, semantic-idle-tag-highlight):
Require pulse.
(semantic-idle-completion-list-default): Require semantic/complete.
lisp/cedet/semantic/lex-spp.el: Require semantic.
(semantic-lex-spp-analyzer-push-tokens-for-symbol): Synch to upstream.
(semantic-lex-spp-first-token-arg-list): Use split-string.
lisp/cedet/semantic/lex.el: Declare semantic-elapsed-time.
Add local vars for autoloading.
(semantic-lex-test): Require semantic.
(semantic-lex): Autoload.
(semantic-flex): Use semantic-lex-keyword-p to avoid compiler warning.
lisp/cedet/semantic/sb.el: Require semantic/sort.
Declare semanticdb-minor-mode-p.
(semantic-sb-fetch-tag-table): Require semantic/db-mode.
lisp/cedet/semantic/scope.el: eval-when-compile semantic/find.
Declare external functions.
(semantic-analyze-scope-nested-tags-default): Require semantic/analyze.
(semantic-analyze-show): Require semantic/analyze.
(semantic-calculate-scope): Require semantic/db-typecache.
lisp/cedet/semantic/sort.el: Add local vars for autoloading.
Declare semanticdb-find-tags-external-children-of-type.
(semantic-flatten-tags-table, semantic-tag-external-member-parent):
Autoload.
(semantic-tag-external-member-children-default): Require semantic/db-find.
lisp/cedet/semantic/symref.el: Require semantic.
Declare data-debug-new-buffer and data-debug-insert-object-slots.
(semantic-symref-data-debug-last-result): Require eieio-datadebug.
lisp/cedet/semantic/tag-file.el: Declare external functions.
(semantic-go-to-tag): Call semanticdb-table-child-p only if
semantic/db is loaded.
(semantic-dependency-tag-file): Require semantic/dep.
lisp/cedet/semantic/tag-ls.el: Require semantic.
Add local variables for autoloading.
(semantic-tag-prototype-p): Autoload.
lisp/cedet/semantic/tag-write.el: Require semantic.
lisp/cedet/semantic/tag.el: Update external function declarations and
requirements, removing autoloaded functions.
Add local vars for autoloading.
(semantic-tag-components): Autoload.
lisp/cedet/semantic/texi.el: Declare lookup-words.
eval-when-compile semantic/find.
lisp/cedet/semantic/util.el: Update file header.
lisp/cedet/semantic/analyze/complete.el: Add local variables for autoloading.
(semantic-analyze-possible-completions, semantic-analyze-type-constants):
Autoload.
;;
;; Create a full-up context analysis.
;;
+;;;###autoload
(define-overloadable-function semantic-analyze-current-context (&optional position)
"Analyze the current context at optional POSITION.
If called interactively, display interesting information about POSITION
(provide 'semantic/analyze)
+;; Local variables:
+;; generated-autoload-file: "loaddefs.el"
+;; generated-autoload-feature: semantic/loaddefs
+;; End:
+
;;; semantic/analyze.el ends here
;;; Helper Fcns
;;
;;
+;;;###autoload
(define-overloadable-function semantic-analyze-type-constants (type)
"For the tag TYPE, return any constant symbols of TYPE.
Used as options when completing.")
'(type)
))))
+;;;###autoload
(define-overloadable-function semantic-ctxt-current-mode (&optional point)
"Return the major mode active at POINT.
POINT defaults to the value of point in current buffer.
(provide 'semantic/ctxt)
+;; Local variables:
+;; generated-autoload-file: "loaddefs.el"
+;; generated-autoload-feature: semantic/loaddefs
+;; End:
+
;;; semantic/ctxt.el ends here
smallest tag. Return nil if there is no tag here."
(car (nreverse (semantic-find-tag-by-overlay))))
+;;;###autoload
(defun semantic-current-tag-parent ()
"Return the current tags parent in the current buffer.
A tag's parent would be a containing structure, such as a type
(semantic-tag-type-compound-p (car tags))
,table))
+;;;###autoload
(define-overloadable-function semantic-find-tags-by-scope-protection (scopeprotection parent &optional table)
"Find all tags accessable by SCOPEPROTECTION.
SCOPEPROTECTION is a symbol which can be returned by the method
Optional argument PARENT is the parent type if TAG is a detail.
Optional argument COLOR means highlight the prototype with font-lock colors.")
+;;;###autoload
(define-overloadable-function semantic-format-tag-prototype (tag &optional parent color)
"Return a prototype for TAG.
This function should be overloaded, though it need not be used.
(semantic-alias-obsolete
'semantic-summerize-nonterminal 'semantic-format-tag-summarize)
+;;;###autoload
(define-overloadable-function semantic-format-tag-summarize (tag &optional parent color)
"Summarize TAG in a reasonable way.
Optional argument PARENT is the parent type if TAG is a detail.
;; For the semantic-find-tags-by-name macro.
(eval-when-compile (require 'semantic/find))
-(declare-function semanticdb-typecache-refresh-for-buffer "semantic/db-typecache")
(declare-function eldoc-message "eldoc")
+(declare-function semantic-analyze-interesting-tag "semantic/analyze")
+(declare-function semantic-complete-analyze-inline-idle "semantic/complete")
+(declare-function semanticdb-deep-find-tags-by-name "semantic/db-find")
+(declare-function semanticdb-minor-mode-p "semantic/db-mode")
+(declare-function semanticdb-save-all-db-idle "semantic/db")
+(declare-function semanticdb-typecache-refresh-for-buffer "semantic/db-typecache")
+(declare-function semantic-decorate-flush-pending-decorations
+ "semantic/decorate/mode")
+(declare-function pulse-momentary-highlight-region "pulse")
+(declare-function pulse-momentary-highlight-overlay "pulse")
;;; Code:
(semantic-safe "Idle Work Including Error: %S"
;; Get the include related path.
(when (and (featurep 'semantic/db)
+ (require 'semantic/db-mode)
(semanticdb-minor-mode-p))
(require 'semantic/db-find)
(semanticdb-find-translate-path buffer nil)
))
)
- ;; Save everything.
- (semanticdb-save-all-db-idle)
+ (when (and (featurep 'semantic/db)
+ (require 'semantic/db-mode)
+ (semanticdb-minor-mode-p))
+ ;; Save everything.
+ (semanticdb-save-all-db-idle)
- ;; Parse up files near our active buffer
- (when semantic-idle-work-parse-neighboring-files-flag
- (semantic-safe "Idle Work Parse Neighboring Files: %S"
- (when (and (featurep 'semantic/db)
- (semanticdb-minor-mode-p))
+ ;; Parse up files near our active buffer
+ (when semantic-idle-work-parse-neighboring-files-flag
+ (semantic-safe "Idle Work Parse Neighboring Files: %S"
(set-buffer cb)
(semantic-idle-scheduler-work-parse-neighboring-files))
t)
- )
- ;; Save everything... again
- (semanticdb-save-all-db-idle)
+ ;; Save everything... again
+ (semanticdb-save-all-db-idle)
+ )
;; Done w/ processing
nil))))
;; After updating the tags, handle any pending decorations for this
;; buffer.
+ (require 'semantic/decorate/mode)
(semantic-decorate-flush-pending-decorations (current-buffer))
))
"Search for a semantic tag with name SYM in database tables.
Return the tag found or nil if not found.
If semanticdb is not in use, use the current buffer only."
- (car (if (and (featurep 'semantic/db) semanticdb-current-database)
+ (car (if (and (featurep 'semantic/db)
+ semanticdb-current-database
+ (require 'semantic/db-find))
(cdar (semanticdb-deep-find-tags-by-name sym))
(semantic-deep-find-tags-by-name sym (current-buffer)))))
(semantic-analyze-current-context (point))
(error nil))))
(when analysis
+ (require 'semantic/analyze)
(semantic-analyze-interesting-tag analysis))))
(defun semantic-idle-summary-current-symbol-info-default ()
"Perhaps add highlighting onto TAG.
TAG was found as the thing under point. If it happens to be
visible, then highlight it."
+ (require 'pulse)
(let* ((region (when (and (semantic-tag-p tag)
(semantic-tag-with-position-p tag))
(semantic-tag-overlay tag)))
"Highlight the tag, and references of the symbol under point.
Call `semantic-analyze-current-context' to find the reference tag.
Call `semantic-symref-hits-in-region' to identify local references."
+ (require 'pulse)
(when (semantic-idle-summary-useful-context-p)
(let* ((ctxt (semantic-analyze-current-context))
(Hbounds (when ctxt (oref ctxt bounds)))
nil))
)
;; Use idle version.
+ (require 'semantic/complete)
(semantic-complete-analyze-inline-idle)
)
(error nil))
;; NN_END
;;
+(require 'semantic)
(require 'semantic/lex)
;;; Code:
(defun semantic-lex-spp-analyzer-push-tokens-for-symbol (str beg end)
"Push lexical tokens for the symbol or keyword STR.
STR occurs in the current buffer between BEG and END."
- (let (sym val)
+ (let (sym val count)
(cond
;;
;; It is a macro. Prepare for a replacement.
(symbolp (car token))
(eq 'semantic-list (car token)))
;; Convert TOKEN in place.
- (let ((argsplit (cedet-split-string (semantic-lex-token-text token)
- "[(), ]" t)))
+ (let ((argsplit (split-string (semantic-lex-token-text token)
+ "[(), ]" t)))
(setcar token 'spp-arg-list)
(setcar (nthcdr 1 token) argsplit))
))
;;; Interactive testing commands
+(declare-function semantic-elapsed-time "semantic")
+
(defun semantic-lex-test (arg)
"Test the semantic lexer in the current buffer.
If universal argument ARG, then try the whole buffer."
(interactive "P")
+ (require 'semantic)
(let* ((start (current-time))
(result (semantic-lex
(if arg (point-min) (point))
(numberp (nth 2 thing)))
)
+(eval-and-compile
+
(defun semantic-lex-expand-block-specs (specs)
"Expand block specifications SPECS into a Lisp form.
SPECS is a list of (BLOCK BEGIN END) elements where BLOCK, BEGIN, and
(car semantic-lex-token-stream))))
(cond ,@(nreverse form))))
)))
+)
(defmacro semantic-lex-push-token (token &rest blockspecs)
"Push TOKEN in the lexical analyzer token stream.
(modify-syntax-entry
(car mod) (nth 1 mod) semantic-lex-syntax-table)))
+;;;###autoload
(define-overloadable-function semantic-lex (start end &optional depth length)
"Lexically analyze text in the current buffer between START and END.
Optional argument DEPTH indicates at what level to scan over entire
((looking-at "\\(\\sw\\|\\s_\\)+")
(setq ts (cons (cons
;; Get info on if this is a keyword or not
- (or (semantic-flex-keyword-p (match-string 0))
+ (or (semantic-lex-keyword-p (match-string 0))
'symbol)
(cons (match-beginning 0) (match-end 0)))
ts)))
(provide 'semantic/lex)
+;; Local variables:
+;; generated-autoload-file: "loaddefs.el"
+;; generated-autoload-feature: semantic/loaddefs
+;; End:
+
;;; semantic-lex.el ends here
(require 'semantic)
(require 'semantic/util)
(require 'speedbar)
-;; (require 'inversion)
-;; (eval-and-compile
-;; (inversion-require 'speedbar "0.15beta1"))
+(require 'semantic/sort)
+
+(declare-function semanticdb-minor-mode-p "semantic/db-mode")
(defcustom semantic-sb-autoexpand-length 1
"*Length of a semantic bucket to autoexpand in place.
"Load FILE into a buffer, and generate tags using the Semantic parser.
Returns the tag list, or t for an error."
(let ((out nil))
- (if (and (featurep 'semanticdb) (semanticdb-minor-mode-p)
+ (if (and (featurep 'semantic/db)
+ (require 'semantic/db-mode)
+ (semanticdb-minor-mode-p)
(not speedbar-power-click)
;; If the database is loaded and running, try to get
;; tokens from it.
(require 'semantic/analyze/fcn)
(require 'semantic/ctxt)
+(eval-when-compile (require 'semantic/find)) ; For semantic-find-* macros
+
+(declare-function data-debug-show "eieio-datadebug")
+(declare-function semantic-analyze-find-tag "semantic/analyze")
+(declare-function semantic-analyze-princ-sequence "semantic/analyze")
+(declare-function semanticdb-typecache-merge-streams "semantic/db-typecache")
+(declare-function semanticdb-typecache-add-dependant "semantic/db-typecache")
;;; Code:
(defun semantic-analyze-scoped-types-default (position)
"Return a list of types currently in scope at POSITION.
Use `semantic-ctxt-scoped-types' to find types."
+ (require 'semantic/db-typecache)
(save-excursion
(goto-char position)
(let ((code-scoped-types nil))
be found.
This only finds ONE immediate parent by name. All other parents returned
are from nesting data types."
+ (require 'semantic/analyze)
(save-excursion
(if position (goto-char position))
(let* ((stack (reverse (semantic-find-tag-by-overlay (point))))
"Map all parents of TYPE to FCN. Return tags of all the types.
Argument SCOPE specify additional tags that are in scope
whose tags can be searched when needed, OR it may be a scope object."
+ (require 'semantic/analyze)
(let* (;; PARENTS specifies only the superclasses and not
;; interfaces. Inheriting from an interfaces implies
;; you have a copy of all methods locally. I think.
The class returned from the scope calculation is variable
`semantic-scope-cache'."
(interactive)
- (if (not (and (featurep 'semanticdb) semanticdb-current-database))
+ (if (not (and (featurep 'semantic/db) semanticdb-current-database))
nil ;; Don't do anything...
+ (require 'semantic/db-typecache)
(if (not point) (setq point (point)))
(when (interactive-p)
(semantic-fetch-tags)
(semanticdb-typecache-add-dependant scopecache)
;; Handy debug output.
(when (interactive-p)
+ (require 'eieio-datadebug)
(data-debug-show scopecache)
)
;; Return ourselves
;;
(defmethod semantic-analyze-show ((context semantic-scope-cache))
"Insert CONTEXT into the current buffer in a nice way."
+ (require 'semantic-analyze)
(semantic-analyze-princ-sequence (oref context scopetypes) "-> ScopeTypes: " )
(semantic-analyze-princ-sequence (oref context parents) "-> Parents: " )
(semantic-analyze-princ-sequence (oref context scope) "-> Scope: " )
(require 'semantic)
(require 'semantic/db)
(eval-when-compile
- (require 'semantic/find)
- (require 'semantic/db-find))
+ (require 'semantic/find))
+
+(declare-function semanticdb-find-tags-external-children-of-type
+ "semantic/db-find")
;;; Alphanumeric sorting
;;
See `semantic-tag-external-member-children' for details."
(if (and usedb
(fboundp 'semanticdb-minor-mode-p)
- (semanticdb-minor-mode-p))
+ (semanticdb-minor-mode-p)
+ (require 'semantic/db-find))
(let ((m (semanticdb-find-tags-external-children-of-type
(semantic-tag-name tag))))
(if m (apply #'append (mapcar #'cdr m))))
;;
;; Your tool should then create an instance of `semantic-symref-result'.
-(require 'semantic/fw)
+(require 'semantic)
;; (require 'ede)
-(eval-when-compile (require 'data-debug)
- (require 'eieio-datadebug))
+
+(declare-function data-debug-new-buffer "data-debug")
+(declare-function data-debug-insert-object-slots "eieio-datadebug")
;;; Code:
(defvar semantic-symref-tool 'detect
(defun semantic-symref-data-debug-last-result ()
"Run the last symref data result in Data Debug."
(interactive)
+ (require 'eieio-datadebug)
(if semantic-symref-last-result
(progn
(data-debug-new-buffer "*Symbol Reference ADEBUG*")
-;;; tag-file.el --- Routines that find files based on tags.
+;;; semantic/tag-file.el --- Routines that find files based on tags.
;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
;;; 2008, 2009 Free Software Foundation, Inc.
(require 'semantic/tag)
+(declare-function semanticdb-table-child-p "semantic/db")
+(declare-function semanticdb-get-buffer "semantic/db")
+(declare-function semantic-dependency-find-file-on-path "semantic/dep")
+
;;; Code:
;;; Location a TAG came from.
;; Tag had nothing, and the parent only has a file-name, then
;; find that file, and switch to that buffer.
(set-buffer (find-file-noselect (semantic-tag-file-name parent))))
- ((and parent (semanticdb-table-child-p parent))
+ ((and parent (featurep 'semantic/db)
+ (semanticdb-table-child-p parent))
(set-buffer (semanticdb-get-buffer parent)))
(t
;; Well, just assume things are in the current buffer.
;; (semantic--tag-get-property tag 'dependency-file)
(:override
(save-excursion
+ (require 'semantic/dep)
(semantic-dependency-find-file-on-path
tag-fname (semantic-tag-include-system-p tag))))
;; )
;; generated-autoload-feature: semantic/loaddefs
;; End:
-;;; semantic-tag-file.el ends here
+;;; semantic/tag-file.el ends here
-;;; tag-ls.el --- Language Specific override functions for tags
+;;; semantic/tag-ls.el --- Language Specific override functions for tags
;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008
;;; Free Software Foundation, Inc.
;; itself. These are the functions that languages can use to derive
;; the information.
-(require 'semantic/tag)
+(require 'semantic)
;;; Code:
;; generated-autoload-feature: semantic/loaddefs
;; End:
-;;; semantic-tag-ls.el ends here
+;;; semantic/tag-ls.el ends here
-;;; tag-write.el --- Write tags to a text stream
+;;; semantic/tag-write.el --- Write tags to a text stream
;; Copyright (C) 2008, 2009 Free Software Foundation, Inc.
;; that they conform to good semantic tag hygene.
;;
-(require 'semantic/tag)
+(require 'semantic)
;;; Code:
(defun semantic-tag-write-one-tag (tag &optional indent)
(provide 'semantic/tag-write)
-;;; semantic-tag-write.el ends here
+;;; semantic/tag-write.el ends here
(require 'semantic/fw)
(require 'semantic/lex)
-(declare-function semantic-ctxt-current-mode "semantic/ctxt")
(declare-function semantic-analyze-split-name "semantic/analyze/fcn")
(declare-function semantic-fetch-tags "semantic")
(declare-function semantic-clear-toplevel-cache "semantic")
-(declare-function semantic-documentation-for-tag "semantic/doc")
-(declare-function semantic-format-tag-prototype "semantic/format")
-(declare-function semantic-format-tag-summarize "semantic/format")
-(declare-function semantic-format-tag-name "semantic/format")
(defconst semantic-tag-version "2.0pre7"
"Version string of semantic tags made with this code.")
If point is inside TAG bounds, return the major mode active at point.
Return the major mode active at beginning of TAG otherwise.
See also the function `semantic-ctxt-current-mode'."
- (require 'semantic/find)
(or tag (setq tag (semantic-current-tag)))
(or (semantic--tag-get-property tag :mode)
(let ((buffer (semantic-tag-buffer tag))
;; beginning of TAG.
(or (and (>= (point) start) (< (point) end))
(goto-char start))
- (require 'semantic/ctxt)
(semantic-ctxt-current-mode)))))
(defsubst semantic--tag-attributes-cdr (tag)
;;; Language Specific Tag access via overload
;;
+;;;###autoload
(define-overloadable-function semantic-tag-components (tag)
"Return a list of components for TAG.
A Component is a part of TAG which itself may be a TAG.
"Return a copy of TAG as a foreign tag, or nil if it can't be done.
TAG defaults to the tag at point in current buffer.
See also `semantic-foreign-tag-p'."
- (require 'semantic/doc)
(or tag (setq tag (semantic-current-tag)))
(when (semantic-tag-p tag)
(let ((ftag (semantic-tag-copy tag nil t))
and attempts to insert a prototype/function call."
;; Long term goal: Have a mechanism for a tempo-like template insert
;; for the given tag.
- (require 'semantic/format)
(insert (semantic-format-tag-prototype foreign-tag)))
(define-overloadable-function semantic-insert-foreign-tag (foreign-tag)
"Insert FOREIGN-TAG into the current buffer.
Signal an error if FOREIGN-TAG is not a valid foreign tag.
This function is overridable with the symbol `insert-foreign-tag'."
- (require 'semantic/format)
(semantic-foreign-tag-check foreign-tag)
(:override)
(message (semantic-format-tag-summarize foreign-tag)))
(define-mode-local-override semantic-insert-foreign-tag
log-edit-mode (foreign-tag)
"Insert foreign tags into log-edit mode."
- (require 'semantic/format)
(insert (concat "(" (semantic-format-tag-name foreign-tag) "): ")))
(define-mode-local-override semantic-insert-foreign-tag
change-log-mode (foreign-tag)
"Insert foreign tags into log-edit mode."
- (require 'semantic/format)
(insert (concat "(" (semantic-format-tag-name foreign-tag) "): ")))
\f
(provide 'semantic/tag)
+;; Local variables:
+;; generated-autoload-file: "loaddefs.el"
+;; generated-autoload-feature: semantic/loaddefs
+;; End:
+
;;; semantic-tag.el ends here
-;;; texi.el --- Semantic details for Texinfo files
+;;; semantic/texi.el --- Semantic details for Texinfo files
;;; Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
;;; Free Software Foundation, Inc.
(require 'semantic/db)
(require 'semantic/db-find)
(require 'semantic/ctxt)
+ (require 'semantic/find)
;; (require 'semantic/imenu)
(require 'semantic/doc)
;; (require 'senator)
)
+(declare-function lookup-words "ispell")
+
(defvar semantic-texi-super-regex
"^@\\(top\\|chapter\\|\\(sub\\)*section\\|unnumbered\\(\\(sub\\)*sec\\)?\\|\
\\(chap\\|\\(sub\\)+\\|major\\)?heading\\|appendix\\(\\(sub\\)*sec\\)?\\|\
(prefixclass (semantic-ctxt-current-class-list))
)
(when prefix
- (require 'semantic-analyze)
+ (require 'semantic/analyze)
(semantic-analyze-context
"Context-for-texinfo"
:buffer (current-buffer)
;; When EDE is active, ask it.
(ede-documentation-files)
)
- ((and (featurep 'semanticdb) (semanticdb-minor-mode-p))
+ ((and (featurep 'semantic/db) (semanticdb-minor-mode-p))
;; See what texinfo files we have loaded in the database
(let ((tabs (semanticdb-get-database-tables
semanticdb-current-database))
The current buffer must be a texinfo file containing TAG.
If TAG is nil, determine a tag based on the current position."
(interactive)
- (unless (or (featurep 'semanticdb) (semanticdb-minor-mode-p))
+ (unless (or (featurep 'semantic/db) (semanticdb-minor-mode-p))
(error "Texinfo updating only works when `semanticdb' is being used"))
(semantic-fetch-tags)
(unless tag
"Jump to the source for the definition in the texinfo file TAG.
If TAG is nil, it is derived from the deffn under POINT."
(interactive)
- (unless (or (featurep 'semanticdb) (semanticdb-minor-mode-p))
+ (unless (or (featurep 'semantic/db) (semanticdb-minor-mode-p))
(error "Texinfo updating only works when `semanticdb' is being used"))
(semantic-fetch-tags)
(unless tag
(provide 'semantic/texi)
-;;; semantic-texi.el ends here
+;;; semantic/texi.el ends here
-;;; util.el --- Utilities for use with semantic tag tables
+;;; semantic/util.el --- Utilities for use with semantic tag tables
;;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
;;; 2008, 2009 Free Software Foundation, Inc.
;;
(require 'semantic/util-modes)
-;;; semantic-util.el ends here
+;;; semantic/util.el ends here
HCoop / bpt / emacs.git / commitdiff