Annotation of pkgsrc/editors/javascript-mode/files/javascript.el, revision 1.1.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>