Using saved parent location: http://bzr.savannah.gnu.org/r/emacs/trunk/ Now on revision 101134. ------------------------------------------------------------ revno: 101134 committer: Jan D branch nick: trunk timestamp: Thu 2010-08-19 07:55:30 +0200 message: * nsselect.m (nxatoms_of_nsselect): Use "Selection" and "Secondary". diff: === modified file 'src/ChangeLog' --- src/ChangeLog 2010-08-18 16:42:06 +0000 +++ src/ChangeLog 2010-08-19 05:55:30 +0000 @@ -1,3 +1,7 @@ +2010-08-19 Jan Djärv + + * nsselect.m (nxatoms_of_nsselect): Use "Selection" and "Secondary". + 2010-08-18 Eli Zaretskii * xterm.c (x_draw_bar_cursor): === modified file 'src/nsselect.m' --- src/nsselect.m 2010-08-18 06:16:55 +0000 +++ src/nsselect.m 2010-08-19 05:55:30 +0000 @@ -542,8 +542,8 @@ void nxatoms_of_nsselect (void) { - NXPrimaryPboard = @"PrimarySelection"; - NXSecondaryPboard = @"SecondarySelection"; + NXPrimaryPboard = @"Selection"; + NXSecondaryPboard = @"Secondary"; } void ------------------------------------------------------------ revno: 101133 committer: Glenn Morris branch nick: trunk timestamp: Wed 2010-08-18 20:45:46 -0700 message: Fix previous Org change. * org.el (org-outline-overlay-data, org-set-outline-overlay-data) (org-save-outline-visibility): Move to org-macs. * org-macs.el (org-outline-overlay-data, org-set-outline-overlay-data) (org-save-outline-visibility): Move here from org.el. (show-all): Autoload it. * ob.el: Don't require org when compiling. diff: === modified file 'lisp/org/ChangeLog' --- lisp/org/ChangeLog 2010-08-18 02:44:25 +0000 +++ lisp/org/ChangeLog 2010-08-19 03:45:46 +0000 @@ -1,3 +1,12 @@ +2010-08-19 Glenn Morris + + * org.el (org-outline-overlay-data, org-set-outline-overlay-data) + (org-save-outline-visibility): Move to org-macs. + * org-macs.el (org-outline-overlay-data, org-set-outline-overlay-data) + (org-save-outline-visibility): Move here from org.el. + (show-all): Autoload it. + * ob.el: Don't require org when compiling. + 2010-08-18 Glenn Morris * ob.el: Require org when compiling. === modified file 'lisp/org/ob.el' --- lisp/org/ob.el 2010-08-18 02:44:25 +0000 +++ lisp/org/ob.el 2010-08-19 03:45:46 +0000 @@ -30,8 +30,7 @@ ;;; Code: (eval-when-compile - (require 'cl) - (require 'org)) ; org-save-outline-visibility macro + (require 'cl)) (require 'org-macs) (defvar org-babel-call-process-region-original) === modified file 'lisp/org/org-macs.el' --- lisp/org/org-macs.el 2010-07-19 09:47:27 +0000 +++ lisp/org/org-macs.el 2010-08-19 03:45:46 +0000 @@ -300,6 +300,66 @@ (nstars (if org-odd-levels-only (1- (* limit-level 2)) limit-level))) (format "\\*\\{1,%d\\} " nstars)))) + +;;; Saving and restoring visibility + +(defun org-outline-overlay-data (&optional use-markers) + "Return a list of the locations of all outline overlays. +The are overlays with the `invisible' property value `outline'. +The return values is a list of cons cells, with start and stop +positions for each overlay. +If USE-MARKERS is set, return the positions as markers." + (let (beg end) + (save-excursion + (save-restriction + (widen) + (delq nil + (mapcar (lambda (o) + (when (eq (overlay-get o 'invisible) 'outline) + (setq beg (overlay-start o) + end (overlay-end o)) + (and beg end (> end beg) + (if use-markers + (cons (move-marker (make-marker) beg) + (move-marker (make-marker) end)) + (cons beg end))))) + (overlays-in (point-min) (point-max)))))))) + +(autoload 'show-all "outline" nil t) + +(defun org-set-outline-overlay-data (data) + "Create visibility overlays for all positions in DATA. +DATA should have been made by `org-outline-overlay-data'." + (let (o) + (save-excursion + (save-restriction + (widen) + (show-all) + (mapc (lambda (c) + (setq o (make-overlay (car c) (cdr c))) + (overlay-put o 'invisible 'outline)) + data))))) + +(defmacro org-save-outline-visibility (use-markers &rest body) + "Save and restore outline visibility around BODY. +If USE-MARKERS is non-nil, use markers for the positions. +This means that the buffer may change while running BODY, +but it also means that the buffer should stay alive +during the operation, because otherwise all these markers will +point nowhere." + (declare (indent 1)) + `(let ((data (org-outline-overlay-data ,use-markers))) + (unwind-protect + (progn + ,@body + (org-set-outline-overlay-data data)) + (when ,use-markers + (mapc (lambda (c) + (and (markerp (car c)) (move-marker (car c) nil)) + (and (markerp (cdr c)) (move-marker (cdr c) nil))) + data))))) + + (provide 'org-macs) ;; arch-tag: 7e6a73ce-aac9-4fc0-9b30-ce6f89dc6668 === modified file 'lisp/org/org.el' --- lisp/org/org.el 2010-07-19 09:47:27 +0000 +++ lisp/org/org.el 2010-08-19 03:45:46 +0000 @@ -6190,62 +6190,6 @@ (beginning-of-line) (recenter (prefix-numeric-value N)))) -;;; Saving and restoring visibility - -(defun org-outline-overlay-data (&optional use-markers) - "Return a list of the locations of all outline overlays. -The are overlays with the `invisible' property value `outline'. -The return values is a list of cons cells, with start and stop -positions for each overlay. -If USE-MARKERS is set, return the positions as markers." - (let (beg end) - (save-excursion - (save-restriction - (widen) - (delq nil - (mapcar (lambda (o) - (when (eq (overlay-get o 'invisible) 'outline) - (setq beg (overlay-start o) - end (overlay-end o)) - (and beg end (> end beg) - (if use-markers - (cons (move-marker (make-marker) beg) - (move-marker (make-marker) end)) - (cons beg end))))) - (overlays-in (point-min) (point-max)))))))) - -(defun org-set-outline-overlay-data (data) - "Create visibility overlays for all positions in DATA. -DATA should have been made by `org-outline-overlay-data'." - (let (o) - (save-excursion - (save-restriction - (widen) - (show-all) - (mapc (lambda (c) - (setq o (make-overlay (car c) (cdr c))) - (overlay-put o 'invisible 'outline)) - data))))) - -(defmacro org-save-outline-visibility (use-markers &rest body) - "Save and restore outline visibility around BODY. -If USE-MARKERS is non-nil, use markers for the positions. -This means that the buffer may change while running BODY, -but it also means that the buffer should stay alive -during the operation, because otherwise all these markers will -point nowhere." - (declare (indent 1)) - `(let ((data (org-outline-overlay-data ,use-markers))) - (unwind-protect - (progn - ,@body - (org-set-outline-overlay-data data)) - (when ,use-markers - (mapc (lambda (c) - (and (markerp (car c)) (move-marker (car c) nil)) - (and (markerp (cdr c)) (move-marker (cdr c) nil))) - data))))) - ;;; Folding of blocks ------------------------------------------------------------ revno: 101132 committer: Stefan Monnier branch nick: trunk timestamp: Thu 2010-08-19 01:25:36 +0200 message: * lisp/simple.el (prog-mode-map): New var. (prog-indent-sexp): New command. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2010-08-18 13:12:34 +0000 +++ lisp/ChangeLog 2010-08-18 23:25:36 +0000 @@ -1,5 +1,8 @@ 2010-08-18 Stefan Monnier + * simple.el (prog-mode-map): New var. + (prog-indent-sexp): New command. + * progmodes/octave-mod.el (octave-mode-menu): Make toggle buttons. * progmodes/prolog.el (smie): Require. === modified file 'lisp/simple.el' --- lisp/simple.el 2010-08-16 02:33:17 +0000 +++ lisp/simple.el 2010-08-18 23:25:36 +0000 @@ -424,6 +424,19 @@ ;; Major mode meant to be the parent of programming modes. +(defvar prog-mode-map + (let ((map (make-sparse-keymap))) + (define-key map [?\C-\M-q] 'prog-indent-sexp) + map) + "Keymap used for programming modes.") + +(defun prog-indent-sexp () + "Indent the expression after point." + (interactive) + (let ((start (point)) + (end (save-excursion (forward-sexp 1) (point)))) + (indent-region start end nil))) + (define-derived-mode prog-mode fundamental-mode "Prog" "Major mode for editing programming language source code." (set (make-local-variable 'require-final-newline) mode-require-final-newline) ------------------------------------------------------------ revno: 101131 committer: Eli Zaretskii branch nick: trunk timestamp: Wed 2010-08-18 22:06:11 +0300 message: xterm.c (x_draw_bar_cursor): Fix last change. diff: === modified file 'src/xterm.c' --- src/xterm.c 2010-08-18 16:42:06 +0000 +++ src/xterm.c 2010-08-18 19:06:11 +0000 @@ -7152,6 +7152,8 @@ if (kind == BAR_CURSOR) { + int x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x); + if (width < 0) width = FRAME_CURSOR_WIDTH (f); width = min (cursor_glyph->pixel_width, width); @@ -7163,8 +7165,7 @@ if ((cursor_glyph->resolved_level & 1) != 0) x += cursor_glyph->pixel_width - width; - XFillRectangle (dpy, window, gc, - WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x), + XFillRectangle (dpy, window, gc, x, WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y), width, row->height); } ------------------------------------------------------------ revno: 101130 committer: Eli Zaretskii branch nick: trunk timestamp: Wed 2010-08-18 19:54:08 +0300 message: bidi.c (bidi_level_of_next_char): Fix commentary regarding reordering of PDF. diff: === modified file 'src/bidi.c' --- src/bidi.c 2010-08-14 10:59:55 +0000 +++ src/bidi.c 2010-08-18 16:54:08 +0000 @@ -1533,7 +1533,7 @@ we want it to be displayed as - {RLO}STet{PDF} + {PDF}STet{RLO} not as ------------------------------------------------------------ revno: 101129 committer: Eli Zaretskii branch nick: trunk timestamp: Wed 2010-08-18 19:42:06 +0300 message: Fix display of bar cursor on right-to-left text. xterm.c (x_draw_bar_cursor): w32term.c (x_draw_bar_cursor): If the character under cursor is R2L, draw the bar cursor on its right rather than on its left. diff: === modified file 'src/ChangeLog' --- src/ChangeLog 2010-08-18 10:21:43 +0000 +++ src/ChangeLog 2010-08-18 16:42:06 +0000 @@ -1,3 +1,9 @@ +2010-08-18 Eli Zaretskii + + * xterm.c (x_draw_bar_cursor): + * w32term.c (x_draw_bar_cursor): If the character under cursor is + R2L, draw the bar cursor on its right rather than on its left. + 2010-08-18 Stefan Monnier * eval.c (Fdefmacro): Only obey one declaration. === modified file 'src/w32term.c' --- src/w32term.c 2010-08-14 12:55:04 +0000 +++ src/w32term.c 2010-08-18 16:42:06 +0000 @@ -4897,6 +4897,11 @@ w->phys_cursor_width = width; + /* If the character under cursor is R2L, draw the bar cursor + on the right of its glyph, rather than on the left. */ + if ((cursor_glyph->resolved_level & 1) != 0) + x += cursor_glyph->pixel_width - width; + w32_fill_area (f, hdc, cursor_color, x, WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y), width, row->height); === modified file 'src/xterm.c' --- src/xterm.c 2010-08-14 12:55:04 +0000 +++ src/xterm.c 2010-08-18 16:42:06 +0000 @@ -7158,6 +7158,11 @@ w->phys_cursor_width = width; + /* If the character under cursor is R2L, draw the bar cursor + on the right of its glyph, rather than on the left. */ + if ((cursor_glyph->resolved_level & 1) != 0) + x += cursor_glyph->pixel_width - width; + XFillRectangle (dpy, window, gc, WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x), WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y), ------------------------------------------------------------ revno: 101128 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 15:12:34 +0200 message: * lisp/progmodes/octave-mod.el (octave-mode-menu): Make toggle buttons. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2010-08-18 11:01:15 +0000 +++ lisp/ChangeLog 2010-08-18 13:12:34 +0000 @@ -1,5 +1,7 @@ 2010-08-18 Stefan Monnier + * progmodes/octave-mod.el (octave-mode-menu): Make toggle buttons. + * progmodes/prolog.el (smie): Require. * emacs-lisp/smie.el (smie-default-backward-token) === modified file 'lisp/progmodes/octave-mod.el' --- lisp/progmodes/octave-mod.el 2010-08-17 15:49:30 +0000 +++ lisp/progmodes/octave-mod.el 2010-08-18 13:12:34 +0000 @@ -283,9 +283,10 @@ ["Indent Line" indent-according-to-mode t] ["Complete Symbol" completion-at-point t] "-" - ;; FIXME: Make them toggle-buttons. - ["Toggle Abbrev Mode" abbrev-mode t] - ["Toggle Auto-Fill Mode" auto-fill-mode t] + ["Toggle Abbrev Mode" abbrev-mode + :style toggle :selected abbrev-mode] + ["Toggle Auto-Fill Mode" auto-fill-mode + :style toggle :selected auto-fill-function] "-" ["Submit Bug Report" octave-submit-bug-report t] "-" ------------------------------------------------------------ revno: 101127 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 14:10:30 +0200 message: Reindent smie.el diff: === modified file 'lisp/emacs-lisp/smie.el' --- lisp/emacs-lisp/smie.el 2010-08-18 12:03:57 +0000 +++ lisp/emacs-lisp/smie.el 2010-08-18 12:10:30 +0000 @@ -158,9 +158,9 @@ (if (not (member (car shr) nts)) (pushnew (car shr) last-ops) (pushnew (car shr) last-nts) - (when (consp (cdr shr)) - (assert (not (member (cadr shr) nts))) - (pushnew (cadr shr) last-ops))))) + (when (consp (cdr shr)) + (assert (not (member (cadr shr) nts))) + (pushnew (cadr shr) last-ops))))) (push (cons nt first-ops) first-ops-table) (push (cons nt last-ops) last-ops-table) (push (cons nt first-nts) first-nts-table) @@ -282,7 +282,7 @@ ;; distinguish associative operators (which will have ;; left = right). (unless (caar cst) - (setcar (car cst) i) + (setcar (car cst) i) (incf i)) (setq csts (delq cst csts)))) (unless progress @@ -386,8 +386,8 @@ (cond ((null toklevels) (when (zerop (length token)) - (condition-case err - (progn (goto-char pos) (funcall next-sexp 1) nil) + (condition-case err + (progn (goto-char pos) (funcall next-sexp 1) nil) (scan-error (throw 'return (list t (caddr err) (buffer-substring-no-properties @@ -417,10 +417,10 @@ (let ((lastlevels levels)) (if (and levels (= (funcall op-back toklevels) (funcall op-forw (car levels)))) - (setq levels (cdr levels))) + (setq levels (cdr levels))) ;; We may have found a match for the previously pending ;; operator. Is this the end? - (cond + (cond ;; Keep looking as long as we haven't matched the ;; topmost operator. (levels @@ -462,11 +462,11 @@ (t POS TOKEN): same thing but for an open-paren or the beginning of buffer. (nil POS TOKEN): we skipped over a paren-like pair. nil: we skipped over an identifier, matched parentheses, ..." - (smie-next-sexp - (indirect-function smie-backward-token-function) - (indirect-function 'backward-sexp) - (indirect-function 'smie-op-left) - (indirect-function 'smie-op-right) + (smie-next-sexp + (indirect-function smie-backward-token-function) + (indirect-function 'backward-sexp) + (indirect-function 'smie-op-left) + (indirect-function 'smie-op-right) halfsexp)) (defun smie-forward-sexp (&optional halfsexp) @@ -480,11 +480,11 @@ (t POS TOKEN): same thing but for an open-paren or the beginning of buffer. (nil POS TOKEN): we skipped over a paren-like pair. nil: we skipped over an identifier, matched parentheses, ..." - (smie-next-sexp - (indirect-function smie-forward-token-function) - (indirect-function 'forward-sexp) - (indirect-function 'smie-op-right) - (indirect-function 'smie-op-left) + (smie-next-sexp + (indirect-function smie-forward-token-function) + (indirect-function 'forward-sexp) + (indirect-function 'smie-op-right) + (indirect-function 'smie-op-left) halfsexp)) ;;; Miscellanous commands using the precedence parser. @@ -501,14 +501,14 @@ (forward-sexp-function nil)) (while (/= n 0) (setq n (- n (if forw 1 -1))) - (let ((pos (point)) + (let ((pos (point)) (res (if forw (smie-forward-sexp 'halfsexp) (smie-backward-sexp 'halfsexp)))) (if (and (car res) (= pos (point)) (not (if forw (eobp) (bobp)))) - (signal 'scan-error - (list "Containing expression ends prematurely" - (cadr res) (cadr res))) + (signal 'scan-error + (list "Containing expression ends prematurely" + (cadr res) (cadr res))) nil))))) (defvar smie-closer-alist nil @@ -764,13 +764,13 @@ ;; Obey the `fixindent' special comment. (and (smie-bolp) (save-excursion - (comment-normalize-vars) - (re-search-forward (concat comment-start-skip - "fixindent" - comment-end-skip) - ;; 1+ to account for the \n comment termination. - (1+ (line-end-position)) t)) - (current-column))) + (comment-normalize-vars) + (re-search-forward (concat comment-start-skip + "fixindent" + comment-end-skip) + ;; 1+ to account for the \n comment termination. + (1+ (line-end-position)) t)) + (current-column))) (defun smie-indent-bob () ;; Start the file at column 0. @@ -802,26 +802,26 @@ (save-excursion (goto-char pos) ;; Different cases: - ;; - smie-bolp: "indent according to others". - ;; - common hanging: "indent according to others". - ;; - SML-let hanging: "indent like parent". - ;; - if-after-else: "indent-like parent". - ;; - middle-of-line: "trust current position". - (cond - ((null (cdr toklevels)) nil) ;Not a keyword. - ((smie-bolp) - ;; For an open-paren-like thingy at BOL, always indent only - ;; based on other rules (typically smie-indent-after-keyword). - nil) - (t + ;; - smie-bolp: "indent according to others". + ;; - common hanging: "indent according to others". + ;; - SML-let hanging: "indent like parent". + ;; - if-after-else: "indent-like parent". + ;; - middle-of-line: "trust current position". + (cond + ((null (cdr toklevels)) nil) ;Not a keyword. + ((smie-bolp) + ;; For an open-paren-like thingy at BOL, always indent only + ;; based on other rules (typically smie-indent-after-keyword). + nil) + (t ;; We're only ever here for virtual-indent, which is why ;; we can use (current-column) as answer for `point'. (let* ((tokinfo (or (assoc (cons :before token) smie-indent-rules) - ;; By default use point unless we're hanging. + ;; By default use point unless we're hanging. `((:before . ,token) (:hanging nil) point))) ;; (after (prog1 (point) (goto-char pos))) - (offset (smie-indent-offset-rule tokinfo))) + (offset (smie-indent-offset-rule tokinfo))) (smie-indent-column offset))))) ;; FIXME: This still looks too much like black magic!! @@ -896,17 +896,17 @@ ;; affect the indentation of the "end". (current-column) (goto-char (cadr parent)) - ;; Don't use (smie-indent-virtual :not-hanging) here, because we - ;; want to jump back over a sequence of same-level ops such as - ;; a -> b -> c - ;; -> d - ;; So as to align with the earliest appropriate place. + ;; Don't use (smie-indent-virtual :not-hanging) here, because we + ;; want to jump back over a sequence of same-level ops such as + ;; a -> b -> c + ;; -> d + ;; So as to align with the earliest appropriate place. (smie-indent-virtual))) (tokinfo (if (and (= (point) pos) (smie-bolp) (or (eq offset 'point) (and (consp offset) (memq 'point offset)))) - ;; Since we started at BOL, we're not computing a virtual + ;; Since we started at BOL, we're not computing a virtual ;; indentation, and we're still at the starting point, so ;; we can't use `current-column' which would cause ;; indentation to depend on itself. @@ -934,12 +934,12 @@ (comment-string-strip comment-continue t t)))) (and (< 0 (length continue)) (looking-at (regexp-quote continue)) (nth 4 (syntax-ppss)) - (let ((ppss (syntax-ppss))) - (save-excursion - (forward-line -1) - (if (<= (point) (nth 8 ppss)) - (progn (goto-char (1+ (nth 8 ppss))) (current-column)) - (skip-chars-forward " \t") + (let ((ppss (syntax-ppss))) + (save-excursion + (forward-line -1) + (if (<= (point) (nth 8 ppss)) + (progn (goto-char (1+ (nth 8 ppss))) (current-column)) + (skip-chars-forward " \t") (if (looking-at (regexp-quote continue)) (current-column)))))))) @@ -1024,8 +1024,8 @@ (defvar smie-indent-functions '(smie-indent-fixindent smie-indent-bob smie-indent-close smie-indent-comment - smie-indent-comment-continue smie-indent-keyword smie-indent-after-keyword - smie-indent-exps) + smie-indent-comment-continue smie-indent-keyword smie-indent-after-keyword + smie-indent-exps) "Functions to compute the indentation. Each function is called with no argument, shouldn't move point, and should return either nil if it has no opinion, or an integer representing the column ------------------------------------------------------------ revno: 101126 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 14:03:57 +0200 message: * smie.el (smie-forward-sexp-command): Fix typo. diff: === modified file 'lisp/emacs-lisp/smie.el' --- lisp/emacs-lisp/smie.el 2010-08-18 10:57:48 +0000 +++ lisp/emacs-lisp/smie.el 2010-08-18 12:03:57 +0000 @@ -505,7 +505,7 @@ (res (if forw (smie-forward-sexp 'halfsexp) (smie-backward-sexp 'halfsexp)))) - (if (and (car res) (= pos (point)) (not (if forw (eolp) (bobp)))) + (if (and (car res) (= pos (point)) (not (if forw (eobp) (bobp)))) (signal 'scan-error (list "Containing expression ends prematurely" (cadr res) (cadr res))) ------------------------------------------------------------ revno: 101125 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 13:01:15 +0200 message: * lisp/progmodes/prolog.el (smie): Require. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2010-08-18 10:57:48 +0000 +++ lisp/ChangeLog 2010-08-18 11:01:15 +0000 @@ -1,5 +1,7 @@ 2010-08-18 Stefan Monnier + * progmodes/prolog.el (smie): Require. + * emacs-lisp/smie.el (smie-default-backward-token) (smie-default-forward-token): Strip properties. (smie-next-sexp): Be more careful with associative operators. === modified file 'lisp/progmodes/prolog.el' --- lisp/progmodes/prolog.el 2010-05-18 07:52:10 +0000 +++ lisp/progmodes/prolog.el 2010-08-18 11:01:15 +0000 @@ -31,7 +31,7 @@ (defvar comint-prompt-regexp) (defvar comint-process-echoes) -(defvar smie-indent-basic) +(require 'smie) (defgroup prolog nil "Major mode for editing and running Prolog under Emacs." ------------------------------------------------------------ revno: 101124 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 12:57:48 +0200 message: Try and remove some of SMIE's black magic by generalizing some rules. * lisp/emacs-lisp/smie.el (smie-default-backward-token) (smie-default-forward-token): Strip properties. (smie-next-sexp): Be more careful with associative operators. (smie-forward-sexp-command): Generalize. (smie-backward-sexp-command): Simplify. (smie-closer-alist): New var. (smie-close-block): New command. (smie-indent-debug-log): New var. (smie-indent-offset-rule): Add a few more cases. (smie-indent-column): New function. (smie-indent-after-keyword): Use it. (smie-indent-keyword): Use it. Fix up the opener code's point position. (smie-indent-comment): Only applies at BOL. (smie-indent-debug): New command. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2010-08-18 10:21:43 +0000 +++ lisp/ChangeLog 2010-08-18 10:57:48 +0000 @@ -1,5 +1,21 @@ 2010-08-18 Stefan Monnier + * emacs-lisp/smie.el (smie-default-backward-token) + (smie-default-forward-token): Strip properties. + (smie-next-sexp): Be more careful with associative operators. + (smie-forward-sexp-command): Generalize. + (smie-backward-sexp-command): Simplify. + (smie-closer-alist): New var. + (smie-close-block): New command. + (smie-indent-debug-log): New var. + (smie-indent-offset-rule): Add a few more cases. + (smie-indent-column): New function. + (smie-indent-after-keyword): Use it. + (smie-indent-keyword): Use it. + Fix up the opener code's point position. + (smie-indent-comment): Only applies at BOL. + (smie-indent-debug): New command. + * emacs-lisp/autoload.el (make-autoload): Preload the macros's declarations that are useful before running the macro. === modified file 'lisp/emacs-lisp/smie.el' --- lisp/emacs-lisp/smie.el 2010-06-09 11:40:50 +0000 +++ lisp/emacs-lisp/smie.el 2010-08-18 10:57:48 +0000 @@ -65,6 +65,9 @@ ;;; Code: +;; FIXME: I think the behavior on empty lines is wrong. It shouldn't +;; look at the next token on subsequent lines. + (eval-when-compile (require 'cl)) (defvar comment-continue) @@ -204,6 +207,17 @@ prec2)) (defun smie-prec2-levels (prec2) + ;; FIXME: Rather than only return an alist of precedence levels, we should + ;; also extract other useful data from it: + ;; - matching sets of block openers&closers (which can otherwise become + ;; collapsed into a single equivalence class in smie-op-levels) for + ;; smie-close-block as well as to detect mismatches in smie-next-sexp + ;; or in blink-paren (as well as to do the blink-paren for inner + ;; keywords like the "in" of "let..in..end"). + ;; - better default indentation rules (i.e. non-zero indentation after inner + ;; keywords like the "in" of "let..in..end") for smie-indent-after-keyword. + ;; Of course, maybe those things would be even better handled in the + ;; bnf->prec function. "Take a 2D precedence table and turn it into an alist of precedence levels. PREC2 is a table as returned by `smie-precs-precedence-table' or `smie-bnf-precedence-table'." @@ -321,32 +335,30 @@ (defun smie-default-backward-token () (forward-comment (- (point))) - (buffer-substring (point) - (progn (if (zerop (skip-syntax-backward ".")) - (skip-syntax-backward "w_'")) - (point)))) + (buffer-substring-no-properties + (point) + (progn (if (zerop (skip-syntax-backward ".")) + (skip-syntax-backward "w_'")) + (point)))) (defun smie-default-forward-token () (forward-comment (point-max)) - (buffer-substring (point) - (progn (if (zerop (skip-syntax-forward ".")) - (skip-syntax-forward "w_'")) - (point)))) + (buffer-substring-no-properties + (point) + (progn (if (zerop (skip-syntax-forward ".")) + (skip-syntax-forward "w_'")) + (point)))) (defun smie-associative-p (toklevels) ;; in "a + b + c" we want to stop at each +, but in - ;; "if a then b else c" we don't want to stop at each keyword. + ;; "if a then b elsif c then d else c" we don't want to stop at each keyword. ;; To distinguish the two cases, we made smie-prec2-levels choose ;; different levels for each part of "if a then b else c", so that ;; by checking if the left-level is equal to the right level, we can ;; figure out that it's an associative operator. - ;; This is not 100% foolproof, tho, since a grammar like - ;; (exp ("A" exp "C") ("A" exp "B" exp "C")) - ;; will cause "B" to have equal left and right levels, even though - ;; it is not an associative operator. - ;; A better check would be the check the actual previous operator - ;; against this one to see if it's the same, but we'd have to change - ;; `levels' to keep a stack of operators rather than only levels. + ;; This is not 100% foolproof, tho, since the "elsif" will have to have + ;; equal left and right levels (since it's optional), so smie-next-sexp + ;; has to be careful to distinguish those different cases. (eq (smie-op-left toklevels) (smie-op-right toklevels))) (defun smie-next-sexp (next-token next-sexp op-forw op-back halfsexp) @@ -371,51 +383,71 @@ (let* ((pos (point)) (token (funcall next-token)) (toklevels (cdr (assoc token smie-op-levels)))) - (cond ((null toklevels) (when (zerop (length token)) (condition-case err (progn (goto-char pos) (funcall next-sexp 1) nil) - (scan-error (throw 'return (list t (caddr err))))) + (scan-error (throw 'return + (list t (caddr err) + (buffer-substring-no-properties + (caddr err) + (+ (caddr err) + (if (< (point) (caddr err)) + -1 1))))))) (if (eq pos (point)) ;; We did not move, so let's abort the loop. (throw 'return (list t (point)))))) ((null (funcall op-back toklevels)) ;; A token like a paren-close. (assert (funcall op-forw toklevels)) ;Otherwise, why mention it? - (push (funcall op-forw toklevels) levels)) + (push toklevels levels)) (t - (while (and levels (< (funcall op-back toklevels) (car levels))) + (while (and levels (< (funcall op-back toklevels) + (funcall op-forw (car levels)))) (setq levels (cdr levels))) (cond ((null levels) (if (and halfsexp (funcall op-forw toklevels)) - (push (funcall op-forw toklevels) levels) + (push toklevels levels) (throw 'return (prog1 (list (or (car toklevels) t) (point) token) (goto-char pos))))) (t - (if (and levels (= (funcall op-back toklevels) (car levels))) + (let ((lastlevels levels)) + (if (and levels (= (funcall op-back toklevels) + (funcall op-forw (car levels)))) (setq levels (cdr levels))) + ;; We may have found a match for the previously pending + ;; operator. Is this the end? (cond - ((null levels) - (cond + ;; Keep looking as long as we haven't matched the + ;; topmost operator. + (levels + (if (funcall op-forw toklevels) + (push toklevels levels))) + ;; We matched the topmost operator. If the new operator + ;; is the last in the corresponding BNF rule, we're done. ((null (funcall op-forw toklevels)) + ;; It is the last element, let's stop here. (throw 'return (list nil (point) token))) - ((smie-associative-p toklevels) + ;; If the new operator is not the last in the BNF rule, + ;; ans is not associative, it's one of the inner operators + ;; (like the "in" in "let .. in .. end"), so keep looking. + ((not (smie-associative-p toklevels)) + (push toklevels levels)) + ;; The new operator is associative. Two cases: + ;; - it's really just an associative operator (like + or ;) + ;; in which case we should have stopped right before. + ((and lastlevels + (smie-associative-p (car lastlevels))) (throw 'return (prog1 (list (or (car toklevels) t) (point) token) (goto-char pos)))) - ;; We just found a match to the previously pending operator - ;; but this new operator is still part of a larger RHS. - ;; E.g. we're now looking at the "then" in - ;; "if a then b else c". So we have to keep parsing the - ;; rest of the construct. - (t (push (funcall op-forw toklevels) levels)))) - (t - (if (funcall op-forw toklevels) - (push (funcall op-forw toklevels) levels)))))))) + ;; - it's an associative operator within a larger construct + ;; (e.g. an "elsif"), so we should just ignore it and keep + ;; looking for the closing element. + (t (setq levels lastlevels)))))))) levels) (setq halfsexp nil))))) @@ -455,37 +487,78 @@ (indirect-function 'smie-op-left) halfsexp)) +;;; Miscellanous commands using the precedence parser. + (defun smie-backward-sexp-command (&optional n) "Move backward through N logical elements." - (interactive "p") - (if (< n 0) - (smie-forward-sexp-command (- n)) - (let ((forward-sexp-function nil)) - (while (> n 0) - (decf n) - (let ((pos (point)) - (res (smie-backward-sexp 'halfsexp))) - (if (and (car res) (= pos (point)) (not (bolp))) - (signal 'scan-error - (list "Containing expression ends prematurely" - (cadr res) (cadr res))) - nil)))))) + (interactive "^p") + (smie-forward-sexp-command (- n))) (defun smie-forward-sexp-command (&optional n) "Move forward through N logical elements." - (interactive "p") - (if (< n 0) - (smie-backward-sexp-command (- n)) - (let ((forward-sexp-function nil)) - (while (> n 0) - (decf n) + (interactive "^p") + (let ((forw (> n 0)) + (forward-sexp-function nil)) + (while (/= n 0) + (setq n (- n (if forw 1 -1))) (let ((pos (point)) - (res (smie-forward-sexp 'halfsexp))) - (if (and (car res) (= pos (point)) (not (bolp))) + (res (if forw + (smie-forward-sexp 'halfsexp) + (smie-backward-sexp 'halfsexp)))) + (if (and (car res) (= pos (point)) (not (if forw (eolp) (bobp)))) (signal 'scan-error (list "Containing expression ends prematurely" (cadr res) (cadr res))) - nil)))))) + nil))))) + +(defvar smie-closer-alist nil + "Alist giving the closer corresponding to an opener.") + +(defun smie-close-block () + "Close the closest surrounding block." + (interactive) + (let ((closer + (save-excursion + (backward-up-list 1) + (if (looking-at "\\s(") + (string (cdr (syntax-after (point)))) + (let* ((open (funcall smie-forward-token-function)) + (closer (cdr (assoc open smie-closer-alist))) + (levels (list (assoc open smie-op-levels))) + (seen '()) + (found '())) + (cond + ;; Even if we improve the auto-computation of closers, + ;; there are still cases where we need manual + ;; intervention, e.g. for Octave's use of `until' + ;; as a pseudo-closer of `do'. + (closer) + ((or (equal levels '(nil)) (nth 1 (car levels))) + (error "Doesn't look like a block")) + (t + ;; FIXME: With grammars like Octave's, every closer ("end", + ;; "endif", "endwhile", ...) has the same level, so we'd need + ;; to look at the BNF or at least at the 2D prec-table, in + ;; order to find the right closer for a given opener. + (while levels + (let ((level (pop levels))) + (dolist (other smie-op-levels) + (when (and (eq (nth 2 level) (nth 1 other)) + (not (memq other seen))) + (push other seen) + (if (nth 2 other) + (push other levels) + (push (car other) found)))))) + (cond + ((null found) (error "No known closer for opener %s" open)) + ;; FIXME: what should we do if there are various closers? + (t (car found)))))))))) + (unless (save-excursion (skip-chars-backward " \t") (bolp)) + (newline)) + (insert closer) + (if (save-excursion (skip-chars-forward " \t") (eolp)) + (indent-according-to-mode) + (reindent-then-newline-and-indent)))) ;;; The indentation engine. @@ -505,22 +578,33 @@ "Rules of the following form. \((:before . TOK) . OFFSET-RULES) how to indent TOK itself. \(TOK . OFFSET-RULES) how to indent right after TOK. -\((T1 . T2) . OFFSET) how to indent token T2 w.r.t T1. -\((t . TOK) . OFFSET) how to indent TOK with respect to its parent. \(list-intro . TOKENS) declare TOKENS as being followed by what may look like a funcall but is just a sequence of expressions. \(t . OFFSET) basic indentation step. \(args . OFFSET) indentation of arguments. +\((T1 . T2) OFFSET) like ((:before . T2) (:parent T1 OFFSET)). OFFSET-RULES is a list of elements which can each either be: \(:hanging . OFFSET-RULES) if TOK is hanging, use OFFSET-RULES. \(:parent PARENT . OFFSET-RULES) if TOK's parent is PARENT, use OFFSET-RULES. \(:next TOKEN . OFFSET-RULES) if TOK is followed by TOKEN, use OFFSET-RULES. -\(:prev TOKEN . OFFSET-RULES) if TOK is preceded by TOKEN, use OFFSET-RULES. -a number the offset to use. +\(:prev TOKEN . OFFSET-RULES) if TOK is preceded by TOKEN, use +\(:bolp . OFFSET-RULES) If TOK is first on a line, use OFFSET-RULES. +OFFSET the offset to use. + +PARENT can be either the name of the parent or `open' to mean any parent +which acts as an open-paren (i.e. has a nil left-precedence). + +OFFSET can be of the form: `point' align with the token. `parent' align with the parent. +NUMBER offset by NUMBER. +\(+ OFFSETS...) use the sum of OFFSETS. + +The precise meaning of `point' depends on various details: it can +either mean the position of the token we're indenting, or the +position of its parent, or the position right after its parent. A nil offset for indentation after a token defaults to `smie-indent-basic'.") @@ -543,21 +627,33 @@ (cdr (assq t smie-indent-rules)) smie-indent-basic)) -(defun smie-indent-offset-rule (tokinfo &optional after) +(defvar smie-indent-debug-log) + +(defun smie-indent-offset-rule (tokinfo &optional after parent) "Apply the OFFSET-RULES in TOKINFO. Point is expected to be right in front of the token corresponding to TOKINFO. If computing the indentation after the token, then AFTER is the position -after the token." +after the token, otherwise it should be nil. +PARENT if non-nil should be the parent info returned by `smie-backward-sexp'." (let ((rules (cdr tokinfo)) - parent next prev + next prev offset) (while (consp rules) (let ((rule (pop rules))) (cond ((not (consp rule)) (setq offset rule)) + ((eq (car rule) '+) (setq offset rule)) ((eq (car rule) :hanging) (when (smie-indent-hanging-p) (setq rules (cdr rule)))) + ((eq (car rule) :bolp) + (when (smie-bolp) + (setq rules (cdr rule)))) + ((eq (car rule) :eolp) + (unless after + (error "Can't use :eolp in :before indentation rules")) + (when (> after (line-end-position)) + (setq rules (cdr rule)))) ((eq (car rule) :prev) (unless prev (save-excursion @@ -578,12 +674,60 @@ (save-excursion (if after (goto-char after)) (setq parent (smie-backward-sexp 'halfsexp)))) - (when (equal (nth 2 parent) (cadr rule)) + (when (or (equal (nth 2 parent) (cadr rule)) + (and (eq (cadr rule) 'open) (null (car parent)))) (setq rules (cddr rule)))) (t (error "Unknown rule %s for indentation of %s" rule (car tokinfo)))))) + ;; If `offset' is not set yet, use `rules' to handle the case where + ;; the tokinfo uses the old-style ((PARENT . TOK). OFFSET). + (unless offset (setq offset rules)) + (when (boundp 'smie-indent-debug-log) + (push (list (point) offset tokinfo) smie-indent-debug-log)) offset)) +(defun smie-indent-column (offset &optional base parent virtual-point) + "Compute the actual column to use for a given OFFSET. +BASE is the base position to use, and PARENT is the parent info, if any. +If VIRTUAL-POINT is non-nil, then `point' is virtual." + (cond + ((eq (car-safe offset) '+) + (apply '+ (mapcar (lambda (offset) (smie-indent-column offset nil parent)) + (cdr offset)))) + ((integerp offset) + (+ offset + (case base + ((nil) 0) + (parent (goto-char (cadr parent)) + (smie-indent-virtual)) + (t + (goto-char base) + ;; For indentation after "(let" in SML-mode, we end up accumulating + ;; the offset of "(" and the offset of "let", so we use `min' to try + ;; and get it right either way. + (min (smie-indent-virtual) (current-column)))))) + ((eq offset 'point) + ;; In indent-keyword, if we're indenting `then' wrt `if', we want to use + ;; indent-virtual rather than use just current-column, so that we can + ;; apply the (:before . "if") rule which does the "else if" dance in SML. + ;; But in other cases, we do not want to use indent-virtual + ;; (e.g. indentation of "*" w.r.t "+", or ";" wrt "("). We could just + ;; always use indent-virtual and then have indent-rules say explicitly + ;; to use `point' after things like "(" or "+" when they're not at EOL, + ;; but you'd end up with lots of those rules. + ;; So we use a heuristic here, which is that we only use virtual if + ;; the parent is tightly linked to the child token (they're part of + ;; the same BNF rule). + (if (and virtual-point (null (car parent))) ;Black magic :-( + (smie-indent-virtual) (current-column))) + ((eq offset 'parent) + (unless parent + (setq parent (or (smie-backward-sexp 'halfsexp) :notfound))) + (if (consp parent) (goto-char (cadr parent))) + (smie-indent-virtual)) + ((eq offset nil) nil) + (t (error "Unknown indentation offset %s" offset)))) + (defun smie-indent-forward-token () "Skip token forward and return it, along with its levels." (let ((tok (funcall smie-forward-token-function))) @@ -655,7 +799,9 @@ (toklevels (smie-indent-forward-token)) (token (pop toklevels))) (if (null (car toklevels)) - ;; Different case: + (save-excursion + (goto-char pos) + ;; Different cases: ;; - smie-bolp: "indent according to others". ;; - common hanging: "indent according to others". ;; - SML-let hanging: "indent like parent". @@ -668,72 +814,115 @@ ;; based on other rules (typically smie-indent-after-keyword). nil) (t - (let* ((tokinfo (or (assoc (cons :before token) smie-indent-rules) + ;; We're only ever here for virtual-indent, which is why + ;; we can use (current-column) as answer for `point'. + (let* ((tokinfo (or (assoc (cons :before token) + smie-indent-rules) ;; By default use point unless we're hanging. - (cons (cons :before token) - '((:hanging nil) point)))) - (after (prog1 (point) (goto-char pos))) + `((:before . ,token) (:hanging nil) point))) + ;; (after (prog1 (point) (goto-char pos))) (offset (smie-indent-offset-rule tokinfo))) - (cond - ((eq offset 'point) (current-column)) - ((eq offset 'parent) - (let ((parent (smie-backward-sexp 'halfsexp))) - (if parent (goto-char (cadr parent)))) - (smie-indent-virtual)) - ((eq offset nil) nil) - (t (error "Unhandled offset %s in %s" - offset (cons :before token))))))) + (smie-indent-column offset))))) ;; FIXME: This still looks too much like black magic!! ;; FIXME: Rather than a bunch of rules like (PARENT . TOKEN), we ;; want a single rule for TOKEN with different cases for each PARENT. - (let ((res (smie-backward-sexp 'halfsexp)) tmp) + (let* ((parent (smie-backward-sexp 'halfsexp)) + (tokinfo + (or (assoc (cons (caddr parent) token) + smie-indent-rules) + (assoc (cons :before token) smie-indent-rules) + ;; Default rule. + `((:before . ,token) + ;; (:parent open 0) + point))) + (offset (save-excursion + (goto-char pos) + (smie-indent-offset-rule tokinfo nil parent)))) + ;; Different behaviors: + ;; - align with parent. + ;; - parent + offset. + ;; - after parent's column + offset (actually, after or before + ;; depending on where backward-sexp stopped). + ;; ? let it drop to some other indentation function (almost never). + ;; ? parent + offset + parent's own offset. + ;; Different cases: + ;; - bump into a same-level operator. + ;; - bump into a specific known parent. + ;; - find a matching open-paren thingy. + ;; - bump into some random parent. + ;; ? borderline case (almost never). + ;; ? bump immediately into a parent. (cond ((not (or (< (point) pos) - (and (cadr res) (< (cadr res) pos)))) + (and (cadr parent) (< (cadr parent) pos)))) ;; If we didn't move at all, that means we didn't really skip - ;; what we wanted. + ;; what we wanted. Should almost never happen, other than + ;; maybe when an infix or close-paren is at the beginning + ;; of a buffer. nil) - ((eq (car res) (car toklevels)) + ((eq (car parent) (car toklevels)) ;; We bumped into a same-level operator. align with it. - (goto-char (cadr res)) + (if (and (smie-bolp) (/= (point) pos) + (save-excursion + (goto-char (goto-char (cadr parent))) + (not (smie-bolp))) + ;; Check the offset of `token' rather then its parent + ;; because its parent may have used a special rule. E.g. + ;; function foo; + ;; line2; + ;; line3; + ;; The ; on the first line had a special rule, but when + ;; indenting line3, we don't care about it and want to + ;; align with line2. + (memq offset '(point nil))) + ;; If the parent is at EOL and its children are indented like + ;; itself, then we can just obey the indentation chosen for the + ;; child. + ;; This is important for operators like ";" which + ;; are usually at EOL (and have an offset of 0): otherwise we'd + ;; always go back over all the statements, which is + ;; a performance problem and would also mean that fixindents + ;; in the middle of such a sequence would be ignored. + ;; + ;; This is a delicate point! + ;; Even if the offset is not 0, we could follow the same logic + ;; and subtract the offset from the child's indentation. + ;; But that would more often be a bad idea: OT1H we generally + ;; want to reuse the closest similar indentation point, so that + ;; the user's choice (or the fixindents) are obeyed. But OTOH + ;; we don't want this to affect "unrelated" parts of the code. + ;; E.g. a fixindent in the body of a "begin..end" should not + ;; affect the indentation of the "end". + (current-column) + (goto-char (cadr parent)) ;; Don't use (smie-indent-virtual :not-hanging) here, because we ;; want to jump back over a sequence of same-level ops such as ;; a -> b -> c ;; -> d ;; So as to align with the earliest appropriate place. - (smie-indent-virtual)) - ((setq tmp (assoc (cons (caddr res) token) - smie-indent-rules)) - (goto-char (cadr res)) - (+ (cdr tmp) (smie-indent-virtual))) ;:not-hanging - ;; FIXME: The rules ((t . TOK) . OFFSET) either indent - ;; relative to "before the parent" or "after the parent", - ;; depending on details of the grammar. - ((null (car res)) - (assert (eq (point) (cadr res))) - (goto-char (cadr res)) - (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0) - (smie-indent-virtual))) ;:not-hanging - ((and (= (point) pos) (smie-bolp)) + (smie-indent-virtual))) + (tokinfo + (if (and (= (point) pos) (smie-bolp) + (or (eq offset 'point) + (and (consp offset) (memq 'point offset)))) ;; Since we started at BOL, we're not computing a virtual - ;; indentation, and we're still at the starting point, so the - ;; next (default) rule can't be used since it uses `current-column' - ;; which would cause. indentation to depend on itself. - ;; We could just return nil, but OTOH that's not good enough in - ;; some cases. Instead, we want to combine the offset-rules for - ;; the current token with the offset-rules of the previous one. - (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0) - ;; FIXME: This is odd. Can't we make it use - ;; smie-indent-(calculate|virtual) somehow? - (smie-indent-after-keyword))) - (t - (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0) - (current-column))))))))) + ;; indentation, and we're still at the starting point, so + ;; we can't use `current-column' which would cause + ;; indentation to depend on itself. + nil + (smie-indent-column offset 'parent parent + ;; If we're still at pos, indent-virtual + ;; will inf-loop. + (unless (= (point) pos) 'virtual)))))))))) (defun smie-indent-comment () - ;; Indentation of a comment. - (and (looking-at comment-start-skip) + "Compute indentation of a comment." + ;; Don't do it for virtual indentations. We should normally never be "in + ;; front of a comment" when doing virtual-indentation anyway. And if we are + ;; (as can happen in octave-mode), moving forward can lead to inf-loops. + (and (smie-bolp) + (looking-at comment-start-skip) (save-excursion (forward-comment (point-max)) (skip-chars-forward " \t\r\n") @@ -761,26 +950,25 @@ (toklevel (smie-indent-backward-token)) (tok (car toklevel)) (tokinfo (assoc tok smie-indent-rules))) + ;; Set some default indent rules. (if (and toklevel (null (cadr toklevel)) (null tokinfo)) (setq tokinfo (list (car toklevel)))) ;; (if (and tokinfo (null toklevel)) ;; (error "Token %S has indent rule but has no parsing info" tok)) (when toklevel + (unless tokinfo + ;; The default indentation after a keyword/operator is 0 for + ;; infix and t for prefix. + ;; Using the BNF syntax, we could come up with better + ;; defaults, but we only have the precedence levels here. + (setq tokinfo (list tok 'default-rule + (if (cadr toklevel) 0 (smie-indent-offset t))))) (let ((offset - (cond - (tokinfo (or (smie-indent-offset-rule tokinfo pos) - (smie-indent-offset t))) - ;; The default indentation after a keyword/operator - ;; is 0 for infix and t for prefix. - ;; Using the BNF syntax, we could come up with - ;; better defaults, but we only have the - ;; precedence levels here. - ((null (cadr toklevel)) (smie-indent-offset t)) - (t 0)))) - ;; For indentation after "(let" in SML-mode, we end up accumulating - ;; the offset of "(" and the offset of "let", so we use `min' to try - ;; and get it right either way. - (+ (min (smie-indent-virtual) (current-column)) offset)))))) + (or (smie-indent-offset-rule tokinfo pos) + (smie-indent-offset t)))) + (let ((before (point))) + (goto-char pos) + (smie-indent-column offset before))))))) (defun smie-indent-exps () ;; Indentation of sequences of simple expressions without @@ -851,7 +1039,7 @@ "Indent current line using the SMIE indentation engine." (interactive) (let* ((savep (point)) - (indent (condition-case nil + (indent (condition-case-no-debug nil (save-excursion (forward-line 0) (skip-chars-forward " \t") @@ -866,7 +1054,14 @@ (save-excursion (indent-line-to indent)) (indent-line-to indent))))) -;;;###autoload +(defun smie-indent-debug () + "Show the rules used to compute indentation of current line." + (interactive) + (let ((smie-indent-debug-log '())) + (smie-indent-calculate) + ;; FIXME: please improve! + (message "%S" smie-indent-debug-log))) + (defun smie-setup (op-levels indent-rules) (set (make-local-variable 'smie-indent-rules) indent-rules) (set (make-local-variable 'smie-op-levels) op-levels) ------------------------------------------------------------ revno: 101123 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 12:21:43 +0200 message: * lisp/emacs-lisp/autoload.el (make-autoload): Preload the macros's declarations that are useful before running the macro. * src/eval.c (Fdefmacro): Only obey one declaration. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2010-08-18 07:45:14 +0000 +++ lisp/ChangeLog 2010-08-18 10:21:43 +0000 @@ -1,3 +1,8 @@ +2010-08-18 Stefan Monnier + + * emacs-lisp/autoload.el (make-autoload): Preload the macros's + declarations that are useful before running the macro. + 2010-08-18 Katsumi Yamaoka * image.el (create-animated-image): Don't add heuristic mask to image @@ -5,8 +10,8 @@ 2010-08-18 Jan Djärv - * term/ns-win.el (ns-get-pasteboard, ns-set-pasteboard): Use - QCLIPBOARD instead of QPRIMARY (Bug#6677). + * term/ns-win.el (ns-get-pasteboard, ns-set-pasteboard): + Use QCLIPBOARD instead of QPRIMARY (Bug#6677). 2010-08-17 Stefan Monnier === modified file 'lisp/emacs-lisp/autoload.el' --- lisp/emacs-lisp/autoload.el 2010-04-18 21:45:44 +0000 +++ lisp/emacs-lisp/autoload.el 2010-08-18 10:21:43 +0000 @@ -109,29 +109,48 @@ (let* ((macrop (memq car '(defmacro defmacro*))) (name (nth 1 form)) (args (case car - ((defun defmacro defun* defmacro* - define-overloadable-function) (nth 2 form)) - ((define-skeleton) '(&optional str arg)) - ((define-generic-mode define-derived-mode - define-compilation-mode) nil) - (t))) + ((defun defmacro defun* defmacro* + define-overloadable-function) (nth 2 form)) + ((define-skeleton) '(&optional str arg)) + ((define-generic-mode define-derived-mode + define-compilation-mode) nil) + (t))) (body (nthcdr (get car 'doc-string-elt) form)) (doc (if (stringp (car body)) (pop body)))) (when (listp args) ;; Add the usage form at the end where describe-function-1 ;; can recover it. (setq doc (help-add-fundoc-usage doc args))) - ;; `define-generic-mode' quotes the name, so take care of that - (list 'autoload (if (listp name) name (list 'quote name)) file doc - (or (and (memq car '(define-skeleton define-derived-mode - define-generic-mode - easy-mmode-define-global-mode - define-global-minor-mode - define-globalized-minor-mode - easy-mmode-define-minor-mode - define-minor-mode)) t) - (eq (car-safe (car body)) 'interactive)) - (if macrop (list 'quote 'macro) nil)))) + (let ((exp + ;; `define-generic-mode' quotes the name, so take care of that + (list 'autoload (if (listp name) name (list 'quote name)) + file doc + (or (and (memq car '(define-skeleton define-derived-mode + define-generic-mode + easy-mmode-define-global-mode + define-global-minor-mode + define-globalized-minor-mode + easy-mmode-define-minor-mode + define-minor-mode)) t) + (eq (car-safe (car body)) 'interactive)) + (if macrop (list 'quote 'macro) nil)))) + (when macrop + ;; Special case to autoload some of the macro's declarations. + (let ((decls (nth (if (stringp (nth 3 form)) 4 3) form)) + (exps '())) + (when (eq (car decls) 'declare) + ;; FIXME: We'd like to reuse macro-declaration-function, + ;; but we can't since it doesn't return anything. + (dolist (decl decls) + (case (car-safe decl) + (indent + (push `(put ',name 'lisp-indent-function ',(cadr decl)) + exps)) + (doc-string + (push `(put ',name 'doc-string-elt ',(cadr decl)) exps)))) + (when exps + (setq exp `(progn ,exp ,@exps)))))) + exp))) ;; For defclass forms, use `eieio-defclass-autoload'. ((eq car 'defclass) === modified file 'src/ChangeLog' --- src/ChangeLog 2010-08-18 09:27:53 +0000 +++ src/ChangeLog 2010-08-18 10:21:43 +0000 @@ -1,5 +1,7 @@ 2010-08-18 Stefan Monnier + * eval.c (Fdefmacro): Only obey one declaration. + * casefiddle.c (casify_region): Setup gl_state. 2010-08-18 Jan Djärv === modified file 'src/eval.c' --- src/eval.c 2010-08-06 19:07:16 +0000 +++ src/eval.c 2010-08-18 10:21:43 +0000 @@ -690,8 +690,8 @@ tail = XCDR (tail); } - while (CONSP (Fcar (tail)) - && EQ (Fcar (Fcar (tail)), Qdeclare)) + if (CONSP (Fcar (tail)) + && EQ (Fcar (Fcar (tail)), Qdeclare)) { if (!NILP (Vmacro_declaration_function)) { ------------------------------------------------------------ revno: 101122 committer: Stefan Monnier branch nick: trunk timestamp: Wed 2010-08-18 11:27:53 +0200 message: * casefiddle.c (casify_region): Setup gl_state. diff: === modified file 'src/ChangeLog' --- src/ChangeLog 2010-08-18 08:06:45 +0000 +++ src/ChangeLog 2010-08-18 09:27:53 +0000 @@ -1,3 +1,7 @@ +2010-08-18 Stefan Monnier + + * casefiddle.c (casify_region): Setup gl_state. + 2010-08-18 Jan Djärv * nsterm.m (ns_define_frame_cursor): Call x_update_cursor (Bug#6868). === modified file 'src/casefiddle.c' --- src/casefiddle.c 2010-08-12 14:44:16 +0000 +++ src/casefiddle.c 2010-08-18 09:27:53 +0000 @@ -221,6 +221,8 @@ start_byte = CHAR_TO_BYTE (start); end_byte = CHAR_TO_BYTE (end); + SETUP_BUFFER_SYNTAX_TABLE(); /* For syntax_prefix_flag_p. */ + while (start < end) { int c2, len; ------------------------------------------------------------ revno: 101121 committer: Jan D branch nick: trunk timestamp: Wed 2010-08-18 10:06:45 +0200 message: * nsterm.m (ns_define_frame_cursor): Call x_update_cursor (Bug#6868). diff: === modified file 'src/ChangeLog' --- src/ChangeLog 2010-08-18 06:30:54 +0000 +++ src/ChangeLog 2010-08-18 08:06:45 +0000 @@ -1,5 +1,9 @@ 2010-08-18 Jan Djärv + * nsterm.m (ns_define_frame_cursor): Call x_update_cursor (Bug#6868). + +2010-08-18 Jan Djärv + * gtkutil.c (update_frame_tool_bar): Literal stings are const char*. 2010-08-18 David De La Harpe Golden === modified file 'src/nsterm.m' --- src/nsterm.m 2010-08-06 10:12:41 +0000 +++ src/nsterm.m 2010-08-18 08:06:45 +0000 @@ -1792,6 +1792,9 @@ EmacsView *view = FRAME_NS_VIEW (f); FRAME_POINTER_TYPE (f) = cursor; [[view window] invalidateCursorRectsForView: view]; + /* Redisplay assumes this function also draws the changed frame + cursor, but this function doesn't, so do it explicitly. */ + x_update_cursor (f, 1); } } ------------------------------------------------------------ revno: 101120 [merge] committer: Katsumi Yamaoka branch nick: trunk timestamp: Wed 2010-08-18 07:46:27 +0000 message: create-animated-image: Don't add heuristic mask to image (Bug#6839). diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2010-08-18 06:16:55 +0000 +++ lisp/ChangeLog 2010-08-18 07:45:14 +0000 @@ -1,3 +1,8 @@ +2010-08-18 Katsumi Yamaoka + + * image.el (create-animated-image): Don't add heuristic mask to image + (Bug#6839). + 2010-08-18 Jan Djärv * term/ns-win.el (ns-get-pasteboard, ns-set-pasteboard): Use === modified file 'lisp/image.el' --- lisp/image.el 2010-05-25 15:54:53 +0000 +++ lisp/image.el 2010-08-18 07:45:14 +0000 @@ -616,7 +616,7 @@ (let* ((animate (memq type image-animated-types)) (image (append (list 'image :type type (if data-p :data :file) file-or-data) - (if animate '(:index 0 :mask heuristic)) + (if animate '(:index 0)) props))) (if animate (image-animate-start image)) ------------------------------------------------------------ revno: 101119 committer: Glenn Morris branch nick: trunk timestamp: Tue 2010-08-17 23:54:26 -0700 message: Add bug ref to placeholder NEWS entry. diff: === modified file 'etc/NEWS' --- etc/NEWS 2010-08-18 02:48:28 +0000 +++ etc/NEWS 2010-08-18 06:54:26 +0000 @@ -214,7 +214,7 @@ * Changes in Specialized Modes and Packages in Emacs 24.1 -** FIXME: xdg-open for browse-url and reportbug, 2010/08. +** FIXME: xdg-open for browse-url and reportbug, 2010/08. (Close bug#4546?) ** Archive Mode has basic support to browse 7z archives. ------------------------------------------------------------ Use --include-merges or -n0 to see merged revisions.