Skip to content
Newer
Older
100755 699 lines (587 sloc) 23.9 KB
df01782 @candera Initial commit
authored Mar 27, 2011
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
Something went wrong with that request. Please try again.