martin/emacs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove old indentation and navigation code on octave-mode.

Browse Source 
* lisp/progmodes/octave-mod.el (octave-mode-map): Remap down-list to
smie-down-list rather than add a binding for octave-down-block.
(octave-mark-block, octave-blink-matching-block-open):
Rely on forward-sexp-function.
(octave-fill-paragraph): Don't narrow, so you can use
indent-according-to-mode.
(octave-block-begin-regexp, octave-block-begin-or-end-regexp): Remove.
(octave-in-block-p, octave-re-search-forward-kw)
(octave-re-search-backward-kw, octave-indent-calculate)
(octave-end-as-array-index-p, octave-block-end-offset)
(octave-scan-blocks, octave-forward-block, octave-backward-block)
(octave-down-block, octave-backward-up-block, octave-up-block)
(octave-before-magic-comment-p, octave-indent-line): Remove.
This commit is contained in:
Stefan Monnier
2010-08-31 14:13:51 +02:00
parent 1a10d4212f
commit ec5d3ff71f
2 changed files with 98 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
lisp/ChangeLog
View File

@@ -1,3 +1,20 @@
2010-08-31 Stefan Monnier <monnier@iro.umontreal.ca>
Remove old indentation and navigation code on octave-mode.
* progmodes/octave-mod.el (octave-mode-map): Remap down-list to
smie-down-list rather than add a binding for octave-down-block.
(octave-mark-block, octave-blink-matching-block-open):
Rely on forward-sexp-function.
(octave-fill-paragraph): Don't narrow, so you can use
indent-according-to-mode.
(octave-block-begin-regexp, octave-block-begin-or-end-regexp): Remove.
(octave-in-block-p, octave-re-search-forward-kw)
(octave-re-search-backward-kw, octave-indent-calculate)
(octave-end-as-array-index-p, octave-block-end-offset)
(octave-scan-blocks, octave-forward-block, octave-backward-block)
(octave-down-block, octave-backward-up-block, octave-up-block)
(octave-before-magic-comment-p, octave-indent-line): Remove.
2010-08-31 Chong Yidong <cyd@stupidchicken.com>
* emacs-lisp/package.el (package--read-archive-file): Just use
@@ -12,15 +29,15 @@
package-menu-package-list and package-menu-package-sort-key.
(package-menu--version-predicate): Fix version calculation.
(package-menu-sort-by-column): Don't select the window.
(package--list-packages): Create the *Packages* buffer. Set
package-menu-package-list-key.
(package--list-packages): Create the *Packages* buffer.
Set package-menu-package-list-key.
(list-packages): Sorting by status is now the default.
(package-buffer-info): Use match-string-no-properties.
(define-package): Add a &rest argument for future proofing, but
don't use it yet.
(package-install-from-buffer, package-install-buffer-internal):
Merged into a single function, package-install-from-buffer.
(package-install-file): Caller changed.
Merge into a single function, package-install-from-buffer.
(package-install-file): Change caller.
* finder.el: Load finder-inf using `require'.
(finder-list-matches): Sorting by status is now the default.

384
lisp/progmodes/octave-mod.el
View File

@@ -223,7 +223,7 @@ parenthetical grouping.")
(define-key map "\C-c\C-n" 'octave-next-code-line)
(define-key map "\C-c\C-a" 'octave-beginning-of-line)
(define-key map "\C-c\C-e" 'octave-end-of-line)
(define-key map "\C-c\M-\C-d" 'octave-down-block)
(define-key map [remap down-list] 'smie-down-list)
(define-key map "\C-c\M-\C-h" 'octave-mark-block)
(define-key map "\C-c]" 'smie-close-block)
(define-key map "\C-c/" 'smie-close-block)
@@ -258,7 +258,6 @@ parenthetical grouping.")
["End of Continuation" octave-end-of-line t]
["Split Line at Point" octave-indent-new-comment-line t])
("Blocks"
["Down Block" octave-down-block t]
["Mark Block" octave-mark-block t]
["Close Block" smie-close-block t])
("Functions"
@@ -343,10 +342,6 @@ newline or semicolon after an else or end keyword."
:type 'integer
:group 'octave)
(defvar octave-block-begin-regexp
(concat "\\<\\("
(mapconcat 'identity octave-begin-keywords "\\|")
"\\)\\>"))
(defvar octave-block-else-regexp
(concat "\\<\\("
(mapconcat 'identity octave-else-keywords "\\|")
@@ -355,8 +350,6 @@ newline or semicolon after an else or end keyword."
(concat "\\<\\("
(mapconcat 'identity octave-end-keywords "\\|")
"\\)\\>"))
(defvar octave-block-begin-or-end-regexp
(concat octave-block-begin-regexp "\\|" octave-block-end-regexp))
(defvar octave-block-else-or-end-regexp
(concat octave-block-else-regexp "\\|" octave-block-end-regexp))
(defvar octave-block-match-alist
@@ -723,36 +716,12 @@ Look up symbol in the function, operator and variable indices of the info files.
(let ((pps (parse-partial-sexp (line-beginning-position) (point))))
(not (or (nth 3 pps) (nth 4 pps)))))
(defun octave-in-block-p ()
"Return t if point is inside an Octave block.
The block is taken to start at the first letter of the begin keyword and
to end after the end keyword."
(let ((pos (point)))
(save-excursion
(condition-case nil
(progn
(skip-syntax-forward "w")
(octave-up-block -1)
(octave-forward-block)
t)
(error nil))
(< pos (point)))))
(defun octave-looking-at-kw (regexp)
"Like `looking-at', but sets `case-fold-search' nil."
(let ((case-fold-search nil))
(looking-at regexp)))
(defun octave-re-search-forward-kw (regexp count)
"Like `re-search-forward', but sets `case-fold-search' nil, and moves point."
(let ((case-fold-search nil))
(re-search-forward regexp nil 'move count)))
(defun octave-re-search-backward-kw (regexp count)
"Like `re-search-backward', but sets `case-fold-search' nil, and moves point."
(let ((case-fold-search nil))
(re-search-backward regexp nil 'move count)))
(defun octave-maybe-insert-continuation-string ()
(if (or (octave-in-comment-p)
(save-excursion
@@ -764,108 +733,6 @@ to end after the end keyword."
;;; Indentation
(defun octave-indent-calculate ()
"Return appropriate indentation for current line as Octave code.
Returns an integer (the column to indent to) unless the line is a
comment line with fixed goal golumn. In that case, returns a list whose
car is the column to indent to, and whose cdr is the current indentation
level."
(let ((is-continuation-line
(save-excursion
(if (zerop (octave-previous-code-line))
(looking-at octave-continuation-regexp))))
(icol 0))
(save-excursion
(beginning-of-line)
;; If we can move backward out one level of parentheses, take 1
;; plus the indentation of that parenthesis. Otherwise, go back
;; to the beginning of the previous code line, and compute the
;; offset this line gives.
(if (condition-case nil
(progn
(up-list -1)
t)
(error nil))
(setq icol (+ 1 (current-column)))
(if (zerop (octave-previous-code-line))
(progn
(octave-beginning-of-line)
(back-to-indentation)
(setq icol (current-column))
(let ((bot (point))
(eol (line-end-position)))
(while (< (point) eol)
(if (octave-not-in-string-or-comment-p)
(cond
((octave-looking-at-kw "\\<switch\\>")
(setq icol (+ icol (* 2 octave-block-offset))))
((octave-looking-at-kw octave-block-begin-regexp)
(setq icol (+ icol octave-block-offset)))
((octave-looking-at-kw octave-block-else-regexp)
(if (= bot (point))
(setq icol (+ icol octave-block-offset))))
((octave-looking-at-kw octave-block-end-regexp)
(if (and (not (= bot (point)))
;; special case for `end' keyword,
;; applied to all keywords
(not (octave-end-as-array-index-p)))
(setq icol (- icol
(octave-block-end-offset)))))))
(forward-char)))
(if is-continuation-line
(setq icol (+ icol octave-continuation-offset)))))))
(save-excursion
(back-to-indentation)
(cond
((and (octave-looking-at-kw octave-block-else-regexp)
(octave-not-in-string-or-comment-p))
(setq icol (- icol octave-block-offset)))
((and (octave-looking-at-kw octave-block-end-regexp)
(octave-not-in-string-or-comment-p))
(setq icol (- icol (octave-block-end-offset))))
((or (looking-at "\\s<\\s<\\s<\\S<")
(octave-before-magic-comment-p))
(setq icol (list 0 icol)))
((looking-at "\\s<\\S<")
(setq icol (list comment-column icol)))))
icol))
;; FIXME: this should probably also make sure we are actually looking
;; at the "end" keyword.
(defun octave-end-as-array-index-p ()
(save-excursion
(condition-case nil
;; Check if point is between parens
(progn (up-list 1) t)
(error nil))))
(defun octave-block-end-offset ()
(save-excursion
(octave-backward-up-block 1)
(* octave-block-offset
(if (string-match (match-string 0) "switch") 2 1))))
(defun octave-before-magic-comment-p ()
(save-excursion
(beginning-of-line)
(and (bobp) (looking-at "\\s-*#!"))))
(defun octave-indent-line (&optional arg)
"Indent current line as Octave code.
With optional ARG, use this as offset unless this line is a comment with
fixed goal column."
(interactive)
(or arg (setq arg 0))
(let ((icol (octave-indent-calculate))
(relpos (- (current-column) (current-indentation))))
(if (listp icol)
(setq icol (car icol))
(setq icol (+ icol arg)))
(if (< icol 0)
(error "Unmatched end keyword")
(indent-line-to icol)
(if (> relpos 0)
(move-to-column (+ icol relpos))))))
(defun octave-indent-new-comment-line ()
"Break Octave line at point, continuing comment if within one.
@@ -967,106 +834,17 @@ does not end in `...' or `\\' or is inside an open parenthesis list."
(zerop (forward-line 1)))))
(end-of-line)))
(defun octave-scan-blocks (count depth)
"Scan from point by COUNT Octave begin-end blocks.
Returns the character number of the position thus found.
If DEPTH is nonzero, block depth begins counting from that value.
Only places where the depth in blocks becomes zero are candidates for
stopping; COUNT such places are counted.
If the beginning or end of the buffer is reached and the depth is wrong,
an error is signaled."
(let ((min-depth (if (> depth 0) 0 depth))
(inc (if (> count 0) 1 -1)))
(save-excursion
(while (/= count 0)
(catch 'foo
(while (or (octave-re-search-forward-kw
octave-block-begin-or-end-regexp inc)
(if (/= depth 0)
(error "Unbalanced block")))
(if (octave-not-in-string-or-comment-p)
(progn
(cond
((match-end 1)
(setq depth (+ depth inc)))
((match-end 2)
(setq depth (- depth inc))))
(if (< depth min-depth)
(error "Containing expression ends prematurely"))
(if (= depth 0)
(throw 'foo nil))))))
(setq count (- count inc)))
(point))))
(defun octave-forward-block (&optional arg)
"Move forward across one balanced Octave begin-end block.
With argument, do it that many times.
Negative arg -N means move backward across N blocks."
(interactive "p")
(or arg (setq arg 1))
(goto-char (or (octave-scan-blocks arg 0) (buffer-end arg))))
(defun octave-backward-block (&optional arg)
"Move backward across one balanced Octave begin-end block.
With argument, do it that many times.
Negative arg -N means move forward across N blocks."
(interactive "p")
(or arg (setq arg 1))
(octave-forward-block (- arg)))
(defun octave-down-block (arg)
"Move forward down one begin-end block level of Octave code.
With argument, do this that many times.
A negative argument means move backward but still go down a level.
In Lisp programs, an argument is required."
(interactive "p")
(let ((inc (if (> arg 0) 1 -1)))
(while (/= arg 0)
(goto-char (or (octave-scan-blocks inc -1)
(buffer-end arg)))
(setq arg (- arg inc)))))
(defun octave-backward-up-block (arg)
"Move backward out of one begin-end block level of Octave code.
With argument, do this that many times.
A negative argument means move forward but still to a less deep spot.
In Lisp programs, an argument is required."
(interactive "p")
(octave-up-block (- arg)))
(defun octave-up-block (arg)
"Move forward out of one begin-end block level of Octave code.
With argument, do this that many times.
A negative argument means move backward but still to a less deep spot.
In Lisp programs, an argument is required."
(interactive "p")
(let ((inc (if (> arg 0) 1 -1)))
(while (/= arg 0)
(goto-char (or (octave-scan-blocks inc 1)
(buffer-end arg)))
(setq arg (- arg inc)))))
(defun octave-mark-block ()
"Put point at the beginning of this Octave block, mark at the end.
The block marked is the one that contains point or follows point."
(interactive)
(let ((pos (point)))
(if (or (and (octave-in-block-p)
(skip-syntax-forward "w"))
(condition-case nil
(progn
(octave-down-block 1)
(octave-in-block-p))
(error nil)))
(progn
(octave-up-block -1)
(push-mark (point))
(octave-forward-block)
(exchange-point-and-mark))
(goto-char pos)
(message "No block to mark found"))))
(unless (or (looking-at "\\s(")
(save-excursion
(let* ((token (funcall smie-forward-token-function))
(level (assoc token smie-op-levels)))
(and level (null (cadr level))))))
(backward-up-list 1))
(mark-sexp))
(defun octave-blink-matching-block-open ()
"Blink the matching Octave begin block keyword.
@@ -1086,12 +864,12 @@ Signal an error if the keywords are incompatible."
(setq eb-keyword
(buffer-substring-no-properties
(match-beginning 1) (match-end 1)))
(octave-backward-up-block 1))
(backward-up-list 1))
((match-end 2)
(setq eb-keyword
(buffer-substring-no-properties
(match-beginning 2) (match-end 2)))
(octave-backward-block)))
(backward-sexp 1)))
(setq pos (match-end 0)
bb-keyword
(buffer-substring-no-properties
@@ -1202,81 +980,73 @@ otherwise."
(not give-up))))
(defun octave-fill-paragraph (&optional arg)
"Fill paragraph of Octave code, handling Octave comments."
;; FIXME: now that the default fill-paragraph takes care of similar issues,
;; this seems obsolete. --Stef
(interactive "P")
(save-excursion
(let ((end (progn (forward-paragraph) (point)))
(beg (progn
(forward-paragraph -1)
(skip-chars-forward " \t\n")
(beginning-of-line)
(point)))
(cfc (current-fill-column))
(ind (octave-indent-calculate))
comment-prefix)
(save-restriction
(goto-char beg)
(narrow-to-region beg end)
(if (listp ind) (setq ind (nth 1 ind)))
(while (not (eobp))
(condition-case nil
(octave-indent-line ind)
(error nil))
(if (and (> ind 0)
(not
(save-excursion
(beginning-of-line)
(looking-at "^\\s-*\\($\\|\\s<+\\)"))))
(setq ind 0))
(move-to-column cfc)
;; First check whether we need to combine non-empty comment lines
(if (and (< (current-column) cfc)
(octave-in-comment-p)
(not (save-excursion
(beginning-of-line)
(looking-at "^\\s-*\\s<+\\s-*$"))))
;; This is a nonempty comment line which does not extend
;; past the fill column. If it is followed by a nonempty
;; comment line with the same comment prefix, try to
;; combine them, and repeat this until either we reach the
;; fill-column or there is nothing more to combine.
(progn
;; Get the comment prefix
(save-excursion
(beginning-of-line)
(while (and (re-search-forward "\\s<+")
(not (octave-in-comment-p))))
(setq comment-prefix (match-string 0)))
;; And keep combining ...
(while (and (< (current-column) cfc)
(save-excursion
(forward-line 1)
(and (looking-at
(concat "^\\s-*"
comment-prefix
"\\S<"))
(not (looking-at
(concat "^\\s-*"
comment-prefix
"\\s-*$"))))))
(delete-char 1)
(re-search-forward comment-prefix)
(delete-region (match-beginning 0) (match-end 0))
(fixup-whitespace)
(move-to-column cfc))))
;; We might also try to combine continued code lines> Perhaps
;; some other time ...
(skip-chars-forward "^ \t\n")
(delete-horizontal-space)
(if (or (< (current-column) cfc)
(and (= (current-column) cfc) (eolp)))
(forward-line 1)
(if (not (eolp)) (insert " "))
(or (octave-auto-fill)
(forward-line 1)))))
t)))
"Fill paragraph of Octave code, handling Octave comments."
;; FIXME: difference with generic fill-paragraph:
;; - code lines are only split, never joined.
;; - \n that end comments are never removed.
;; - insert continuation marker when splitting code lines.
(interactive "P")
(save-excursion
(let ((end (progn (forward-paragraph) (copy-marker (point) t)))
(beg (progn
(forward-paragraph -1)
(skip-chars-forward " \t\n")
(beginning-of-line)
(point)))
(cfc (current-fill-column))
comment-prefix)
(goto-char beg)
(while (< (point) end)
(condition-case nil
(indent-according-to-mode)
(error nil))
(move-to-column cfc)
;; First check whether we need to combine non-empty comment lines
(if (and (< (current-column) cfc)
(octave-in-comment-p)
(not (save-excursion
(beginning-of-line)
(looking-at "^\\s-*\\s<+\\s-*$"))))
;; This is a nonempty comment line which does not extend
;; past the fill column. If it is followed by a nonempty
;; comment line with the same comment prefix, try to
;; combine them, and repeat this until either we reach the
;; fill-column or there is nothing more to combine.
(progn
;; Get the comment prefix
(save-excursion
(beginning-of-line)
(while (and (re-search-forward "\\s<+")
(not (octave-in-comment-p))))
(setq comment-prefix (match-string 0)))
;; And keep combining ...
(while (and (< (current-column) cfc)
(save-excursion
(forward-line 1)
(and (looking-at
(concat "^\\s-*"
comment-prefix
"\\S<"))
(not (looking-at
(concat "^\\s-*"
comment-prefix
"\\s-*$"))))))
(delete-char 1)
(re-search-forward comment-prefix)
(delete-region (match-beginning 0) (match-end 0))
(fixup-whitespace)
(move-to-column cfc))))
;; We might also try to combine continued code lines> Perhaps
;; some other time ...
(skip-chars-forward "^ \t\n")
(delete-horizontal-space)
(if (or (< (current-column) cfc)
(and (= (current-column) cfc) (eolp)))
(forward-line 1)
(if (not (eolp)) (insert " "))
(or (octave-auto-fill)
(forward-line 1))))
t)))
;;; Completions