Annotation of pkgsrc/editors/javascript-mode/files/javascript.el, revision 1.1

1.1     ! abs         1: ;;; javascript.el --- Major mode for editing JavaScript source text
        !             2: 
        !             3: ;; Copyright (C) 2008 Free Software Foundation, Inc.
        !             4: 
        !             5: ;; Author: Karl Landstrom <karl.landstrom@brgeight.se>
        !             6: ;; Maintainer: Karl Landstrom <karl.landstrom@brgeight.se>
        !             7: ;; Version: 2.2.1
        !             8: ;; Date: 2008-12-27
        !             9: ;; Keywords: languages, oop
        !            10: 
        !            11: ;; This file is free software; you can redistribute it and/or modify
        !            12: ;; it under the terms of the GNU General Public License as published by
        !            13: ;; the Free Software Foundation; either version 2, or (at your option)
        !            14: ;; any later version.
        !            15: 
        !            16: ;; This file is distributed in the hope that it will be useful,
        !            17: ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            18: ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            19: ;; GNU General Public License for more details.
        !            20: 
        !            21: ;; You should have received a copy of the GNU General Public License
        !            22: ;; along with GNU Emacs; see the file COPYING.  If not, write to
        !            23: ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
        !            24: ;; Boston, MA 02111-1307, USA.
        !            25: 
        !            26: ;;; Commentary:
        !            27: ;;
        !            28: ;; The main features of this JavaScript mode are syntactic
        !            29: ;; highlighting (enabled with `font-lock-mode' or
        !            30: ;; `global-font-lock-mode'), automatic indentation and filling of
        !            31: ;; comments.
        !            32: ;;
        !            33: ;; This package has (only) been tested with GNU Emacs 21.4 (the latest
        !            34: ;; stable release).
        !            35: ;;
        !            36: ;; Installation:
        !            37: ;;
        !            38: ;; Put this file in a directory where Emacs can find it (`C-h v
        !            39: ;; load-path' for more info). Then add the following lines to your
        !            40: ;; Emacs initialization file:
        !            41: ;; 
        !            42: ;;    (add-to-list 'auto-mode-alist '("\\.js\\'" . javascript-mode))
        !            43: ;;    (autoload 'javascript-mode "javascript" nil t)
        !            44: ;;    
        !            45: ;; General Remarks:
        !            46: ;; 
        !            47: ;; This mode assumes that block comments are not nested inside block
        !            48: ;; comments and that strings do not contain line breaks.
        !            49: ;; 
        !            50: ;; Exported names start with "javascript-" whereas private names start
        !            51: ;; with "js-".
        !            52: ;; 
        !            53: ;; Changes:
        !            54: ;;
        !            55: ;; See javascript.el.changelog.
        !            56: 
        !            57: ;;; Code:
        !            58: 
        !            59: (require 'cc-mode)
        !            60: (require 'font-lock)
        !            61: (require 'newcomment)
        !            62: 
        !            63: (defgroup javascript nil 
        !            64:   "Customization variables for `javascript-mode'."
        !            65:   :tag "JavaScript"
        !            66:   :group 'languages)
        !            67: 
        !            68: (defcustom javascript-indent-level 4
        !            69:   "Number of spaces for each indentation step."
        !            70:   :type 'integer
        !            71:   :group 'javascript)
        !            72: 
        !            73: (defcustom javascript-expr-indent-offset 0
        !            74:   "Number of additional spaces used for indentation of continued
        !            75: expressions. The value must be no less than minus
        !            76: `javascript-indent-level'."
        !            77:   :type 'integer
        !            78:   :group 'javascript)
        !            79: 
        !            80: (defcustom javascript-auto-indent-flag t
        !            81:   "Automatic indentation with punctuation characters. If non-nil, the
        !            82: current line is indented when certain punctuations are inserted."
        !            83:   :type 'boolean
        !            84:   :group 'javascript)
        !            85: 
        !            86: 
        !            87: ;; --- Keymap ---
        !            88: 
        !            89: (defvar javascript-mode-map nil 
        !            90:   "Keymap used in JavaScript mode.")
        !            91: 
        !            92: (unless javascript-mode-map 
        !            93:   (setq javascript-mode-map (make-sparse-keymap)))
        !            94: 
        !            95: (when javascript-auto-indent-flag
        !            96:   (mapc (lambda (key) 
        !            97:          (define-key javascript-mode-map key 'javascript-insert-and-indent))
        !            98:        '("{" "}" "(" ")" ":" ";" ",")))
        !            99: 
        !           100: (defun javascript-insert-and-indent (key)
        !           101:   "Run command bound to key and indent current line. Runs the command
        !           102: bound to KEY in the global keymap and indents the current line."
        !           103:   (interactive (list (this-command-keys)))
        !           104:   (call-interactively (lookup-key (current-global-map) key))
        !           105:   (indent-according-to-mode))
        !           106: 
        !           107: 
        !           108: ;; --- Syntax Table And Parsing ---
        !           109: 
        !           110: (defvar javascript-mode-syntax-table
        !           111:   (let ((table (make-syntax-table)))
        !           112:     (c-populate-syntax-table table)
        !           113:     (modify-syntax-entry ?$ "_" table)
        !           114:     table)
        !           115:   "Syntax table used in JavaScript mode.")
        !           116: 
        !           117: (defvar js-ident-as-word-syntax-table
        !           118:   (let ((table (copy-syntax-table javascript-mode-syntax-table)))
        !           119:     (modify-syntax-entry ?$ "w" table)
        !           120:     (modify-syntax-entry ?_ "w" table)
        !           121:     table)
        !           122:   "Alternative syntax table used internally to simplify detection
        !           123:   of identifiers and keywords and its boundaries.")
        !           124: 
        !           125: 
        !           126: (defun js-re-search-forward-inner (regexp &optional bound count)
        !           127:   "Auxiliary function for `js-re-search-forward'."
        !           128:   (let ((parse)
        !           129:         (saved-point (point-min)))
        !           130:     (while (> count 0)
        !           131:       (re-search-forward regexp bound)
        !           132:       (setq parse (parse-partial-sexp saved-point (point)))
        !           133:       (cond ((nth 3 parse)
        !           134:              (re-search-forward 
        !           135:               (concat "\\([^\\]\\|^\\)" (string (nth 3 parse))) 
        !           136:               (save-excursion (end-of-line) (point)) t))
        !           137:             ((nth 7 parse)
        !           138:              (forward-line))
        !           139:             ((or (nth 4 parse)
        !           140:                  (and (eq (char-before) ?\/) (eq (char-after) ?\*)))
        !           141:              (re-search-forward "\\*/"))
        !           142:             (t
        !           143:              (setq count (1- count))))
        !           144:       (setq saved-point (point))))
        !           145:   (point))
        !           146: 
        !           147: 
        !           148: (defun js-re-search-forward (regexp &optional bound noerror count)
        !           149:   "Search forward but ignore strings and comments. Invokes
        !           150: `re-search-forward' but treats the buffer as if strings and
        !           151: comments have been removed."
        !           152:   (let ((saved-point (point))
        !           153:         (search-expr 
        !           154:          (cond ((null count)
        !           155:                 '(js-re-search-forward-inner regexp bound 1))
        !           156:                ((< count 0)
        !           157:                 '(js-re-search-backward-inner regexp bound (- count)))
        !           158:                ((> count 0)
        !           159:                 '(js-re-search-forward-inner regexp bound count)))))
        !           160:     (condition-case err
        !           161:         (eval search-expr)
        !           162:       (search-failed
        !           163:        (goto-char saved-point)
        !           164:        (unless noerror
        !           165:          (error (error-message-string err)))))))
        !           166: 
        !           167: 
        !           168: (defun js-re-search-backward-inner (regexp &optional bound count)
        !           169:   "Auxiliary function for `js-re-search-backward'."
        !           170:   (let ((parse)
        !           171:         (saved-point (point-min)))
        !           172:     (while (> count 0)
        !           173:       (re-search-backward regexp bound)
        !           174:       (when (and (> (point) (point-min))
        !           175:                  (save-excursion (backward-char) (looking-at "/[/*]")))
        !           176:         (backward-char))
        !           177:       (setq parse (parse-partial-sexp saved-point (point)))
        !           178:       (cond ((nth 3 parse)
        !           179:              (re-search-backward
        !           180:               (concat "\\([^\\]\\|^\\)" (string (nth 3 parse))) 
        !           181:               (save-excursion (beginning-of-line) (point)) t))
        !           182:             ((nth 7 parse) 
        !           183:              (goto-char (nth 8 parse)))
        !           184:             ((or (nth 4 parse)
        !           185:                  (and (eq (char-before) ?/) (eq (char-after) ?*)))
        !           186:              (re-search-backward "/\\*"))
        !           187:             (t
        !           188:              (setq count (1- count))))))
        !           189:   (point))
        !           190: 
        !           191: 
        !           192: (defun js-re-search-backward (regexp &optional bound noerror count)
        !           193:   "Search backward but ignore strings and comments. Invokes
        !           194: `re-search-backward' but treats the buffer as if strings and
        !           195: comments have been removed."
        !           196:   (let ((saved-point (point))
        !           197:         (search-expr 
        !           198:          (cond ((null count)
        !           199:                 '(js-re-search-backward-inner regexp bound 1))
        !           200:                ((< count 0)
        !           201:                 '(js-re-search-forward-inner regexp bound (- count)))
        !           202:                ((> count 0)
        !           203:                 '(js-re-search-backward-inner regexp bound count)))))
        !           204:     (condition-case err
        !           205:         (eval search-expr)
        !           206:       (search-failed
        !           207:        (goto-char saved-point)
        !           208:        (unless noerror
        !           209:          (error (error-message-string err)))))))
        !           210: 
        !           211: 
        !           212: ;; --- Font Lock ---
        !           213: 
        !           214: (defun js-inside-param-list-p ()
        !           215:   "Return non-nil if point is inside a function parameter list."
        !           216:   (condition-case err
        !           217:       (save-excursion
        !           218:        (up-list -1)
        !           219:        (and (looking-at "(")
        !           220:             (progn (backward-word 1)
        !           221:                    (or (looking-at "function")
        !           222:                        (progn (backward-word 1) (looking-at "function"))))))
        !           223:     (error nil)))
        !           224: 
        !           225: 
        !           226: (defconst js-function-heading-1-re 
        !           227:   "^[ \t]*function[ \t]+\\(\\w+\\)"
        !           228:   "Regular expression matching the start of a function header.")
        !           229: 
        !           230: (defconst js-function-heading-2-re 
        !           231:   "^[ \t]*\\(\\w+\\)[ \t]*:[ \t]*function\\>"
        !           232:   "Regular expression matching the start of a function entry in
        !           233:   an associative array.")
        !           234: 
        !           235: (defconst js-keyword-re
        !           236:   (regexp-opt '("abstract" "break" "case" "catch" "class" "const"
        !           237:                 "continue" "debugger" "default" "delete" "do" "else" 
        !           238:                 "enum" "export" "extends" "final" "finally" "for" 
        !           239:                 "function" "goto" "if" "implements" "import" "in" 
        !           240:                 "instanceof" "interface" "native" "new" "package" 
        !           241:                 "private" "protected" "public" "return" "static" 
        !           242:                 "super" "switch" "synchronized" "this" "throw" 
        !           243:                 "throws" "transient" "try" "typeof" "var" "void" 
        !           244:                 "volatile" "while" "with") 'words)
        !           245:   "Regular expression matching any JavaScript keyword.")
        !           246: 
        !           247: (defconst js-basic-type-re
        !           248:   (regexp-opt '("boolean" "byte" "char" "double" "float" "int" "long"
        !           249:                 "short" "void") 'words)
        !           250:   "Regular expression matching any predefined type in JavaScript.")
        !           251: 
        !           252: (defconst js-constant-re
        !           253:   (regexp-opt '("false" "null" "true") 'words)
        !           254:   "Regular expression matching any future reserved words in JavaScript.")
        !           255: 
        !           256: 
        !           257: (defconst js-font-lock-keywords-1
        !           258:   (list 
        !           259:    "\\<import\\>" 
        !           260:    (list js-function-heading-1-re 1 font-lock-function-name-face)
        !           261:    (list js-function-heading-2-re 1 font-lock-function-name-face))
        !           262:   "Level one font lock.")
        !           263: 
        !           264: (defconst js-font-lock-keywords-2
        !           265:   (append js-font-lock-keywords-1
        !           266:           (list (list js-keyword-re 1 font-lock-keyword-face)
        !           267:                 (cons js-basic-type-re font-lock-type-face)
        !           268:                 (cons js-constant-re font-lock-constant-face)))
        !           269:   "Level two font lock.")
        !           270: 
        !           271: 
        !           272: ;; Limitations with variable declarations: There seems to be no
        !           273: ;; sensible way to highlight variables occuring after an initialized
        !           274: ;; variable in a variable list. For instance, in
        !           275: ;;
        !           276: ;;    var x, y = f(a, b), z
        !           277: ;;
        !           278: ;; z will not be highlighted. Also, in variable declaration lists
        !           279: ;; spanning several lines only variables on the first line will be
        !           280: ;; highlighted. To get correct fontification, every line with variable
        !           281: ;; declarations must contain a `var' keyword.
        !           282: 
        !           283: (defconst js-font-lock-keywords-3
        !           284:   (append 
        !           285:    js-font-lock-keywords-2
        !           286:    (list 
        !           287:     
        !           288:     ;; variable declarations
        !           289:     (list
        !           290:      (concat "\\<\\(const\\|var\\)\\>\\|" js-basic-type-re)
        !           291:      (list "\\(\\w+\\)[ \t]*\\([=;].*\\|\\<in\\>.*\\|,\\|/[/*]\\|$\\)"
        !           292:           nil
        !           293:           nil
        !           294:           '(1 font-lock-variable-name-face)))
        !           295: 
        !           296:     ;; formal parameters
        !           297:     (list
        !           298:      "\\<function\\>\\([ \t]+\\w+\\)?[ \t]*([ \t]*\\w"
        !           299:      (list "\\(\\w+\\)\\([ \t]*).*\\)?"
        !           300:           '(backward-char)
        !           301:           '(end-of-line)
        !           302:           '(1 font-lock-variable-name-face)))
        !           303:     
        !           304:     ;; continued formal parameter list
        !           305:     (list
        !           306:      "^[ \t]*\\w+[ \t]*[,)]"
        !           307:      (list "\\w+"
        !           308:           '(if (save-excursion (backward-char) (js-inside-param-list-p))
        !           309:                (backward-word 1) 
        !           310:              (end-of-line))
        !           311:           '(end-of-line)
        !           312:           '(0 font-lock-variable-name-face)))
        !           313: ))
        !           314:   "Level three font lock.")
        !           315: 
        !           316: (defconst js-font-lock-keywords
        !           317:   '(js-font-lock-keywords-3 js-font-lock-keywords-1 js-font-lock-keywords-2
        !           318:                             js-font-lock-keywords-3)
        !           319:   "See `font-lock-keywords'.")
        !           320: 
        !           321: (defconst js-font-lock-syntactic-keywords
        !           322:   '(("[=(][ \t\n]*\\(/\\)[^/*]\\(.*?[^\\]\\)?\\(/\\)" (1 '(7)) (3 '(7))))
        !           323:   "Highlighting of regular expressions. See also the variable
        !           324:   `font-lock-keywords'.")
        !           325: 
        !           326: 
        !           327: ;; --- Indentation ---
        !           328: 
        !           329: (defconst js-possibly-braceless-keyword-re
        !           330:   (regexp-opt
        !           331:    '("catch" "do" "else" "finally" "for" "if" "try" "while" "with")
        !           332:    'words)
        !           333:   "Regular expression matching keywords that are optionally
        !           334:   followed by an opening brace.")
        !           335: 
        !           336: (defconst js-indent-operator-re
        !           337:   (concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|"
        !           338:           (regexp-opt '("in" "instanceof") 'words))
        !           339:   "Regular expression matching operators that affect indentation
        !           340:   of continued expressions.")
        !           341: 
        !           342: 
        !           343: (defun js-looking-at-operator-p ()
        !           344:   "Return non-nil if text after point is an operator (that is not
        !           345: a comma)."
        !           346:   (save-match-data
        !           347:     (and (looking-at js-indent-operator-re)
        !           348:          (or (not (looking-at ":"))
        !           349:              (save-excursion
        !           350:                (and (js-re-search-backward "[?:{]\\|\\<case\\>" nil t)
        !           351:                     (looking-at "?")))))))
        !           352: 
        !           353: 
        !           354: (defun js-continued-expression-p ()
        !           355:   "Returns non-nil if the current line continues an expression."
        !           356:   (save-excursion
        !           357:     (back-to-indentation)
        !           358:     (or (js-looking-at-operator-p)
        !           359:         (and (js-re-search-backward "\n" nil t)
        !           360:             (progn 
        !           361:               (skip-chars-backward " \t")
        !           362:               (backward-char)
        !           363:               (and (> (point) (point-min))
        !           364:                     (save-excursion (backward-char) (not (looking-at "[/*]/")))
        !           365:                     (js-looking-at-operator-p)
        !           366:                    (and (progn (backward-char)
        !           367:                                (not (looking-at "++\\|--\\|/[/*]"))))))))))
        !           368: 
        !           369: 
        !           370: (defun js-end-of-do-while-loop-p ()
        !           371:   "Returns non-nil if word after point is `while' of a do-while
        !           372: statement, else returns nil. A braceless do-while statement
        !           373: spanning several lines requires that the start of the loop is
        !           374: indented to the same column as the current line."
        !           375:   (interactive)
        !           376:   (save-excursion
        !           377:     (save-match-data
        !           378:       (when (looking-at "\\s-*\\<while\\>")
        !           379:        (if (save-excursion 
        !           380:              (skip-chars-backward "[ \t\n]*}")
        !           381:              (looking-at "[ \t\n]*}"))
        !           382:            (save-excursion 
        !           383:              (backward-list) (backward-word 1) (looking-at "\\<do\\>"))
        !           384:          (js-re-search-backward "\\<do\\>" (point-at-bol) t)
        !           385:          (or (looking-at "\\<do\\>")
        !           386:              (let ((saved-indent (current-indentation)))
        !           387:                (while (and (js-re-search-backward "^[ \t]*\\<" nil t)
        !           388:                            (/= (current-indentation) saved-indent)))
        !           389:                (and (looking-at "[ \t]*\\<do\\>")
        !           390:                     (not (js-re-search-forward 
        !           391:                           "\\<while\\>" (point-at-eol) t))
        !           392:                     (= (current-indentation) saved-indent)))))))))
        !           393: 
        !           394: 
        !           395: (defun js-ctrl-statement-indentation ()
        !           396:   "Returns the proper indentation of the current line if it
        !           397: starts the body of a control statement without braces, else
        !           398: returns nil."
        !           399:   (save-excursion
        !           400:     (back-to-indentation)
        !           401:     (when (save-excursion
        !           402:             (and (not (looking-at "[{]"))
        !           403:                  (progn
        !           404:                    (js-re-search-backward "[[:graph:]]" nil t)
        !           405:                    (forward-char)
        !           406:                    (when (= (char-before) ?\)) (backward-list))
        !           407:                    (skip-syntax-backward " ")
        !           408:                    (skip-syntax-backward "w")
        !           409:                    (looking-at js-possibly-braceless-keyword-re))
        !           410:                  (not (js-end-of-do-while-loop-p))))
        !           411:       (save-excursion
        !           412:         (goto-char (match-beginning 0))
        !           413:         (+ (current-indentation) javascript-indent-level)))))
        !           414: 
        !           415: 
        !           416: (defun js-proper-indentation (parse-status)
        !           417:   "Return the proper indentation for the current line."
        !           418:   (save-excursion
        !           419:     (back-to-indentation)
        !           420:     (let ((ctrl-stmt-indent (js-ctrl-statement-indentation))
        !           421:           (same-indent-p (looking-at "[]})]\\|\\<case\\>\\|\\<default\\>"))
        !           422:           (continued-expr-p (js-continued-expression-p)))
        !           423:       (cond (ctrl-stmt-indent)
        !           424:             ((nth 1 parse-status)
        !           425:              (goto-char (nth 1 parse-status))
        !           426:              (if (looking-at "[({[][ \t]*\\(/[/*]\\|$\\)")
        !           427:                  (progn
        !           428:                    (skip-syntax-backward " ")
        !           429:                    (when (= (char-before) ?\)) (backward-list))
        !           430:                    (back-to-indentation)
        !           431:                    (cond (same-indent-p
        !           432:                           (current-column))
        !           433:                          (continued-expr-p
        !           434:                           (+ (current-column) (* 2 javascript-indent-level)
        !           435:                              javascript-expr-indent-offset))
        !           436:                          (t
        !           437:                           (+ (current-column) javascript-indent-level))))
        !           438:                (unless same-indent-p
        !           439:                  (forward-char)
        !           440:                  (skip-chars-forward " \t"))
        !           441:                (current-column)))
        !           442:            (continued-expr-p (+ javascript-indent-level 
        !           443:                                  javascript-expr-indent-offset))
        !           444:             (t 0)))))
        !           445: 
        !           446: 
        !           447: (defun javascript-indent-line ()
        !           448:   "Indent the current line as JavaScript source text."
        !           449:   (interactive)
        !           450:   (with-syntax-table js-ident-as-word-syntax-table
        !           451:     (let ((parse-status 
        !           452:           (save-excursion (parse-partial-sexp (point-min) (point-at-bol))))
        !           453:          (offset (- (current-column) (current-indentation))))
        !           454:       (when (not (nth 8 parse-status))
        !           455:        (indent-line-to (js-proper-indentation parse-status))
        !           456:        (when (> offset 0) (forward-char offset))))))
        !           457:   
        !           458: 
        !           459: ;; --- Filling ---
        !           460: 
        !           461: ;; FIXME: It should be possible to use the more sofisticated function
        !           462: ;; `c-fill-paragraph' in `cc-cmds.el' instead. However, just setting
        !           463: ;; `fill-paragraph-function' to `c-fill-paragraph' does not work;
        !           464: ;; inside `c-fill-paragraph', `fill-paragraph-function' evaluates to
        !           465: ;; nil!?
        !           466: 
        !           467: (defun js-backward-paragraph ()
        !           468:   "Move backward to start of paragraph. Postcondition: Point is at
        !           469: beginning of buffer or the previous line contains only whitespace."
        !           470:   (forward-line -1)
        !           471:   (while (not (or (bobp) (looking-at "^[ \t]*$")))
        !           472:     (forward-line -1))
        !           473:   (when (not (bobp)) (forward-line 1)))
        !           474: 
        !           475: 
        !           476: (defun js-forward-paragraph ()
        !           477:   "Move forward to end of paragraph. Postcondition: Point is at
        !           478: end of buffer or the next line contains only whitespace."
        !           479:   (forward-line 1)
        !           480:   (while (not (or (eobp) (looking-at "^[ \t]*$")))
        !           481:     (forward-line 1))
        !           482:   (when (not (eobp)) (backward-char 1)))
        !           483:  
        !           484: 
        !           485: (defun js-fill-block-comment-paragraph (parse-status justify)
        !           486:   "Fill current paragraph as a block comment. PARSE-STATUS is the
        !           487: result of `parse-partial-regexp' from beginning of buffer to
        !           488: point. JUSTIFY has the same meaning as in `fill-paragraph'."
        !           489:   (let ((offset (save-excursion 
        !           490:                   (goto-char (nth 8 parse-status)) (current-indentation))))
        !           491:     (save-excursion
        !           492:       (save-restriction
        !           493:         (narrow-to-region (save-excursion 
        !           494:                             (goto-char (nth 8 parse-status)) (point-at-bol))
        !           495:                           (save-excursion 
        !           496:                            (goto-char (nth 8 parse-status))
        !           497:                            (re-search-forward "*/")))
        !           498:         (narrow-to-region (save-excursion 
        !           499:                             (js-backward-paragraph)
        !           500:                             (when (looking-at "^[ \t]*$") (forward-line 1))
        !           501:                             (point))
        !           502:                           (save-excursion 
        !           503:                             (js-forward-paragraph) 
        !           504:                             (when (looking-at "^[ \t]*$") (backward-char))
        !           505:                             (point)))
        !           506:         (goto-char (point-min))
        !           507:         (while (not (eobp))
        !           508:           (delete-horizontal-space)
        !           509:           (forward-line 1))
        !           510:         (let ((fill-column (- fill-column offset))
        !           511:               (fill-paragraph-function nil))
        !           512:           (fill-paragraph justify))
        !           513: 
        !           514:         ;; In Emacs 21.4 as opposed to CVS Emacs 22,
        !           515:         ;; `fill-paragraph' seems toadd a newline at the end of the
        !           516:         ;; paragraph. Remove it!
        !           517:         (goto-char (point-max))
        !           518:         (when (looking-at "^$") (backward-delete-char 1))
        !           519: 
        !           520:         (goto-char (point-min))
        !           521:         (while (not (eobp))
        !           522:           (indent-to offset)
        !           523:           (forward-line 1))))))
        !           524: 
        !           525: 
        !           526: (defun js-sline-comment-par-start ()
        !           527:   "Return point at the beginning of the line where the current
        !           528: single-line comment paragraph starts."
        !           529:   (save-excursion
        !           530:     (beginning-of-line)
        !           531:     (while (and (not (bobp)) 
        !           532:                 (looking-at "^[ \t]*//[ \t]*[[:graph:]]"))
        !           533:       (forward-line -1))
        !           534:     (unless (bobp) (forward-line 1))
        !           535:     (point)))
        !           536: 
        !           537: 
        !           538: (defun js-sline-comment-par-end ()
        !           539:   "Return point at end of current single-line comment paragraph."
        !           540:   (save-excursion
        !           541:     (beginning-of-line)
        !           542:     (while (and (not (eobp)) 
        !           543:                 (looking-at "^[ \t]*//[ \t]*[[:graph:]]"))
        !           544:       (forward-line 1))
        !           545:     (unless (bobp) (backward-char))
        !           546:     (point)))
        !           547: 
        !           548: 
        !           549: (defun js-sline-comment-offset (line)
        !           550:   "Return the column at the start of the current single-line
        !           551: comment paragraph."
        !           552:   (save-excursion 
        !           553:     (goto-line line)
        !           554:     (re-search-forward "//" (point-at-eol))
        !           555:     (goto-char (match-beginning 0))
        !           556:     (current-column)))
        !           557: 
        !           558: 
        !           559: (defun js-sline-comment-text-offset (line)
        !           560:   "Return the column at the start of the text of the current
        !           561: single-line comment paragraph."
        !           562:   (save-excursion
        !           563:     (goto-line line)
        !           564:     (re-search-forward "//[ \t]*" (point-at-eol))
        !           565:     (current-column)))
        !           566: 
        !           567: 
        !           568: (defun js-at-empty-sline-comment-p ()
        !           569:   "Return non-nil if inside an empty single-line comment."
        !           570:   (and (save-excursion
        !           571:          (beginning-of-line)
        !           572:          (not (looking-at "^.*//.*[[:graph:]]")))
        !           573:        (save-excursion
        !           574:          (re-search-backward "//" (point-at-bol) t))))
        !           575: 
        !           576:          
        !           577: (defun js-fill-sline-comments (parse-status justify)
        !           578:   "Fill current paragraph as a sequence of single-line comments.
        !           579: PARSE-STATUS is the result of `parse-partial-regexp' from
        !           580: beginning of buffer to point. JUSTIFY has the same meaning as in
        !           581: `fill-paragraph'."
        !           582:   (when (not (js-at-empty-sline-comment-p))
        !           583:     (let* ((start (js-sline-comment-par-start))
        !           584:            (start-line (1+ (count-lines (point-min) start)))
        !           585:            (end (js-sline-comment-par-end))
        !           586:            (offset (js-sline-comment-offset start-line))
        !           587:            (text-offset (js-sline-comment-text-offset start-line)))
        !           588:       (save-excursion
        !           589:         (save-restriction
        !           590:           (narrow-to-region start end)
        !           591:           (goto-char (point-min))
        !           592:           (while (re-search-forward "^[ \t]*//[ \t]*" nil t)
        !           593:             (replace-match "")
        !           594:             (forward-line 1))
        !           595:           (let ((fill-paragraph-function nil)
        !           596:                 (fill-column (- fill-column text-offset)))
        !           597:             (fill-paragraph justify))
        !           598: 
        !           599:           ;; In Emacs 21.4 as opposed to CVS Emacs 22,
        !           600:           ;; `fill-paragraph' seems to add a newline at the end of the
        !           601:           ;; paragraph. Remove it!
        !           602:           (goto-char (point-max))
        !           603:           (when (looking-at "^$") (backward-delete-char 1))
        !           604: 
        !           605:           (goto-char (point-min))
        !           606:           (while (not (eobp))
        !           607:             (indent-to offset)
        !           608:             (insert "//")
        !           609:             (indent-to text-offset)
        !           610:             (forward-line 1)))))))
        !           611:   
        !           612: 
        !           613: (defun js-trailing-comment-p (parse-status)
        !           614:   "Return non-nil if inside a trailing comment. PARSE-STATUS is
        !           615: the result of `parse-partial-regexp' from beginning of buffer to
        !           616: point."
        !           617:   (save-excursion 
        !           618:     (when (nth 4 parse-status)
        !           619:       (goto-char (nth 8 parse-status))
        !           620:       (skip-chars-backward " \t")
        !           621:       (not (bolp)))))
        !           622: 
        !           623: 
        !           624: (defun js-block-comment-p (parse-status)
        !           625:   "Return non-nil if inside a block comment. PARSE-STATUS is the
        !           626: result of `parse-partial-regexp' from beginning of buffer to
        !           627: point."
        !           628:   (save-excursion 
        !           629:     (save-match-data
        !           630:       (when (nth 4 parse-status)
        !           631:         (goto-char (nth 8 parse-status))
        !           632:         (looking-at "/\\*")))))
        !           633: 
        !           634: 
        !           635: (defun javascript-fill-paragraph (&optional justify)
        !           636:   "If inside a comment, fill the current comment paragraph.
        !           637: Trailing comments are ignored."
        !           638:   (interactive)
        !           639:   (let ((parse-status (parse-partial-sexp (point-min) (point))))
        !           640:     (when (and (nth 4 parse-status) 
        !           641:                (not (js-trailing-comment-p parse-status)))
        !           642:       (if (js-block-comment-p parse-status)
        !           643:           (js-fill-block-comment-paragraph parse-status justify)
        !           644:         (js-fill-sline-comments parse-status justify))))
        !           645:   t)
        !           646: 
        !           647: 
        !           648: ;; --- Imenu ---
        !           649: 
        !           650: (defconst js-imenu-generic-expression 
        !           651:   (list
        !           652:    (list
        !           653:     nil 
        !           654:     "function\\s-+\\(\\(\\w\\|\\s_\\)+\\)\\s-*("
        !           655:     1))
        !           656:   "Regular expression matching top level procedures. Used by imenu.")
        !           657: 
        !           658: 
        !           659: ;; --- Main Function ---
        !           660: 
        !           661: ;;;###autoload
        !           662: (defun javascript-mode ()
        !           663:   "Major mode for editing JavaScript source text.
        !           664: 
        !           665: Key bindings:
        !           666: 
        !           667: \\{javascript-mode-map}"
        !           668:   (interactive)
        !           669:   (kill-all-local-variables)
        !           670: 
        !           671:   (use-local-map javascript-mode-map)
        !           672:   (set-syntax-table javascript-mode-syntax-table)
        !           673:   (set (make-local-variable 'indent-line-function) 'javascript-indent-line)
        !           674: 
        !           675:   (set (make-local-variable 'font-lock-defaults) 
        !           676:        (list js-font-lock-keywords 
        !           677:             nil nil '((?$ . "w") (?_ . "w")) nil
        !           678:             '(font-lock-syntactic-keywords . js-font-lock-syntactic-keywords)))
        !           679: 
        !           680:   (set (make-local-variable 'parse-sexp-ignore-comments) t) 
        !           681: 
        !           682:   ;; Comments
        !           683:   (set (make-local-variable 'comment-start) "// ")
        !           684:   (set (make-local-variable 'comment-end) "")
        !           685:   (set (make-local-variable 'fill-paragraph-function) 
        !           686:        'javascript-fill-paragraph)
        !           687: 
        !           688:   ;; Imenu
        !           689:   (setq imenu-case-fold-search nil)
        !           690:   (set (make-local-variable 'imenu-generic-expression)
        !           691:        js-imenu-generic-expression)
        !           692: 
        !           693:   (setq major-mode 'javascript-mode)
        !           694:   (setq mode-name "JavaScript")
        !           695:   (run-hooks 'javascript-mode-hook))
        !           696: 
        !           697: 
        !           698: (provide 'javascript-mode)
        !           699: ;;; javascript.el ends here

CVSweb <webmaster@jp.NetBSD.org>