![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lisp-mode.el CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp|
Return to lisp-mode.el CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / lisp |
1.1 root 1: ;; Lisp mode, and its idiosyncratic commands.
2: ;; Copyright (C) 1985 Free Software Foundation, Inc.
3:
4: ;; This file is part of GNU Emacs.
5:
6: ;; GNU Emacs is distributed in the hope that it will be useful,
7: ;; but WITHOUT ANY WARRANTY. No author or distributor
8: ;; accepts responsibility to anyone for the consequences of using it
9: ;; or for whether it serves any particular purpose or works at all,
10: ;; unless he says so in writing. Refer to the GNU Emacs General Public
11: ;; License for full details.
12:
13: ;; Everyone is granted permission to copy, modify and redistribute
14: ;; GNU Emacs, but only under the conditions described in the
15: ;; GNU Emacs General Public License. A copy of this license is
16: ;; supposed to have been given to you along with GNU Emacs so you
17: ;; can know your rights and responsibilities. It should be in a
18: ;; file named COPYING. Among other things, the copyright notice
19: ;; and this notice must be preserved on all copies.
20:
21:
22: (defvar lisp-mode-syntax-table nil "")
23: (defvar emacs-lisp-mode-syntax-table nil "")
24: (defvar lisp-mode-abbrev-table nil "")
25:
26: (if (not emacs-lisp-mode-syntax-table)
27: (let ((i 0))
28: (setq emacs-lisp-mode-syntax-table (make-syntax-table))
29: (while (< i ?0)
30: (modify-syntax-entry i "_ " emacs-lisp-mode-syntax-table)
31: (setq i (1+ i)))
32: (setq i (1+ ?9))
33: (while (< i ?A)
34: (modify-syntax-entry i "_ " emacs-lisp-mode-syntax-table)
35: (setq i (1+ i)))
36: (setq i (1+ ?Z))
37: (while (< i ?a)
38: (modify-syntax-entry i "_ " emacs-lisp-mode-syntax-table)
39: (setq i (1+ i)))
40: (setq i (1+ ?z))
41: (while (< i 128)
42: (modify-syntax-entry i "_ " emacs-lisp-mode-syntax-table)
43: (setq i (1+ i)))
44: (modify-syntax-entry ? " " emacs-lisp-mode-syntax-table)
45: (modify-syntax-entry ?\t " " emacs-lisp-mode-syntax-table)
46: (modify-syntax-entry ?\n "> " emacs-lisp-mode-syntax-table)
47: (modify-syntax-entry ?\f "> " emacs-lisp-mode-syntax-table)
48: (modify-syntax-entry ?\; "< " emacs-lisp-mode-syntax-table)
49: (modify-syntax-entry ?` "' " emacs-lisp-mode-syntax-table)
50: (modify-syntax-entry ?' "' " emacs-lisp-mode-syntax-table)
51: (modify-syntax-entry ?, "' " emacs-lisp-mode-syntax-table)
52: (modify-syntax-entry ?. "' " emacs-lisp-mode-syntax-table)
53: (modify-syntax-entry ?# "' " emacs-lisp-mode-syntax-table)
54: (modify-syntax-entry ?\" "\" " emacs-lisp-mode-syntax-table)
55: (modify-syntax-entry ?\\ "\\ " emacs-lisp-mode-syntax-table)
56: (modify-syntax-entry ?\( "() " emacs-lisp-mode-syntax-table)
57: (modify-syntax-entry ?\) ")( " emacs-lisp-mode-syntax-table)
58: (modify-syntax-entry ?\[ "(] " emacs-lisp-mode-syntax-table)
59: (modify-syntax-entry ?\] ")[ " emacs-lisp-mode-syntax-table)))
60:
61: (define-abbrev-table 'lisp-mode-abbrev-table ())
62:
63: (defun lisp-mode-variables (lisp-syntax)
64: (cond (lisp-syntax
65: (if (not lisp-mode-syntax-table)
66: (progn (setq lisp-mode-syntax-table
67: (copy-syntax-table emacs-lisp-mode-syntax-table))
68: (modify-syntax-entry ?\| "\" "
69: lisp-mode-syntax-table)
70: (modify-syntax-entry ?\[ "_ "
71: lisp-mode-syntax-table)
72: (modify-syntax-entry ?\] "_ "
73: lisp-mode-syntax-table)))
74: (set-syntax-table lisp-mode-syntax-table)))
75: (setq local-abbrev-table lisp-mode-abbrev-table)
76: (make-local-variable 'paragraph-start)
77: (setq paragraph-start (concat "^$\\|" page-delimiter))
78: (make-local-variable 'paragraph-separate)
79: (setq paragraph-separate paragraph-start)
80: (make-local-variable 'paragraph-ignore-fill-prefix)
81: (setq paragraph-ignore-fill-prefix t)
82: (make-local-variable 'indent-line-function)
83: (setq indent-line-function 'lisp-indent-line)
84: (make-local-variable 'comment-start)
85: (setq comment-start ";")
86: (make-local-variable 'comment-start-skip)
87: (setq comment-start-skip ";+ *")
88: (make-local-variable 'comment-column)
89: (setq comment-column 40)
90: (make-local-variable 'comment-indent-hook)
91: (setq comment-indent-hook 'lisp-comment-indent))
92:
93: (defun lisp-mode-commands (map)
94: (define-key map "\e\C-q" 'indent-sexp)
95: (define-key map "\177" 'backward-delete-char-untabify)
96: (define-key map "\t" 'lisp-indent-line))
97:
98: (defvar emacs-lisp-mode-map () "")
99: (if emacs-lisp-mode-map
100: ()
101: (setq emacs-lisp-mode-map (make-sparse-keymap))
102: (define-key emacs-lisp-mode-map "\e\C-x" 'eval-defun)
103: (lisp-mode-commands emacs-lisp-mode-map))
104:
105: (defun emacs-lisp-mode ()
106: "Major mode for editing Lisp code to run in Emacs.
107: Commands:
108: Delete converts tabs to spaces as it moves back.
109: Blank lines separate paragraphs. Semicolons start comments.
110: \\{emacs-lisp-mode-map}
111: Entry to this mode calls the value of emacs-lisp-mode-hook
112: if that value is non-nil."
113: (interactive)
114: (kill-all-local-variables)
115: (use-local-map emacs-lisp-mode-map)
116: (set-syntax-table emacs-lisp-mode-syntax-table)
117: (setq major-mode 'emacs-lisp-mode)
118: (setq mode-name "Emacs-Lisp")
119: (lisp-mode-variables nil)
120: (run-hooks 'emacs-lisp-mode-hook))
121:
122: (defvar lisp-mode-map ())
123: (if lisp-mode-map
124: ()
125: (setq lisp-mode-map (make-sparse-keymap))
126: (define-key lisp-mode-map "\e\C-x" 'lisp-send-defun)
127: (define-key lisp-mode-map "\C-c\C-l" 'run-lisp)
128: (lisp-mode-commands lisp-mode-map))
129:
130: (defun lisp-mode ()
131: "Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
132: Commands:
133: Delete converts tabs to spaces as it moves back.
134: Blank lines separate paragraphs. Semicolons start comments.
135: \\{lisp-mode-map}
136: Note that `run-lisp' may be used either to start an inferior Lisp job
137: or to switch back to an existing one.
138:
139: Entry to this mode calls the value of lisp-mode-hook
140: if that value is non-nil."
141: (interactive)
142: (kill-all-local-variables)
143: (use-local-map lisp-mode-map)
144: (setq major-mode 'lisp-mode)
145: (setq mode-name "Lisp")
146: (lisp-mode-variables t)
147: (set-syntax-table lisp-mode-syntax-table)
148: (run-hooks 'lisp-mode-hook))
149:
150: ;; This will do unless shell.el is loaded.
151: (defun lisp-send-defun nil
152: "Send the current defun to the Lisp process made by M-x run-lisp."
153: (interactive)
154: (error "Process lisp does not exist"))
155:
156: (defvar lisp-interaction-mode-map ())
157: (if lisp-interaction-mode-map
158: ()
159: (setq lisp-interaction-mode-map (make-sparse-keymap))
160: (lisp-mode-commands lisp-interaction-mode-map)
161: (define-key lisp-interaction-mode-map "\e\C-x" 'eval-defun)
162: (define-key lisp-interaction-mode-map "\n" 'eval-print-last-sexp))
163:
164: (defun lisp-interaction-mode ()
165: "Major mode for typing and evaluating Lisp forms.
166: Like Lisp mode except that \\[eval-print-last-sexp] evals the Lisp expression
167: before point, and prints its value into the buffer, advancing point.
168:
169: Commands:
170: Delete converts tabs to spaces as it moves back.
171: Paragraphs are separated only by blank lines. Semicolons start comments.
172: \\{lisp-interaction-mode-map}
173: Entry to this mode calls the value of lisp-interaction-mode-hook
174: if that value is non-nil."
175: (interactive)
176: (kill-all-local-variables)
177: (use-local-map lisp-interaction-mode-map)
178: (setq major-mode 'lisp-interaction-mode)
179: (setq mode-name "Lisp Interaction")
180: (lisp-mode-variables t)
181: (run-hooks 'lisp-interaction-mode-hook))
182:
183: (defun eval-print-last-sexp (arg)
184: "Evaluate sexp before point; print value into current buffer."
185: (interactive "P")
186: (eval-region
187: (let ((stab (syntax-table)))
188: (unwind-protect
189: (save-excursion
190: (set-syntax-table emacs-lisp-mode-syntax-table)
191: (forward-sexp -1)
192: (point))
193: (set-syntax-table stab)))
194: (point)
195: (current-buffer)))
196:
197: (defun eval-last-sexp (arg)
198: "Evaluate sexp before point; print value in minibuffer.
199: With argument, print output into current buffer."
200: (interactive "P")
201: (eval-region
202: (let ((stab (syntax-table)))
203: (unwind-protect
204: (save-excursion
205: (set-syntax-table emacs-lisp-mode-syntax-table)
206: (forward-sexp -1)
207: (point))
208: (set-syntax-table stab)))
209: (point)
210: (if arg (current-buffer) t)))
211:
212: (defun eval-defun (arg)
213: "Evaluate defun that point is in or before.
214: Print value in minibuffer.
215: With argument, insert value in current buffer after the defun."
216: (interactive "P")
217: (save-excursion
218: (end-of-defun)
219: (let ((end (point)))
220: (beginning-of-defun)
221: (eval-region (point) end
222: (if arg (current-buffer) t)))))
223:
224: (defun lisp-comment-indent ()
225: (if (looking-at ";;;")
226: (current-column)
227: (if (looking-at ";;")
228: (let ((tem (calculate-lisp-indent)))
229: (if (listp tem) (car tem) tem))
230: (skip-chars-backward " \t")
231: (max (if (bolp) 0 (1+ (current-column)))
232: comment-column))))
233:
234: (defconst lisp-indent-offset nil "")
235: (defconst lisp-indent-hook 'lisp-indent-hook "")
236:
237: (defun lisp-indent-line (&optional whole-exp)
238: "Indent current line as Lisp code.
239: With argument, indent any additional lines of the same expression
240: rigidly along with this one."
241: (interactive "P")
242: (let ((indent (calculate-lisp-indent)) shift-amt beg end
243: (pos (- (point-max) (point))))
244: (beginning-of-line)
245: (setq beg (point))
246: (skip-chars-forward " \t")
247: (if (looking-at ";;;")
248: ;; Don't alter indentation of a ;;; comment line.
249: nil
250: (if (and (looking-at ";") (not (looking-at ";;")))
251: ;; Single-semicolon comment lines should be indented
252: ;; as comment lines, not as code.
253: (progn (indent-for-comment) (forward-char -1))
254: (if (listp indent) (setq indent (car indent)))
255: (setq shift-amt (- indent (current-column)))
256: (if (zerop shift-amt)
257: nil
258: (delete-region beg (point))
259: (indent-to indent)))
260: ;; If initial point was within line's indentation,
261: ;; position after the indentation. Else stay at same point in text.
262: (if (> (- (point-max) pos) (point))
263: (goto-char (- (point-max) pos)))
264: ;; If desired, shift remaining lines of expression the same amount.
265: (and whole-exp (not (zerop shift-amt))
266: (save-excursion
267: (goto-char beg)
268: (forward-sexp 1)
269: (setq end (point))
270: (goto-char beg)
271: (forward-line 1)
272: (setq beg (point))
273: (> end beg))
274: (indent-code-rigidly beg end shift-amt)))))
275:
276: (defun calculate-lisp-indent (&optional parse-start)
277: "Return appropriate indentation for current line as Lisp code.
278: In usual case returns an integer: the column to indent to.
279: Can instead return a list, whose car is the column to indent to.
280: This means that following lines at the same level of indentation
281: should not necessarily be indented the same way.
282: The second element of the list is the buffer position
283: of the start of the containing expression."
284: (save-excursion
285: (beginning-of-line)
286: (let ((indent-point (point))
287: state paren-depth
288: ;; setting this to a number inhibits calling hook
289: (desired-indent nil)
290: (retry t)
291: last-sexp containing-sexp)
292: (if parse-start
293: (goto-char parse-start)
294: (beginning-of-defun))
295: ;; Find outermost containing sexp
296: (while (< (point) indent-point)
297: (setq state (parse-partial-sexp (point) indent-point 0)))
298: ;; Find innermost containing sexp
299: (while (and retry
300: state
301: (> (setq paren-depth (elt state 0)) 0))
302: (setq retry nil)
303: (setq last-sexp (elt state 2))
304: (setq containing-sexp (elt state 1))
305: ;; Position following last unclosed open.
306: (goto-char (1+ containing-sexp))
307: ;; Is there a complete sexp since then?
308: (if (and last-sexp (> last-sexp (point)))
309: ;; Yes, but is there a containing sexp after that?
310: (let ((peek (parse-partial-sexp last-sexp indent-point 0)))
311: (if (setq retry (car (cdr peek))) (setq state peek)))))
312: (if retry
313: nil
314: ;; Innermost containing sexp found
315: (goto-char (1+ containing-sexp))
316: (if (not last-sexp)
317: ;; indent-point immediately follows open paren.
318: ;; Don't call hook.
319: (setq desired-indent (current-column))
320: ;; Find the start of first element of containing sexp.
321: (parse-partial-sexp (point) last-sexp 0 t)
322: (cond ((looking-at "\\s(")
323: ;; First element of containing sexp is a list.
324: ;; Indent under that list.
325: )
326: ((> (save-excursion (forward-line 1) (point))
327: last-sexp)
328: ;; This is the first line to start within the containing sexp.
329: ;; It's almost certainly a function call.
330: (if (= (point) last-sexp)
331: ;; Containing sexp has nothing before this line
332: ;; except the first element. Indent under that element.
333: nil
334: ;; Skip the first element, find start of second (the first
335: ;; argument of the function call) and indent under.
336: (progn (forward-sexp 1)
337: (parse-partial-sexp (point) last-sexp 0 t)))
338: (backward-prefix-chars))
339: (t
340: ;; Indent beneath first sexp on same line as last-sexp.
341: ;; Again, it's almost certainly a function call.
342: (goto-char last-sexp)
343: (beginning-of-line)
344: (parse-partial-sexp (point) last-sexp 0 t)
345: (backward-prefix-chars)))))
346: ;; Point is at the point to indent under unless we are inside a string.
347: ;; Call indentation hook except when overriden by lisp-indent-offset
348: ;; or if the desired indentation has already been computed.
349: (let ((normal-indent (current-column)))
350: (cond ((elt state 3)
351: ;; Inside a string, don't change indentation.
352: (goto-char indent-point)
353: (skip-chars-forward " \t")
354: (current-column))
355: ((and (integerp lisp-indent-offset) containing-sexp)
356: ;; Indent by constant offset
357: (goto-char containing-sexp)
358: (+ normal-indent lisp-indent-offset))
359: (desired-indent)
360: ((and (boundp 'lisp-indent-hook)
361: lisp-indent-hook
362: (not retry))
363: (or (funcall lisp-indent-hook indent-point state)
364: normal-indent))
365: (t
366: normal-indent))))))
367:
368: (defun lisp-indent-hook (indent-point state)
369: (let ((normal-indent (current-column)))
370: (goto-char (1+ (elt state 1)))
371: (parse-partial-sexp (point) last-sexp 0 t)
372: (if (and (elt state 2)
373: (not (looking-at "\\sw\\|\\s_")))
374: ;; car of form doesn't seem to be a a symbol
375: (progn
376: (if (not (> (save-excursion (forward-line 1) (point))
377: last-sexp))
378: (progn (goto-char last-sexp)
379: (beginning-of-line)
380: (parse-partial-sexp (point) last-sexp 0 t)))
381: ;; Indent under the list or under the first sexp on the
382: ;; same line as last-sexp. Note that first thing on that
383: ;; line has to be complete sexp since we are inside the
384: ;; innermost containing sexp.
385: (backward-prefix-chars)
386: (current-column))
387: (let ((function (buffer-substring (point)
388: (progn (forward-sexp 1) (point))))
389: method)
390: (setq method (get (intern-soft function) 'lisp-indent-hook))
391: (cond ((or (eq method 'defun)
392: (and (null method)
393: (> (length function) 3)
394: (string-match "\\`def" function)))
395: (lisp-indent-defform state indent-point))
396: ((integerp method)
397: (lisp-indent-specform method state
398: indent-point normal-indent))
399: (method
400: (funcall method state indent-point)))))))
401:
402: (defconst lisp-body-indent 2 "")
403:
404: (defun lisp-indent-specform (count state indent-point normal-indent)
405: (let ((containing-form-start (elt state 1))
406: (i count)
407: body-indent containing-form-column)
408: ;; Move to the start of containing form, calculate indentation
409: ;; to use for non-distinguished forms (> count), and move past the
410: ;; function symbol. lisp-indent-hook guarantees that there is at
411: ;; least one word or symbol character following open paren of containing
412: ;; form.
413: (goto-char containing-form-start)
414: (setq containing-form-column (current-column))
415: (setq body-indent (+ lisp-body-indent containing-form-column))
416: (forward-char 1)
417: (forward-sexp 1)
418: ;; Now find the start of the last form.
419: (parse-partial-sexp (point) indent-point 1 t)
420: (while (and (< (point) indent-point)
421: (condition-case ()
422: (progn
423: (setq count (1- count))
424: (forward-sexp 1)
425: (parse-partial-sexp (point) indent-point 1 t))
426: (error nil))))
427: ;; Point is sitting on first character of last (or count) sexp.
428: (if (> count 0)
429: ;; A distinguished form. If it is the first or second form use double
430: ;; lisp-body-indent, else normal indent. With lisp-body-indent bound
431: ;; to 2 (the default), this just happens to work the same with if as
432: ;; the older code, but it makes unwind-protect, condition-case,
433: ;; with-output-to-temp-buffer, et. al. much more tasteful. The older,
434: ;; less hacked, behavior can be obtained by replacing below with
435: ;; (list normal-indent containing-form-start).
436: (if (<= (- i count) 1)
437: (list (+ containing-form-column (* 2 lisp-body-indent))
438: containing-form-start)
439: (list normal-indent containing-form-start))
440: ;; A non-distinguished form. Use body-indent if there are no
441: ;; distinguished forms and this is the first undistinguished form,
442: ;; or if this is the first undistinguished form and the preceding
443: ;; distinguished form has indentation at least as great as body-indent.
444: (if (or (and (= i 0) (= count 0))
445: (and (= count 0) (<= body-indent normal-indent)))
446: body-indent
447: normal-indent))))
448:
449: (defun lisp-indent-defform (state indent-point)
450: (goto-char (car (cdr state)))
451: (forward-line 1)
452: (if (> (point) (car (cdr (cdr state))))
453: (progn
454: (goto-char (car (cdr state)))
455: (+ lisp-body-indent (current-column)))))
456:
457:
458: ;; (put 'progn 'lisp-indent-hook 0), say, causes progn to be indented
459: ;; like defun if the first form is placed on the next line, otherwise
460: ;; it is indented like any other form (i.e. forms line up under first).
461:
462: (put 'lambda 'lisp-indent-hook 'defun)
463: (put 'progn 'lisp-indent-hook 0)
464: (put 'prog1 'lisp-indent-hook 1)
465: (put 'save-excursion 'lisp-indent-hook 0)
466: (put 'save-window-excursion 'lisp-indent-hook 0)
467: (put 'save-restriction 'lisp-indent-hook 0)
468: (put 'let 'lisp-indent-hook 1)
469: (put 'let* 'lisp-indent-hook 1)
470: (put 'while 'lisp-indent-hook 1)
471: (put 'if 'lisp-indent-hook 2)
472: (put 'catch 'lisp-indent-hook 1)
473: (put 'condition-case 'lisp-indent-hook 2)
474: (put 'unwind-protect 'lisp-indent-hook 1)
475: (put 'with-output-to-temp-buffer 'lisp-indent-hook 1)
476:
477: (defun indent-sexp ()
478: "Indent each line of the list starting just after point."
479: (interactive)
480: (let ((indent-stack (list nil)) (next-depth 0) bol
481: outer-loop-done inner-loop-done state this-indent)
482: ;; Get error now if we don't have a complete sexp after point.
483: (save-excursion (forward-sexp 1))
484: (save-excursion
485: (setq outer-loop-done nil)
486: (while (not outer-loop-done)
487: (setq last-depth next-depth
488: innerloop-done nil)
489: ;; Parse this line so we can learn the state
490: ;; to indent the next line.
491: ;; This inner loop goes through only once
492: ;; unless a line ends inside a string.
493: (while (and (not innerloop-done)
494: (not (setq outer-loop-done (eobp))))
495: (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
496: nil nil state))
497: (setq next-depth (car state))
498: ;; If the line contains a comment other than the sort
499: ;; that is indented like code,
500: ;; indent it now with indent-for-comment.
501: ;; Comments indented like code are right already.
502: ;; In any case clear the in-comment flag in the state
503: ;; because parse-partial-sexp never sees the newlines.
504: (if (car (nthcdr 4 state))
505: (progn (indent-for-comment)
506: (end-of-line)
507: (setcar (nthcdr 4 state) nil)))
508: ;; If this line ends inside a string,
509: ;; go straight to next line, remaining within the inner loop,
510: ;; and turn off the \-flag.
511: (if (car (nthcdr 3 state))
512: (progn
513: (forward-line 1)
514: (setcar (nthcdr 5 state) nil))
515: (setq innerloop-done t)))
516: (if (setq outer-loop-done (<= next-depth 0))
517: nil
518: (while (> last-depth next-depth)
519: (setq indent-stack (cdr indent-stack)
520: last-depth (1- last-depth)))
521: (while (< last-depth next-depth)
522: (setq indent-stack (cons nil indent-stack)
523: last-depth (1+ last-depth)))
524: ;; Now go to the next line and indent it according
525: ;; to what we learned from parsing the previous one.
526: (forward-line 1)
527: (setq bol (point))
528: (skip-chars-forward " \t")
529: ;; But not if the line is blank, or just a comment
530: ;; (except for double-semi comments; indent them as usual).
531: (if (or (eobp) (looking-at "[;\n]"))
532: nil
533: (if (and (car indent-stack)
534: (>= (car indent-stack) 0))
535: (setq this-indent (car indent-stack))
536: (let ((val (calculate-lisp-indent
537: (if (car indent-stack) (- (car indent-stack))))))
538: (if (integerp val)
539: (setcar indent-stack
540: (setq this-indent val))
541: (setcar indent-stack (- (car (cdr val))))
542: (setq this-indent (car val)))))
543: (if (/= (current-column) this-indent)
544: (progn (delete-region bol (point))
545: (indent-to this-indent)))))))))
546:
547: (defun indent-code-rigidly (start end arg &optional nochange-regexp)
548: "Indent all lines of code, starting in the region, sideways by ARG columns.
549: Does not affect lines starting inside comments or strings,
550: assuming that the start of the region is not inside them.
551: Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
552: The last is a regexp which, if matched at the beginning of a line,
553: means don't indent that line."
554: (interactive "r\np")
555: (let (state)
556: (save-excursion
557: (goto-char end)
558: (setq end (point-marker))
559: (goto-char start)
560: (or (bolp)
561: (setq state (parse-partial-sexp (point)
562: (progn
563: (forward-line 1) (point))
564: nil nil state)))
565: (while (< (point) end)
566: (or (car (nthcdr 3 state))
567: (and nochange-regexp
568: (looking-at nochange-regexp))
569: ;; If line does not start in string, indent it
570: (let ((indent (current-indentation)))
571: (delete-region (point) (progn (skip-chars-forward " \t") (point)))
572: (or (eolp)
573: (indent-to (max 0 (+ indent arg)) 0))))
574: (setq state (parse-partial-sexp (point)
575: (progn
576: (forward-line 1) (point))
577: nil nil state))))))
578:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.