1 ;;; js.el --- Major mode for editing JavaScript
3 ;; Copyright (C) 2008-2011 Free Software Foundation, Inc.
5 ;; Author: Karl Landstrom <karl.landstrom@brgeight.se>
6 ;; Daniel Colascione <dan.colascione@gmail.com>
7 ;; Maintainer: Daniel Colascione <dan.colascione@gmail.com>
10 ;; Keywords: languages, javascript
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
29 ;; This is based on Karl Landstrom's barebones javascript-mode. This
30 ;; is much more robust and works with cc-mode's comment filling
33 ;; The main features of this JavaScript mode are syntactic
34 ;; highlighting (enabled with `font-lock-mode' or
35 ;; `global-font-lock-mode'), automatic indentation and filling of
36 ;; comments, C preprocessor fontification, and MozRepl integration.
40 ;; XXX: This mode assumes that block comments are not nested inside block
43 ;; Exported names start with "js-"; private names start with
51 (require 'thingatpt) ; forward-symbol etc
61 (defvar inferior-moz-buffer)
62 (defvar moz-repl-name)
64 (declare-function ido-mode "ido")
65 (declare-function inferior-moz-process "ext:mozrepl" ())
69 (defconst js--name-start-re "[a-zA-Z_$]"
70 "Regexp matching the start of a JavaScript identifier, without grouping.")
72 (defconst js--stmt-delim-chars "^;{}?:")
74 (defconst js--name-re (concat js--name-start-re
75 "\\(?:\\s_\\|\\sw\\)*")
76 "Regexp matching a JavaScript identifier, without grouping.")
78 (defconst js--objfield-re (concat js--name-re ":")
79 "Regexp matching the start of a JavaScript object field.")
81 (defconst js--dotted-name-re
82 (concat js--name-re "\\(?:\\." js--name-re "\\)*")
83 "Regexp matching a dot-separated sequence of JavaScript names.")
85 (defconst js--cpp-name-re js--name-re
86 "Regexp matching a C preprocessor name.")
88 (defconst js--opt-cpp-start "^\\s-*#\\s-*\\([[:alnum:]]+\\)"
89 "Regexp matching the prefix of a cpp directive.
90 This includes the directive name, or nil in languages without
91 preprocessor support. The first submatch surrounds the directive
94 (defconst js--plain-method-re
95 (concat "^\\s-*?\\(" js--dotted-name-re "\\)\\.prototype"
96 "\\.\\(" js--name-re "\\)\\s-*?=\\s-*?\\(function\\)\\_>")
97 "Regexp matching an explicit JavaScript prototype \"method\" declaration.
98 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
99 and group 3 is the 'function' keyword.")
101 (defconst js--plain-class-re
102 (concat "^\\s-*\\(" js--dotted-name-re "\\)\\.prototype"
104 "Regexp matching a JavaScript explicit prototype \"class\" declaration.
105 An example of this is \"Class.prototype = { method1: ...}\".")
107 ;; var NewClass = BaseClass.extend(
108 (defconst js--mp-class-decl-re
109 (concat "^\\s-*var\\s-+"
110 "\\(" js--name-re "\\)"
112 "\\(" js--dotted-name-re
113 "\\)\\.extend\\(?:Final\\)?\\s-*(\\s-*{?\\s-*$"))
115 ;; var NewClass = Class.create()
116 (defconst js--prototype-obsolete-class-decl-re
117 (concat "^\\s-*\\(?:var\\s-+\\)?"
118 "\\(" js--dotted-name-re "\\)"
119 "\\s-*=\\s-*Class\\.create()"))
121 (defconst js--prototype-objextend-class-decl-re-1
122 (concat "^\\s-*Object\\.extend\\s-*("
123 "\\(" js--dotted-name-re "\\)"
126 (defconst js--prototype-objextend-class-decl-re-2
127 (concat "^\\s-*\\(?:var\\s-+\\)?"
128 "\\(" js--dotted-name-re "\\)"
129 "\\s-*=\\s-*Object\\.extend\\s-*\("))
131 ;; var NewClass = Class.create({
132 (defconst js--prototype-class-decl-re
133 (concat "^\\s-*\\(?:var\\s-+\\)?"
134 "\\(" js--name-re "\\)"
135 "\\s-*=\\s-*Class\\.create\\s-*(\\s-*"
136 "\\(?:\\(" js--dotted-name-re "\\)\\s-*,\\s-*\\)?{?"))
138 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
139 ;; matched with dedicated font-lock matchers
140 (defconst js--dojo-class-decl-re
141 (concat "^\\s-*dojo\\.declare\\s-*(\"\\(" js--dotted-name-re "\\)"))
143 (defconst js--extjs-class-decl-re-1
144 (concat "^\\s-*Ext\\.extend\\s-*("
145 "\\s-*\\(" js--dotted-name-re "\\)"
146 "\\s-*,\\s-*\\(" js--dotted-name-re "\\)")
147 "Regexp matching an ExtJS class declaration (style 1).")
149 (defconst js--extjs-class-decl-re-2
150 (concat "^\\s-*\\(?:var\\s-+\\)?"
151 "\\(" js--name-re "\\)"
152 "\\s-*=\\s-*Ext\\.extend\\s-*(\\s-*"
153 "\\(" js--dotted-name-re "\\)")
154 "Regexp matching an ExtJS class declaration (style 2).")
156 (defconst js--mochikit-class-re
157 (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*"
158 "\\(" js--dotted-name-re "\\)")
159 "Regexp matching a MochiKit class declaration.")
161 (defconst js--dummy-class-style
162 '(:name "[Automatically Generated Class]"))
164 (defconst js--class-styles
166 :class-decl ,js--plain-class-re
169 :framework javascript)
172 :class-decl ,js--mochikit-class-re
177 (:name "Prototype (Obsolete)"
178 :class-decl ,js--prototype-obsolete-class-decl-re
180 :framework prototype)
182 (:name "Prototype (Modern)"
183 :class-decl ,js--prototype-class-decl-re
185 :framework prototype)
187 (:name "Prototype (Object.extend)"
188 :class-decl ,js--prototype-objextend-class-decl-re-1
191 :framework prototype)
193 (:name "Prototype (Object.extend) 2"
194 :class-decl ,js--prototype-objextend-class-decl-re-2
197 :framework prototype)
200 :class-decl ,js--dojo-class-decl-re
204 (:name "ExtJS (style 1)"
205 :class-decl ,js--extjs-class-decl-re-1
210 (:name "ExtJS (style 2)"
211 :class-decl ,js--extjs-class-decl-re-2
215 (:name "Merrill Press"
216 :class-decl ,js--mp-class-decl-re
218 :framework merrillpress))
220 "List of JavaScript class definition styles.
222 A class definition style is a plist with the following keys:
224 :name is a human-readable name of the class type
226 :class-decl is a regular expression giving the start of the
227 class. Its first group must match the name of its class. If there
228 is a parent class, the second group should match, and it should be
229 the name of the class.
231 If :prototype is present and non-nil, the parser will merge
232 declarations for this constructs with others at the same lexical
233 level that have the same name. Otherwise, multiple definitions
234 will create multiple top-level entries. Don't use :prototype
235 unnecessarily: it has an associated cost in performance.
237 If :strip-prototype is present and non-nil, then if the class
238 name as matched contains
241 (defconst js--available-frameworks
242 (loop with available-frameworks
243 for style in js--class-styles
244 for framework = (plist-get style :framework)
245 unless (memq framework available-frameworks)
246 collect framework into available-frameworks
247 finally return available-frameworks)
248 "List of available JavaScript frameworks symbols.")
250 (defconst js--function-heading-1-re
252 "^\\s-*function\\s-+\\(" js--name-re "\\)")
253 "Regexp matching the start of a JavaScript function header.
254 Match group 1 is the name of the function.")
256 (defconst js--function-heading-2-re
258 "^\\s-*\\(" js--name-re "\\)\\s-*:\\s-*function\\_>")
259 "Regexp matching the start of a function entry in an associative array.
260 Match group 1 is the name of the function.")
262 (defconst js--function-heading-3-re
264 "^\\s-*\\(?:var\\s-+\\)?\\(" js--dotted-name-re "\\)"
265 "\\s-*=\\s-*function\\_>")
266 "Regexp matching a line in the JavaScript form \"var MUMBLE = function\".
267 Match group 1 is MUMBLE.")
269 (defconst js--macro-decl-re
270 (concat "^\\s-*#\\s-*define\\s-+\\(" js--cpp-name-re "\\)\\s-*(")
271 "Regexp matching a CPP macro definition, up to the opening parenthesis.
272 Match group 1 is the name of the macro.")
274 (defun js--regexp-opt-symbol (list)
275 "Like `regexp-opt', but surround the result with `\\\\_<' and `\\\\_>'."
276 (concat "\\_<" (regexp-opt list t) "\\_>"))
278 (defconst js--keyword-re
279 (js--regexp-opt-symbol
280 '("abstract" "break" "case" "catch" "class" "const"
281 "continue" "debugger" "default" "delete" "do" "else"
282 "enum" "export" "extends" "final" "finally" "for"
283 "function" "goto" "if" "implements" "import" "in"
284 "instanceof" "interface" "native" "new" "package"
285 "private" "protected" "public" "return" "static"
286 "super" "switch" "synchronized" "throw"
287 "throws" "transient" "try" "typeof" "var" "void" "let"
288 "yield" "volatile" "while" "with"))
289 "Regexp matching any JavaScript keyword.")
291 (defconst js--basic-type-re
292 (js--regexp-opt-symbol
293 '("boolean" "byte" "char" "double" "float" "int" "long"
295 "Regular expression matching any predefined type in JavaScript.")
297 (defconst js--constant-re
298 (js--regexp-opt-symbol '("false" "null" "undefined"
300 "true" "arguments" "this"))
301 "Regular expression matching any future reserved words in JavaScript.")
304 (defconst js--font-lock-keywords-1
307 (list js--function-heading-1-re 1 font-lock-function-name-face)
308 (list js--function-heading-2-re 1 font-lock-function-name-face))
309 "Level one font lock keywords for `js-mode'.")
311 (defconst js--font-lock-keywords-2
312 (append js--font-lock-keywords-1
313 (list (list js--keyword-re 1 font-lock-keyword-face)
315 "\\s-+\\(each\\)\\_>" nil nil
316 (list 1 'font-lock-keyword-face))
317 (cons js--basic-type-re font-lock-type-face)
318 (cons js--constant-re font-lock-constant-face)))
319 "Level two font lock keywords for `js-mode'.")
321 ;; js--pitem is the basic building block of the lexical
322 ;; database. When one refers to a real part of the buffer, the region
323 ;; of text to which it refers is split into a conceptual header and
324 ;; body. Consider the (very short) block described by a hypothetical
327 ;; function foo(a,b,c) { return 42; }
330 ;; +- h-begin +- h-end +- b-end
332 ;; (Remember that these are buffer positions, and therefore point
333 ;; between characters, not at them. An arrow drawn to a character
334 ;; indicates the corresponding position is between that character and
335 ;; the one immediately preceding it.)
337 ;; The header is the region of text [h-begin, h-end], and is
338 ;; the text needed to unambiguously recognize the start of the
339 ;; construct. If the entire header is not present, the construct is
340 ;; not recognized at all. No other pitems may be nested inside the
343 ;; The body is the region [h-end, b-end]. It may contain nested
344 ;; js--pitem instances. The body of a pitem may be empty: in
345 ;; that case, b-end is equal to header-end.
347 ;; The three points obey the following relationship:
349 ;; h-begin < h-end <= b-end
351 ;; We put a text property in the buffer on the character *before*
352 ;; h-end, and if we see it, on the character *before* b-end.
354 ;; The text property for h-end, js--pstate, is actually a list
355 ;; of all js--pitem instances open after the marked character.
357 ;; The text property for b-end, js--pend, is simply the
358 ;; js--pitem that ends after the marked character. (Because
359 ;; pitems always end when the paren-depth drops below a critical
360 ;; value, and because we can only drop one level per character, only
361 ;; one pitem may end at a given character.)
363 ;; In the structure below, we only store h-begin and (sometimes)
364 ;; b-end. We can trivially and quickly find h-end by going to h-begin
365 ;; and searching for an js--pstate text property. Since no other
366 ;; js--pitem instances can be nested inside the header of a
367 ;; pitem, the location after the character with this text property
370 ;; js--pitem instances are never modified (with the exception
371 ;; of the b-end field). Instead, modified copies are added at subseqnce parse points.
372 ;; (The exception for b-end and its caveats is described below.)
375 (defstruct (js--pitem (:type list))
376 ;; IMPORTANT: Do not alter the position of fields within the list.
377 ;; Various bits of code depend on their positions, particularly
378 ;; anything that manipulates the list of children.
380 ;; List of children inside this pitem's body
381 (children nil :read-only t)
383 ;; When we reach this paren depth after h-end, the pitem ends
384 (paren-depth nil :read-only t)
386 ;; Symbol or class-style plist if this is a class
387 (type nil :read-only t)
390 (h-begin nil :read-only t)
392 ;; List of strings giving the parts of the name of this pitem (e.g.,
393 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
394 (name nil :read-only t)
396 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
397 ;; this pitem: when we copy-and-modify pitem instances, we share
398 ;; their tail structures, so all the copies actually have the same
399 ;; terminating cons cell. We modify that shared cons cell directly.
401 ;; The field value is either a number (buffer location) or nil if
404 ;; If the field's value is greater than `js--cache-end', the
405 ;; value is stale and must be treated as if it were nil. Conversely,
406 ;; if this field is nil, it is guaranteed that this pitem is open up
407 ;; to at least `js--cache-end'. (This property is handy when
408 ;; computing whether we're inside a given pitem.)
412 ;; The pitem we start parsing with.
413 (defconst js--initial-pitem
415 :paren-depth most-negative-fixnum
418 ;;; User Customization
421 "Customization variables for JavaScript mode."
425 (defcustom js-indent-level 4
426 "Number of spaces for each indentation step in `js-mode'."
430 (defcustom js-expr-indent-offset 0
431 "Number of additional spaces for indenting continued expressions.
432 The value must be no less than minus `js-indent-level'."
436 (defcustom js-paren-indent-offset 0
437 "Number of additional spaces for indenting expressions in parentheses.
438 The value must be no less than minus `js-indent-level'."
443 (defcustom js-square-indent-offset 0
444 "Number of additional spaces for indenting expressions in square braces.
445 The value must be no less than minus `js-indent-level'."
450 (defcustom js-curly-indent-offset 0
451 "Number of additional spaces for indenting expressions in curly braces.
452 The value must be no less than minus `js-indent-level'."
457 (defcustom js-auto-indent-flag t
458 "Whether to automatically indent when typing punctuation characters.
459 If non-nil, the characters {}();,: also indent the current line
464 (defcustom js-flat-functions nil
465 "Treat nested functions as top-level functions in `js-mode'.
466 This applies to function movement, marking, and so on."
470 (defcustom js-comment-lineup-func #'c-lineup-C-comments
471 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
475 (defcustom js-enabled-frameworks js--available-frameworks
476 "Frameworks recognized by `js-mode'.
477 To improve performance, you may turn off some frameworks you
478 seldom use, either globally or on a per-buffer basis."
479 :type (cons 'set (mapcar (lambda (x)
481 js--available-frameworks))
484 (defcustom js-js-switch-tabs
485 (and (memq system-type '(darwin)) t)
486 "Whether `js-mode' should display tabs while selecting them.
487 This is useful only if the windowing system has a good mechanism
488 for preventing Firefox from stealing the keyboard focus."
492 (defcustom js-js-tmpdir
494 "Temporary directory used by `js-mode' to communicate with Mozilla.
495 This directory must be readable and writable by both Mozilla and Emacs."
499 (defcustom js-js-timeout 5
500 "Reply timeout for executing commands in Mozilla via `js-mode'.
501 The value is given in seconds. Increase this value if you are
502 getting timeout messages."
509 (let ((keymap (make-sparse-keymap)))
511 (define-key keymap key #'js-insert-and-indent))
512 '("{" "}" "(" ")" ":" ";" ","))
513 (define-key keymap [(control ?c) (meta ?:)] #'js-eval)
514 (define-key keymap [(control ?c) (control ?j)] #'js-set-js-context)
515 (define-key keymap [(control meta ?x)] #'js-eval-defun)
516 (define-key keymap [(meta ?.)] #'js-find-symbol)
517 (easy-menu-define nil keymap "Javascript Menu"
519 ["Select New Mozilla Context..." js-set-js-context
520 (fboundp #'inferior-moz-process)]
521 ["Evaluate Expression in Mozilla Context..." js-eval
522 (fboundp #'inferior-moz-process)]
523 ["Send Current Function to Mozilla..." js-eval-defun
524 (fboundp #'inferior-moz-process)]))
526 "Keymap for `js-mode'.")
528 (defun js-insert-and-indent (key)
529 "Run the command bound to KEY, and indent if necessary.
530 Indentation does not take place if point is in a string or
532 (interactive (list (this-command-keys)))
533 (call-interactively (lookup-key (current-global-map) key))
534 (let ((syntax (save-restriction (widen) (syntax-ppss))))
535 (when (or (and (not (nth 8 syntax))
539 (1+ (current-indentation)))))
540 (indent-according-to-mode))))
543 ;;; Syntax table and parsing
545 (defvar js-mode-syntax-table
546 (let ((table (make-syntax-table)))
547 (c-populate-syntax-table table)
548 (modify-syntax-entry ?$ "_" table)
550 "Syntax table for `js-mode'.")
552 (defvar js--quick-match-re nil
553 "Autogenerated regexp used by `js-mode' to match buffer constructs.")
555 (defvar js--quick-match-re-func nil
556 "Autogenerated regexp used by `js-mode' to match constructs and functions.")
558 (make-variable-buffer-local 'js--quick-match-re)
559 (make-variable-buffer-local 'js--quick-match-re-func)
561 (defvar js--cache-end 1
562 "Last valid buffer position for the `js-mode' function cache.")
563 (make-variable-buffer-local 'js--cache-end)
565 (defvar js--last-parse-pos nil
566 "Latest parse position reached by `js--ensure-cache'.")
567 (make-variable-buffer-local 'js--last-parse-pos)
569 (defvar js--state-at-last-parse-pos nil
570 "Parse state at `js--last-parse-pos'.")
571 (make-variable-buffer-local 'js--state-at-last-parse-pos)
573 (defun js--flatten-list (list)
574 (loop for item in list
575 nconc (cond ((consp item)
576 (js--flatten-list item))
577 (item (list item)))))
579 (defun js--maybe-join (prefix separator suffix &rest list)
580 "Helper function for `js--update-quick-match-re'.
581 If LIST contains any element that is not nil, return its non-nil
582 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
583 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
584 nil. If any element in LIST is itself a list, flatten that
586 (setq list (js--flatten-list list))
588 (concat prefix (mapconcat #'identity list separator) suffix)))
590 (defun js--update-quick-match-re ()
591 "Internal function used by `js-mode' for caching buffer constructs.
592 This updates `js--quick-match-re', based on the current set of
594 (setq js--quick-match-re
596 "^[ \t]*\\(?:" "\\|" "\\)"
599 "#define[ \t]+[a-zA-Z_]"
601 (when (memq 'extjs js-enabled-frameworks)
604 (when (memq 'prototype js-enabled-frameworks)
607 ;; var mumble = THING (
609 "\\(?:var[ \t]+\\)?[a-zA-Z_$0-9.]+[ \t]*=[ \t]*\\(?:"
613 (when (memq 'prototype js-enabled-frameworks)
616 (when (memq 'extjs js-enabled-frameworks)
619 (when (memq 'merrillpress js-enabled-frameworks)
620 "[a-zA-Z_$0-9]+\\.extend\\(?:Final\\)?"))
622 (when (memq 'dojo js-enabled-frameworks)
623 "dojo\\.declare[ \t]*\(")
625 (when (memq 'mochikit js-enabled-frameworks)
626 "MochiKit\\.Base\\.update[ \t]*\(")
628 ;; mumble.prototypeTHING
630 "[a-zA-Z_$0-9.]+\\.prototype\\(?:" "\\|" "\\)"
632 (when (memq 'javascript js-enabled-frameworks)
633 '( ;; foo.prototype.bar = function(
634 "\\.[a-zA-Z_$0-9]+[ \t]*=[ \t]*function[ \t]*\("
636 ;; mumble.prototype = {
637 "[ \t]*=[ \t]*{")))))
639 (setq js--quick-match-re-func
640 (concat "function\\|" js--quick-match-re)))
642 (defun js--forward-text-property (propname)
643 "Move over the next value of PROPNAME in the buffer.
644 If found, return that value and leave point after the character
645 having that value; otherwise, return nil and leave point at EOB."
646 (let ((next-value (get-text-property (point) propname)))
650 (goto-char (next-single-property-change
651 (point) propname nil (point-max)))
653 (setq next-value (get-text-property (point) propname))
658 (defun js--backward-text-property (propname)
659 "Move over the previous value of PROPNAME in the buffer.
660 If found, return that value and leave point just before the
661 character that has that value, otherwise return nil and leave
664 (let ((prev-value (get-text-property (1- (point)) propname)))
668 (goto-char (previous-single-property-change
669 (point) propname nil (point-min)))
673 (setq prev-value (get-text-property (point) propname))))
677 (defsubst js--forward-pstate ()
678 (js--forward-text-property 'js--pstate))
680 (defsubst js--backward-pstate ()
681 (js--backward-text-property 'js--pstate))
683 (defun js--pitem-goto-h-end (pitem)
684 (goto-char (js--pitem-h-begin pitem))
685 (js--forward-pstate))
687 (defun js--re-search-forward-inner (regexp &optional bound count)
688 "Helper function for `js--re-search-forward'."
691 (orig-macro-end (save-excursion
692 (when (js--beginning-of-macro)
696 (re-search-forward regexp bound)
697 (setq parse (syntax-ppss))
698 (cond ((setq str-terminator (nth 3 parse))
699 (when (eq str-terminator t)
700 (setq str-terminator ?/))
702 (concat "\\([^\\]\\|^\\)" (string str-terminator))
707 (and (eq (char-before) ?\/) (eq (char-after) ?\*)))
708 (re-search-forward "\\*/"))
709 ((and (not (and orig-macro-end
710 (<= (point) orig-macro-end)))
711 (js--beginning-of-macro))
714 (setq count (1- count))))))
718 (defun js--re-search-forward (regexp &optional bound noerror count)
719 "Search forward, ignoring strings, cpp macros, and comments.
720 This function invokes `re-search-forward', but treats the buffer
721 as if strings, cpp macros, and comments have been removed.
723 If invoked while inside a macro, it treats the contents of the
724 macro as normal text."
725 (unless count (setq count 1))
726 (let ((saved-point (point))
728 (cond ((< count 0) (setq count (- count))
729 #'js--re-search-backward-inner)
730 ((> count 0) #'js--re-search-forward-inner)
733 (funcall search-fun regexp bound count)
735 (goto-char saved-point)
737 (signal (car err) (cdr err)))))))
740 (defun js--re-search-backward-inner (regexp &optional bound count)
741 "Auxiliary function for `js--re-search-backward'."
746 (and (js--beginning-of-macro)
749 (re-search-backward regexp bound)
750 (when (and (> (point) (point-min))
751 (save-excursion (backward-char) (looking-at "/[/*]")))
753 (setq parse (syntax-ppss))
754 (cond ((setq str-terminator (nth 3 parse))
755 (when (eq str-terminator t)
756 (setq str-terminator ?/))
758 (concat "\\([^\\]\\|^\\)" (string str-terminator))
761 (goto-char (nth 8 parse)))
763 (and (eq (char-before) ?/) (eq (char-after) ?*)))
764 (re-search-backward "/\\*"))
765 ((and (not (and orig-macro-start
766 (>= (point) orig-macro-start)))
767 (js--beginning-of-macro)))
769 (setq count (1- count))))))
773 (defun js--re-search-backward (regexp &optional bound noerror count)
774 "Search backward, ignoring strings, preprocessor macros, and comments.
776 This function invokes `re-search-backward' but treats the buffer
777 as if strings, preprocessor macros, and comments have been
780 If invoked while inside a macro, treat the macro as normal text."
781 (js--re-search-forward regexp bound noerror (if count (- count) -1)))
783 (defun js--forward-expression ()
784 "Move forward over a whole JavaScript expression.
785 This function doesn't move over expressions continued across
788 ;; non-continued case; simplistic, but good enough?
789 do (loop until (or (eolp)
791 (forward-comment most-positive-fixnum)
792 (memq (char-after) '(?\, ?\; ?\] ?\) ?\}))))
795 while (and (eq (char-after) ?\n)
798 (js--continued-expression-p)))))
800 (defun js--forward-function-decl ()
801 "Move forward over a JavaScript function declaration.
802 This puts point at the 'function' keyword.
804 If this is a syntactically-correct non-expression function,
805 return the name of the function, or t if the name could not be
806 determined. Otherwise, return nil."
807 (assert (looking-at "\\_<function\\_>"))
810 (forward-comment most-positive-fixnum)
811 (when (looking-at js--name-re)
812 (setq name (match-string-no-properties 0))
813 (goto-char (match-end 0)))
814 (forward-comment most-positive-fixnum)
815 (and (eq (char-after) ?\( )
816 (ignore-errors (forward-list) t)
817 (progn (forward-comment most-positive-fixnum)
818 (and (eq (char-after) ?{)
821 (defun js--function-prologue-beginning (&optional pos)
822 "Return the start of the JavaScript function prologue containing POS.
823 A function prologue is everything from start of the definition up
824 to and including the opening brace. POS defaults to point.
825 If POS is not in a function prologue, return nil."
826 (let (prologue-begin)
832 (when (save-excursion
834 (or (looking-at js--function-heading-2-re)
835 (looking-at js--function-heading-3-re)))
837 (setq prologue-begin (match-beginning 1))
838 (when (<= prologue-begin pos)
839 (goto-char (match-end 0))))
841 (skip-syntax-backward "w_")
842 (and (or (looking-at "\\_<function\\_>")
843 (js--re-search-backward "\\_<function\\_>" nil t))
845 (save-match-data (goto-char (match-beginning 0))
846 (js--forward-function-decl))
849 (or prologue-begin (match-beginning 0))))))
851 (defun js--beginning-of-defun-raw ()
852 "Helper function for `js-beginning-of-defun'.
853 Go to previous defun-beginning and return the parse state for it,
854 or nil if we went all the way back to bob and don't find
858 (while (and (setq pstate (js--backward-pstate))
859 (not (eq 'function (js--pitem-type (car pstate))))))
860 (and (not (bobp)) pstate)))
862 (defun js--pstate-is-toplevel-defun (pstate)
863 "Helper function for `js--beginning-of-defun-nested'.
864 If PSTATE represents a non-empty top-level defun, return the
865 top-most pitem. Otherwise, return nil."
866 (loop for pitem in pstate
869 if (eq 'function (js--pitem-type pitem))
871 and do (setq func-pitem pitem)
872 finally return (if (eq func-depth 1) func-pitem)))
874 (defun js--beginning-of-defun-nested ()
875 "Helper function for `js--beginning-of-defun'.
876 Return the pitem of the function we went to the beginning of."
878 ;; Look for the smallest function that encloses point...
879 (loop for pitem in (js--parse-state-at-point)
880 if (and (eq 'function (js--pitem-type pitem))
881 (js--inside-pitem-p pitem))
882 do (goto-char (js--pitem-h-begin pitem))
885 ;; ...and if that isn't found, look for the previous top-level
887 (loop for pstate = (js--backward-pstate)
889 if (js--pstate-is-toplevel-defun pstate)
890 do (goto-char (js--pitem-h-begin it))
893 (defun js--beginning-of-defun-flat ()
894 "Helper function for `js-beginning-of-defun'."
895 (let ((pstate (js--beginning-of-defun-raw)))
897 (goto-char (js--pitem-h-begin (car pstate))))))
899 (defun js-beginning-of-defun (&optional arg)
900 "Value of `beginning-of-defun-function' for `js-mode'."
901 (setq arg (or arg 1))
902 (while (and (not (eobp)) (< arg 0))
904 (when (and (not js-flat-functions)
905 (or (eq (js-syntactic-context) 'function)
906 (js--function-prologue-beginning)))
909 (if (js--re-search-forward
910 "\\_<function\\_>" nil t)
911 (goto-char (js--function-prologue-beginning))
912 (goto-char (point-max))))
916 ;; If we're just past the end of a function, the user probably wants
917 ;; to go to the beginning of *that* function
918 (when (eq (char-before) ?})
921 (let ((prologue-begin (js--function-prologue-beginning)))
922 (cond ((and prologue-begin (< prologue-begin (point)))
923 (goto-char prologue-begin))
926 (js--beginning-of-defun-flat))
928 (js--beginning-of-defun-nested))))))
930 (defun js--flush-caches (&optional beg ignored)
931 "Flush the `js-mode' syntax cache after position BEG.
932 BEG defaults to `point-min', meaning to flush the entire cache."
934 (setq beg (or beg (save-restriction (widen) (point-min))))
935 (setq js--cache-end (min js--cache-end beg)))
937 (defmacro js--debug (&rest _arguments)
938 ;; `(message ,@arguments)
941 (defun js--ensure-cache--pop-if-ended (open-items paren-depth)
942 (let ((top-item (car open-items)))
943 (when (<= paren-depth (js--pitem-paren-depth top-item))
944 (assert (not (get-text-property (1- (point)) 'js-pend)))
945 (put-text-property (1- (point)) (point) 'js--pend top-item)
946 (setf (js--pitem-b-end top-item) (point))
948 ;; open-items must contain at least two items for this to
949 ;; work, but because we push a dummy item to start with,
950 ;; that assumption holds.
951 (cons (js--pitem-add-child (second open-items) top-item)
952 (cddr open-items)))))
955 (defmacro js--ensure-cache--update-parse ()
956 "Helper function for `js--ensure-cache'.
957 Update parsing information up to point, referring to parse,
958 prev-parse-point, goal-point, and open-items bound lexically in
959 the body of `js--ensure-cache'."
961 (setq goal-point (point))
962 (goto-char prev-parse-point)
964 (setq open-items (js--ensure-cache--pop-if-ended
965 open-items (car parse)))
966 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
967 ;; the given depth -- i.e., make sure we're deeper than the target
969 (assert (> (nth 0 parse)
970 (js--pitem-paren-depth (car open-items))))
971 (setq parse (parse-partial-sexp
972 prev-parse-point goal-point
973 (js--pitem-paren-depth (car open-items))
976 ;; (let ((overlay (make-overlay prev-parse-point (point))))
977 ;; (overlay-put overlay 'face '(:background "red"))
980 ;; (js--debug "parsed: %S" parse)
982 ;; (delete-overlay overlay)))
984 (setq prev-parse-point (point))
985 (< (point) goal-point)))
987 (setq open-items (js--ensure-cache--pop-if-ended
988 open-items (car parse)))))
990 (defun js--show-cache-at-point ()
993 (let ((prop (get-text-property (point) 'js--pstate)))
994 (with-output-to-temp-buffer "*Help*"
997 (defun js--split-name (string)
998 "Split a JavaScript name into its dot-separated parts.
999 This also removes any prototype parts from the split name
1000 \(unless the name is just \"prototype\" to start with)."
1001 (let ((name (save-match-data
1002 (split-string string "\\." t))))
1003 (unless (and (= (length name) 1)
1004 (equal (car name) "prototype"))
1006 (setq name (remove "prototype" name)))))
1008 (defvar js--guess-function-name-start nil)
1010 (defun js--guess-function-name (position)
1011 "Guess the name of the JavaScript function at POSITION.
1012 POSITION should be just after the end of the word \"function\".
1013 Return the name of the function, or nil if the name could not be
1016 This function clobbers match data. If we find the preamble
1017 begins earlier than expected while guessing the function name,
1018 set `js--guess-function-name-start' to that position; otherwise,
1019 set that variable to nil."
1020 (setq js--guess-function-name-start nil)
1022 (goto-char position)
1025 ((looking-at js--function-heading-3-re)
1026 (and (eq (match-end 0) position)
1027 (setq js--guess-function-name-start (match-beginning 1))
1028 (match-string-no-properties 1)))
1030 ((looking-at js--function-heading-2-re)
1031 (and (eq (match-end 0) position)
1032 (setq js--guess-function-name-start (match-beginning 1))
1033 (match-string-no-properties 1))))))
1035 (defun js--clear-stale-cache ()
1036 ;; Clear any endings that occur after point
1039 (while (setq end-prop (js--forward-text-property
1041 (setf (js--pitem-b-end end-prop) nil))))
1043 ;; Remove any cache properties after this point
1044 (remove-text-properties (point) (point-max)
1045 '(js--pstate t js--pend t)))
1047 (defun js--ensure-cache (&optional limit)
1048 "Ensures brace cache is valid up to the character before LIMIT.
1049 LIMIT defaults to point."
1050 (setq limit (or limit (point)))
1051 (when (< js--cache-end limit)
1053 (c-save-buffer-state
1062 filtered-class-styles
1067 ;; Figure out which class styles we need to look for
1068 (setq filtered-class-styles
1069 (loop for style in js--class-styles
1070 if (memq (plist-get style :framework)
1071 js-enabled-frameworks)
1078 ;; Find last known good position
1079 (goto-char js--cache-end)
1081 (setq open-items (get-text-property
1082 (1- (point)) 'js--pstate))
1085 (goto-char (previous-single-property-change
1086 (point) 'js--pstate nil (point-min)))
1089 (setq open-items (get-text-property (1- (point))
1091 (assert open-items))))
1094 ;; Make a placeholder for the top-level definition
1095 (setq open-items (list js--initial-pitem)))
1097 (setq parse (syntax-ppss))
1098 (setq prev-parse-point (point))
1100 (js--clear-stale-cache)
1102 (narrow-to-region (point-min) limit)
1104 (loop while (re-search-forward js--quick-match-re-func nil t)
1105 for orig-match-start = (goto-char (match-beginning 0))
1106 for orig-match-end = (match-end 0)
1107 do (js--ensure-cache--update-parse)
1108 for orig-depth = (nth 0 parse)
1110 ;; Each of these conditions should return non-nil if
1111 ;; we should add a new item and leave point at the end
1112 ;; of the new item's header (h-end in the
1113 ;; js--pitem diagram). This point is the one
1114 ;; after the last character we need to unambiguously
1115 ;; detect this construct. If one of these evaluates to
1116 ;; nil, the location of the point is ignored.
1118 ;; In comment or string
1121 ;; Regular function declaration
1122 ((and (looking-at "\\_<function\\_>")
1123 (setq name (js--forward-function-decl)))
1126 (setq name (js--guess-function-name orig-match-end))
1128 (when js--guess-function-name-start
1129 (setq orig-match-start
1130 js--guess-function-name-start))
1134 (assert (eq (char-after) ?{))
1137 :paren-depth orig-depth
1138 :h-begin orig-match-start
1140 :name (if (eq name t)
1142 (js--split-name name))))
1145 ((looking-at js--macro-decl-re)
1147 ;; Macros often contain unbalanced parentheses.
1148 ;; Make sure that h-end is at the textual end of
1149 ;; the macro no matter what the parenthesis say.
1151 (js--ensure-cache--update-parse)
1154 :paren-depth (nth 0 parse)
1155 :h-begin orig-match-start
1157 :name (list (match-string-no-properties 1))))
1159 ;; "Prototype function" declaration
1160 ((looking-at js--plain-method-re)
1161 (goto-char (match-beginning 3))
1162 (when (save-match-data
1163 (js--forward-function-decl))
1166 :paren-depth orig-depth
1167 :h-begin orig-match-start
1169 :name (nconc (js--split-name
1170 (match-string-no-properties 1))
1171 (list (match-string-no-properties 2))))))
1174 ((loop with syntactic-context =
1175 (js--syntactic-context-from-pstate open-items)
1176 for class-style in filtered-class-styles
1177 if (and (memq syntactic-context
1178 (plist-get class-style :contexts))
1179 (looking-at (plist-get class-style
1181 do (goto-char (match-end 0))
1184 :paren-depth orig-depth
1185 :h-begin orig-match-start
1187 :name (js--split-name
1188 (match-string-no-properties 1))))))
1190 do (js--ensure-cache--update-parse)
1191 and do (push it open-items)
1192 and do (put-text-property
1193 (1- (point)) (point) 'js--pstate open-items)
1194 else do (goto-char orig-match-end))
1197 (js--ensure-cache--update-parse)
1198 (setq js--cache-end limit)
1199 (setq js--last-parse-pos limit)
1200 (setq js--state-at-last-parse-pos open-items)
1203 (defun js--end-of-defun-flat ()
1204 "Helper function for `js-end-of-defun'."
1205 (loop while (js--re-search-forward "}" nil t)
1206 do (js--ensure-cache)
1207 if (get-text-property (1- (point)) 'js--pend)
1208 if (eq 'function (js--pitem-type it))
1210 finally do (goto-char (point-max))))
1212 (defun js--end-of-defun-nested ()
1213 "Helper function for `js-end-of-defun'."
1216 (this-end (save-excursion
1217 (and (setq pitem (js--beginning-of-defun-nested))
1218 (js--pitem-goto-h-end pitem)
1219 (progn (backward-char)
1224 (if (and this-end (< (point) this-end))
1225 ;; We're already inside a function; just go to its end.
1226 (goto-char this-end)
1228 ;; Otherwise, go to the end of the next function...
1229 (while (and (js--re-search-forward "\\_<function\\_>" nil t)
1230 (not (setq found (progn
1231 (goto-char (match-beginning 0))
1232 (js--forward-function-decl))))))
1234 (if found (forward-list)
1236 (goto-char (point-max))))))
1238 (defun js-end-of-defun (&optional arg)
1239 "Value of `end-of-defun-function' for `js-mode'."
1240 (setq arg (or arg 1))
1241 (while (and (not (bobp)) (< arg 0))
1243 (js-beginning-of-defun)
1244 (js-beginning-of-defun)
1250 ;; look for function backward. if we're inside it, go to that
1251 ;; function's end. otherwise, search for the next function's end and
1253 (if js-flat-functions
1254 (js--end-of-defun-flat)
1256 ;; if we're doing nested functions, see whether we're in the
1257 ;; prologue. If we are, go to the end of the function; otherwise,
1258 ;; call js--end-of-defun-nested to do the real work
1259 (let ((prologue-begin (js--function-prologue-beginning)))
1260 (cond ((and prologue-begin (<= prologue-begin (point)))
1261 (goto-char prologue-begin)
1262 (re-search-forward "\\_<function")
1263 (goto-char (match-beginning 0))
1264 (js--forward-function-decl)
1267 (t (js--end-of-defun-nested)))))))
1269 (defun js--beginning-of-macro (&optional lim)
1270 (let ((here (point)))
1272 (if lim (narrow-to-region lim (point-max)))
1274 (while (eq (char-before (1- (point))) ?\\)
1276 (back-to-indentation)
1277 (if (and (<= (point) here)
1278 (looking-at js--opt-cpp-start))
1283 (defun js--backward-syntactic-ws (&optional lim)
1284 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1286 (when lim (narrow-to-region lim (point-max)))
1288 (let ((in-macro (save-excursion (js--beginning-of-macro)))
1291 (while (progn (unless in-macro (js--beginning-of-macro))
1292 (forward-comment most-negative-fixnum)
1296 (setq pos (point)))))))))
1298 (defun js--forward-syntactic-ws (&optional lim)
1299 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1301 (when lim (narrow-to-region (point-min) lim))
1302 (let ((pos (point)))
1304 (forward-comment most-positive-fixnum)
1305 (when (eq (char-after) ?#)
1310 (setq pos (point)))))))))
1312 ;; Like (up-list -1), but only considers lists that end nearby"
1313 (defun js--up-nearby-list ()
1315 ;; Look at a very small region so our compuation time doesn't
1316 ;; explode in pathological cases.
1317 (narrow-to-region (max (point-min) (- (point) 500)) (point))
1320 (defun js--inside-param-list-p ()
1321 "Return non-nil iff point is in a function parameter list."
1324 (js--up-nearby-list)
1325 (and (looking-at "(")
1326 (progn (forward-symbol -1)
1327 (or (looking-at "function")
1328 (progn (forward-symbol -1)
1329 (looking-at "function"))))))))
1331 (defun js--inside-dojo-class-list-p ()
1332 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1335 (js--up-nearby-list)
1336 (let ((list-begin (point)))
1338 (and (looking-at js--dojo-class-decl-re)
1339 (goto-char (match-end 0))
1340 (looking-at "\"\\s-*,\\s-*\\[")
1341 (eq (match-end 0) (1+ list-begin)))))))
1343 (defun js--syntax-begin-function ()
1344 (when (< js--cache-end (point))
1345 (goto-char (max (point-min) js--cache-end)))
1348 (while (and (setq pitem (car (js--backward-pstate)))
1349 (not (eq 0 (js--pitem-paren-depth pitem)))))
1352 (goto-char (js--pitem-h-begin pitem )))))
1355 (defun js--make-framework-matcher (framework &rest regexps)
1356 "Helper function for building `js--font-lock-keywords'.
1357 Create a byte-compiled function for matching a concatenation of
1358 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1359 (setq regexps (apply #'concat regexps))
1362 (when (memq (quote ,framework) js-enabled-frameworks)
1363 (re-search-forward ,regexps limit t)))))
1365 (defvar js--tmp-location nil)
1366 (make-variable-buffer-local 'js--tmp-location)
1368 (defun js--forward-destructuring-spec (&optional func)
1369 "Move forward over a JavaScript destructuring spec.
1370 If FUNC is supplied, call it with no arguments before every
1371 variable name in the spec. Return true iff this was actually a
1372 spec. FUNC must preserve the match data."
1378 (forward-comment most-positive-fixnum)
1379 (cond ((memq (char-after) '(?\[ ?\{))
1380 (js--forward-destructuring-spec func))
1382 ((eq (char-after) ?,)
1386 ((looking-at js--name-re)
1387 (and func (funcall func))
1388 (goto-char (match-end 0))
1390 (when (eq (char-after) ?\])
1396 (forward-comment most-positive-fixnum)
1398 (when (looking-at js--objfield-re)
1399 (goto-char (match-end 0))
1400 (forward-comment most-positive-fixnum)
1401 (and (cond ((memq (char-after) '(?\[ ?\{))
1402 (js--forward-destructuring-spec func))
1403 ((looking-at js--name-re)
1404 (and func (funcall func))
1405 (goto-char (match-end 0))
1407 (progn (forward-comment most-positive-fixnum)
1408 (when (eq (char-after) ?\,)
1410 (forward-comment most-positive-fixnum)
1412 (when (eq (char-after) ?\})
1416 (defun js--variable-decl-matcher (limit)
1417 "Font-lock matcher for variable names in a variable declaration.
1418 This is a cc-mode-style matcher that *always* fails, from the
1419 point of view of font-lock. It applies highlighting directly with
1420 `font-lock-apply-highlight'."
1423 (narrow-to-region (point-min) limit)
1426 (forward-comment most-positive-fixnum)
1429 (when (eq (char-after) ?,)
1431 (forward-comment most-positive-fixnum)
1433 (cond ((looking-at js--name-re)
1434 (font-lock-apply-highlight
1435 '(0 font-lock-variable-name-face))
1436 (goto-char (match-end 0)))
1439 (js--forward-destructuring-spec))
1441 (js--forward-destructuring-spec
1443 (font-lock-apply-highlight
1444 '(0 font-lock-variable-name-face)))))))
1446 (forward-comment most-positive-fixnum)
1447 (when (eq (char-after) ?=)
1449 (js--forward-expression)
1450 (forward-comment most-positive-fixnum))
1454 ;; Conditions to handle
1456 (end-of-buffer nil))
1458 ;; Matcher always "fails"
1461 (defconst js--font-lock-keywords-3
1463 ;; This goes before keywords-2 so it gets used preferentially
1464 ;; instead of the keywords in keywords-2. Don't use override
1465 ;; because that will override syntactic fontification too, which
1466 ;; will fontify commented-out directives as if they weren't
1468 ,@cpp-font-lock-keywords ; from font-lock.el
1470 ,@js--font-lock-keywords-2
1472 ("\\.\\(prototype\\)\\_>"
1473 (1 font-lock-constant-face))
1475 ;; Highlights class being declared, in parts
1476 (js--class-decl-matcher
1477 ,(concat "\\(" js--name-re "\\)\\(?:\\.\\|.*$\\)")
1478 (goto-char (match-beginning 1))
1480 (1 font-lock-type-face))
1482 ;; Highlights parent class, in parts, if available
1483 (js--class-decl-matcher
1484 ,(concat "\\(" js--name-re "\\)\\(?:\\.\\|.*$\\)")
1485 (if (match-beginning 2)
1487 (setq js--tmp-location (match-end 2))
1488 (goto-char js--tmp-location)
1490 (goto-char (match-beginning 2)))
1491 (setq js--tmp-location nil)
1492 (goto-char (point-at-eol)))
1493 (when js--tmp-location
1495 (goto-char js--tmp-location)
1497 (1 font-lock-type-face))
1499 ;; Highlights parent class
1500 (js--class-decl-matcher
1501 (2 font-lock-type-face nil t))
1503 ;; Dojo needs its own matcher to override the string highlighting
1504 (,(js--make-framework-matcher
1506 "^\\s-*dojo\\.declare\\s-*(\""
1507 "\\(" js--dotted-name-re "\\)"
1508 "\\(?:\"\\s-*,\\s-*\\(" js--dotted-name-re "\\)\\)?")
1509 (1 font-lock-type-face t)
1510 (2 font-lock-type-face nil t))
1512 ;; Match Dojo base classes. Of course Mojo has to be different
1513 ;; from everything else under the sun...
1514 (,(js--make-framework-matcher
1516 "^\\s-*dojo\\.declare\\s-*(\""
1517 "\\(" js--dotted-name-re "\\)\"\\s-*,\\s-*\\[")
1518 ,(concat "[[,]\\s-*\\(" js--dotted-name-re "\\)\\s-*"
1522 (1 font-lock-type-face))
1524 ;; continued Dojo base-class list
1525 (,(js--make-framework-matcher
1527 "^\\s-*" js--dotted-name-re "\\s-*[],]")
1528 ,(concat "\\(" js--dotted-name-re "\\)"
1529 "\\s-*\\(?:\\].*$\\)?")
1530 (if (save-excursion (backward-char)
1531 (js--inside-dojo-class-list-p))
1535 (1 font-lock-type-face))
1537 ;; variable declarations
1539 (concat "\\_<\\(const\\|var\\|let\\)\\_>\\|" js--basic-type-re)
1540 (list #'js--variable-decl-matcher nil nil nil))
1542 ;; class instantiation
1544 (concat "\\_<new\\_>\\s-+\\(" js--dotted-name-re "\\)")
1545 (list 1 'font-lock-type-face))
1549 (concat "\\_<instanceof\\_>\\s-+\\(" js--dotted-name-re "\\)")
1550 (list 1 'font-lock-type-face))
1552 ;; formal parameters
1555 "\\_<function\\_>\\(\\s-+" js--name-re "\\)?\\s-*(\\s-*"
1557 (list (concat "\\(" js--name-re "\\)\\(\\s-*).*\\)?")
1560 '(1 font-lock-variable-name-face)))
1562 ;; continued formal parameter list
1565 "^\\s-*" js--name-re "\\s-*[,)]")
1567 '(if (save-excursion (backward-char)
1568 (js--inside-param-list-p))
1572 '(0 font-lock-variable-name-face))))
1573 "Level three font lock for `js-mode'.")
1575 (defun js--inside-pitem-p (pitem)
1576 "Return whether point is inside the given pitem's header or body."
1578 (assert (js--pitem-h-begin pitem))
1579 (assert (js--pitem-paren-depth pitem))
1581 (and (> (point) (js--pitem-h-begin pitem))
1582 (or (null (js--pitem-b-end pitem))
1583 (> (js--pitem-b-end pitem) (point)))))
1585 (defun js--parse-state-at-point ()
1586 "Parse the JavaScript program state at point.
1587 Return a list of `js--pitem' instances that apply to point, most
1588 specific first. In the worst case, the current toplevel instance
1594 (let ((pstate (or (save-excursion
1595 (js--backward-pstate))
1596 (list js--initial-pitem))))
1598 ;; Loop until we either hit a pitem at BOB or pitem ends after
1599 ;; point (or at point if we're at eob)
1600 (loop for pitem = (car pstate)
1601 until (or (eq (js--pitem-type pitem)
1603 (js--inside-pitem-p pitem))
1608 (defun js--syntactic-context-from-pstate (pstate)
1609 "Return the JavaScript syntactic context corresponding to PSTATE."
1610 (let ((type (js--pitem-type (car pstate))))
1611 (cond ((memq type '(function macro))
1617 (defun js-syntactic-context ()
1618 "Return the JavaScript syntactic context at point.
1619 When called interatively, also display a message with that
1622 (let* ((syntactic-context (js--syntactic-context-from-pstate
1623 (js--parse-state-at-point))))
1625 (when (called-interactively-p 'interactive)
1626 (message "Syntactic context: %s" syntactic-context))
1630 (defun js--class-decl-matcher (limit)
1631 "Font lock function used by `js-mode'.
1632 This performs fontification according to `js--class-styles'."
1633 (loop initially (js--ensure-cache limit)
1634 while (re-search-forward js--quick-match-re limit t)
1635 for orig-end = (match-end 0)
1636 do (goto-char (match-beginning 0))
1637 if (loop for style in js--class-styles
1638 for decl-re = (plist-get style :class-decl)
1639 if (and (memq (plist-get style :framework)
1640 js-enabled-frameworks)
1641 (memq (js-syntactic-context)
1642 (plist-get style :contexts))
1644 (looking-at decl-re))
1645 do (goto-char (match-end 0))
1648 else do (goto-char orig-end)))
1650 (defconst js--font-lock-keywords
1651 '(js--font-lock-keywords-3 js--font-lock-keywords-1
1652 js--font-lock-keywords-2
1653 js--font-lock-keywords-3)
1654 "Font lock keywords for `js-mode'. See `font-lock-keywords'.")
1656 ;; XXX: Javascript can continue a regexp literal across lines so long
1657 ;; as the newline is escaped with \. Account for that in the regexp
1660 (defconst js--regexp-literal
1662 ;; We want to match regular expressions only at the beginning of
1664 ;; FIXME: Should we also allow /regexp/ after infix operators such as +,
1666 "\\(?:\\`\\|[=([{,:;]\\)\\(?:\\s-\\|\n\\)*"
1667 "\\(/\\)\\(?:\\\\.\\|[^/*\\]\\)\\(?:\\\\.\\|[^/\\]\\)*\\(/\\)")
1668 "Regexp matching a JavaScript regular expression literal.
1669 Match groups 1 and 2 are the characters forming the beginning and
1670 end of the literal."))
1672 (defconst js-syntax-propertize-function
1673 (syntax-propertize-rules
1674 (js--regexp-literal (1 "\"") (2 "\""))))
1678 (defconst js--possibly-braceless-keyword-re
1679 (js--regexp-opt-symbol
1680 '("catch" "do" "else" "finally" "for" "if" "try" "while" "with"
1682 "Regexp matching keywords optionally followed by an opening brace.")
1684 (defconst js--indent-operator-re
1685 (concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|"
1686 (js--regexp-opt-symbol '("in" "instanceof")))
1687 "Regexp matching operators that affect indentation of continued expressions.")
1690 (defun js--looking-at-operator-p ()
1691 "Return non-nil if point is on a JavaScript operator, other than a comma."
1693 (and (looking-at js--indent-operator-re)
1694 (or (not (looking-at ":"))
1696 (and (js--re-search-backward "[?:{]\\|\\_<case\\_>" nil t)
1697 (looking-at "?")))))))
1700 (defun js--continued-expression-p ()
1701 "Return non-nil if the current line continues an expression."
1703 (back-to-indentation)
1704 (or (js--looking-at-operator-p)
1705 (and (js--re-search-backward "\n" nil t)
1707 (skip-chars-backward " \t")
1708 (or (bobp) (backward-char))
1709 (and (> (point) (point-min))
1710 (save-excursion (backward-char) (not (looking-at "[/*]/")))
1711 (js--looking-at-operator-p)
1712 (and (progn (backward-char)
1713 (not (looking-at "++\\|--\\|/[/*]"))))))))))
1716 (defun js--end-of-do-while-loop-p ()
1717 "Return non-nil if point is on the \"while\" of a do-while statement.
1718 Otherwise, return nil. A braceless do-while statement spanning
1719 several lines requires that the start of the loop is indented to
1720 the same column as the current line."
1724 (when (looking-at "\\s-*\\_<while\\_>")
1726 (skip-chars-backward "[ \t\n]*}")
1727 (looking-at "[ \t\n]*}"))
1729 (backward-list) (forward-symbol -1) (looking-at "\\_<do\\_>"))
1730 (js--re-search-backward "\\_<do\\_>" (point-at-bol) t)
1731 (or (looking-at "\\_<do\\_>")
1732 (let ((saved-indent (current-indentation)))
1733 (while (and (js--re-search-backward "^\\s-*\\_<" nil t)
1734 (/= (current-indentation) saved-indent)))
1735 (and (looking-at "\\s-*\\_<do\\_>")
1736 (not (js--re-search-forward
1737 "\\_<while\\_>" (point-at-eol) t))
1738 (= (current-indentation) saved-indent)))))))))
1741 (defun js--ctrl-statement-indentation ()
1742 "Helper function for `js--proper-indentation'.
1743 Return the proper indentation of the current line if it starts
1744 the body of a control statement without braces; otherwise, return
1747 (back-to-indentation)
1748 (when (save-excursion
1749 (and (not (eq (point-at-bol) (point-min)))
1750 (not (looking-at "[{]"))
1752 (js--re-search-backward "[[:graph:]]" nil t)
1753 (or (eobp) (forward-char))
1754 (when (= (char-before) ?\)) (backward-list))
1755 (skip-syntax-backward " ")
1756 (skip-syntax-backward "w_")
1757 (looking-at js--possibly-braceless-keyword-re))
1758 (not (js--end-of-do-while-loop-p))))
1760 (goto-char (match-beginning 0))
1761 (+ (current-indentation) js-indent-level)))))
1763 (defun js--get-c-offset (symbol anchor)
1764 (let ((c-offsets-alist
1765 (list (cons 'c js-comment-lineup-func))))
1766 (c-get-syntactic-indentation (list (cons symbol anchor)))))
1768 (defun js--proper-indentation (parse-status)
1769 "Return the proper indentation for the current line."
1771 (back-to-indentation)
1772 (cond ((nth 4 parse-status)
1773 (js--get-c-offset 'c (nth 8 parse-status)))
1774 ((nth 8 parse-status) 0) ; inside string
1775 ((js--ctrl-statement-indentation))
1776 ((eq (char-after) ?#) 0)
1777 ((save-excursion (js--beginning-of-macro)) 4)
1778 ((nth 1 parse-status)
1779 ;; A single closing paren/bracket should be indented at the
1780 ;; same level as the opening statement. Same goes for
1781 ;; "case" and "default".
1782 (let ((same-indent-p (looking-at
1783 "[]})]\\|\\_<case\\_>\\|\\_<default\\_>"))
1784 (continued-expr-p (js--continued-expression-p)))
1785 (goto-char (nth 1 parse-status)) ; go to the opening char
1786 (if (looking-at "[({[]\\s-*\\(/[/*]\\|$\\)")
1787 (progn ; nothing following the opening paren/bracket
1788 (skip-syntax-backward " ")
1789 (when (eq (char-before) ?\)) (backward-list))
1790 (back-to-indentation)
1791 (cond (same-indent-p
1794 (+ (current-column) (* 2 js-indent-level)
1795 js-expr-indent-offset))
1797 (+ (current-column) js-indent-level
1798 (case (char-after (nth 1 parse-status))
1799 (?\( js-paren-indent-offset)
1800 (?\[ js-square-indent-offset)
1801 (?\{ js-curly-indent-offset))))))
1802 ;; If there is something following the opening
1803 ;; paren/bracket, everything else should be indented at
1805 (unless same-indent-p
1807 (skip-chars-forward " \t"))
1810 ((js--continued-expression-p)
1811 (+ js-indent-level js-expr-indent-offset))
1814 (defun js-indent-line ()
1815 "Indent the current line as JavaScript."
1819 (let* ((parse-status
1820 (save-excursion (syntax-ppss (point-at-bol))))
1821 (offset (- (current-column) (current-indentation))))
1822 (indent-line-to (js--proper-indentation parse-status))
1823 (when (> offset 0) (forward-char offset)))))
1827 (defun js-c-fill-paragraph (&optional justify)
1828 "Fill the paragraph with `c-fill-paragraph'."
1830 (flet ((c-forward-sws
1832 (js--forward-syntactic-ws limit))
1835 (js--backward-syntactic-ws limit))
1836 (c-beginning-of-macro
1838 (js--beginning-of-macro limit)))
1839 (let ((fill-paragraph-function 'c-fill-paragraph))
1840 (c-fill-paragraph justify))))
1842 ;;; Type database and Imenu
1844 ;; We maintain a cache of semantic information, i.e., the classes and
1845 ;; functions we've encountered so far. In order to avoid having to
1846 ;; re-parse the buffer on every change, we cache the parse state at
1847 ;; each interesting point in the buffer. Each parse state is a
1848 ;; modified copy of the previous one, or in the case of the first
1849 ;; parse state, the empty state.
1851 ;; The parse state itself is just a stack of js--pitem
1852 ;; instances. It starts off containing one element that is never
1853 ;; closed, that is initially js--initial-pitem.
1857 (defun js--pitem-format (pitem)
1858 (let ((name (js--pitem-name pitem))
1859 (type (js--pitem-type pitem)))
1861 (format "name:%S type:%S"
1865 (plist-get type :name)))))
1867 (defun js--make-merged-item (item child name-parts)
1868 "Helper function for `js--splice-into-items'.
1869 Return a new item that is the result of merging CHILD into
1870 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1871 that we haven't consumed yet."
1872 (js--debug "js--make-merged-item: {%s} into {%s}"
1873 (js--pitem-format child)
1874 (js--pitem-format item))
1876 ;; If the item we're merging into isn't a class, make it into one
1877 (unless (consp (js--pitem-type item))
1878 (js--debug "js--make-merged-item: changing dest into class")
1879 (setq item (make-js--pitem
1880 :children (list item)
1882 ;; Use the child's class-style if it's available
1883 :type (if (atom (js--pitem-type child))
1884 js--dummy-class-style
1885 (js--pitem-type child))
1887 :name (js--pitem-strname item))))
1889 ;; Now we can merge either a function or a class into a class
1892 (js--debug "js--make-merged-item: recursing")
1893 ;; if we have more name-parts to go before we get to the
1894 ;; bottom of the class hierarchy, call the merger
1896 (js--splice-into-items (car item) child
1899 ((atom (js--pitem-type child))
1900 (js--debug "js--make-merged-item: straight merge")
1901 ;; Not merging a class, but something else, so just prepend
1903 (cons child (car item)))
1906 ;; Otherwise, merge the new child's items into those
1908 (js--debug "js--make-merged-item: merging class contents")
1909 (append (car child) (car item))))
1912 (defun js--pitem-strname (pitem)
1913 "Last part of the name of PITEM, as a string or symbol."
1914 (let ((name (js--pitem-name pitem)))
1919 (defun js--splice-into-items (items child name-parts)
1920 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1921 If a class doesn't exist in the tree, create it. Return
1922 the new items list. NAME-PARTS is a list of strings given
1923 the broken-down class name of the item to insert."
1925 (let ((top-name (car name-parts))
1927 new-items last-new-item new-cons)
1929 (js--debug "js--splice-into-items: name-parts: %S items:%S"
1931 (mapcar #'js--pitem-name items))
1933 (assert (stringp top-name))
1934 (assert (> (length top-name) 0))
1936 ;; If top-name isn't found in items, then we build a copy of items
1937 ;; and throw it away. But that's okay, since most of the time, we
1938 ;; *will* find an instance.
1940 (while (and item-ptr
1941 (cond ((equal (js--pitem-strname (car item-ptr)) top-name)
1942 ;; Okay, we found an entry with the right name. Splice
1943 ;; the merged item into the list...
1944 (setq new-cons (cons (js--make-merged-item
1945 (car item-ptr) child
1950 (setcdr last-new-item new-cons)
1951 (setq new-items new-cons))
1953 ;; ...and terminate the loop
1957 ;; Otherwise, copy the current cons and move onto the
1958 ;; text. This is tricky; we keep track of the tail of
1959 ;; the list that begins with new-items in
1961 (setq new-cons (cons (car item-ptr) nil))
1963 (setcdr last-new-item new-cons)
1964 (setq new-items new-cons))
1965 (setq last-new-item new-cons)
1967 ;; Go to the next cell in items
1968 (setq item-ptr (cdr item-ptr))))))
1971 ;; Yay! We stopped because we found something, not because
1972 ;; we ran out of items to search. Just return the new
1975 (js--debug "search succeeded: %S" name-parts)
1978 ;; We didn't find anything. If the child is a class and we don't
1979 ;; have any classes to drill down into, just push that class;
1980 ;; otherwise, make a fake class and carry on.
1981 (js--debug "search failed: %S" name-parts)
1982 (cons (if (cdr name-parts)
1983 ;; We have name-parts left to process. Make a fake
1984 ;; class for this particular part...
1986 ;; ...and recursively digest the rest of the name
1987 :children (js--splice-into-items
1988 nil child (cdr name-parts))
1989 :type js--dummy-class-style
1992 ;; Otherwise, this is the only name we have, so stick
1993 ;; the item on the front of the list
1997 (defun js--pitem-add-child (pitem child)
1998 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
1999 (assert (integerp (js--pitem-h-begin child)))
2000 (assert (if (consp (js--pitem-name child))
2001 (loop for part in (js--pitem-name child)
2002 always (stringp part))
2005 ;; This trick works because we know (based on our defstructs) that
2006 ;; the child list is always the first element, and so the second
2007 ;; element and beyond can be shared when we make our "copy".
2010 (let ((name (js--pitem-name child))
2011 (type (js--pitem-type child)))
2013 (cond ((cdr-safe name) ; true if a list of at least two elements
2014 ;; Use slow path because we need class lookup
2015 (js--splice-into-items (car pitem) child name))
2018 (plist-get type :prototype))
2020 ;; Use slow path because we need class merging. We know
2021 ;; name is a list here because down in
2022 ;; `js--ensure-cache', we made sure to only add
2023 ;; class entries with lists for :name
2024 (assert (consp name))
2025 (js--splice-into-items (car pitem) child name))
2029 (cons child (car pitem)))))
2033 (defun js--maybe-make-marker (location)
2034 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2035 (if imenu-use-markers
2036 (set-marker (make-marker) location)
2039 (defun js--pitems-to-imenu (pitems unknown-ctr)
2040 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2042 (let (imenu-items pitem pitem-type pitem-name subitems)
2044 (while (setq pitem (pop pitems))
2045 (setq pitem-type (js--pitem-type pitem))
2046 (setq pitem-name (js--pitem-strname pitem))
2047 (when (eq pitem-name t)
2048 (setq pitem-name (format "[unknown %s]"
2049 (incf (car unknown-ctr)))))
2052 ((memq pitem-type '(function macro))
2053 (assert (integerp (js--pitem-h-begin pitem)))
2054 (push (cons pitem-name
2055 (js--maybe-make-marker
2056 (js--pitem-h-begin pitem)))
2059 ((consp pitem-type) ; class definition
2060 (setq subitems (js--pitems-to-imenu
2061 (js--pitem-children pitem)
2064 (push (cons pitem-name subitems)
2067 ((js--pitem-h-begin pitem)
2068 (assert (integerp (js--pitem-h-begin pitem)))
2069 (setq subitems (list
2071 (js--maybe-make-marker
2072 (js--pitem-h-begin pitem)))))
2073 (push (cons pitem-name subitems)
2076 (t (error "Unknown item type: %S" pitem-type))))
2080 (defun js--imenu-create-index ()
2081 "Return an imenu index for the current buffer."
2085 (goto-char (point-max))
2087 (assert (or (= (point-min) (point-max))
2088 (eq js--last-parse-pos (point))))
2089 (when js--last-parse-pos
2090 (let ((state js--state-at-last-parse-pos)
2091 (unknown-ctr (cons -1 nil)))
2093 ;; Make sure everything is closed
2096 (cons (js--pitem-add-child (second state) (car state))
2099 (assert (= (length state) 1))
2101 ;; Convert the new-finalized state into what imenu expects
2102 (js--pitems-to-imenu
2103 (car (js--pitem-children state))
2106 ;; Silence the compiler.
2107 (defvar which-func-imenu-joiner-function)
2109 (defun js--which-func-joiner (parts)
2110 (mapconcat #'identity parts "."))
2112 (defun js--imenu-to-flat (items prefix symbols)
2113 (loop for item in items
2114 if (imenu--subalist-p item)
2115 do (js--imenu-to-flat
2116 (cdr item) (concat prefix (car item) ".")
2119 do (let* ((name (concat prefix (car item)))
2123 (while (gethash name2 symbols)
2124 (setq name2 (format "%s<%d>" name (incf ctr))))
2126 (puthash name2 (cdr item) symbols))))
2128 (defun js--get-all-known-symbols ()
2129 "Return a hash table of all JavaScript symbols.
2130 This searches all existing `js-mode' buffers. Each key is the
2131 name of a symbol (possibly disambiguated with <N>, where N > 1),
2132 and each value is a marker giving the location of that symbol."
2133 (loop with symbols = (make-hash-table :test 'equal)
2134 with imenu-use-markers = t
2135 for buffer being the buffers
2136 for imenu-index = (with-current-buffer buffer
2137 (when (derived-mode-p 'js-mode)
2138 (js--imenu-create-index)))
2139 do (js--imenu-to-flat imenu-index "" symbols)
2140 finally return symbols))
2142 (defvar js--symbol-history nil
2143 "History of entered JavaScript symbols.")
2145 (defun js--read-symbol (symbols-table prompt &optional initial-input)
2146 "Helper function for `js-find-symbol'.
2147 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2148 one from `js--get-all-known-symbols', using prompt PROMPT and
2149 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2150 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2156 (let ((choice (ido-completing-read
2158 (loop for key being the hash-keys of symbols-table
2160 nil t initial-input 'js--symbol-history)))
2161 (cons choice (gethash choice symbols-table))))
2163 (defun js--guess-symbol-at-point ()
2164 (let ((bounds (bounds-of-thing-at-point 'symbol)))
2167 (goto-char (car bounds))
2168 (when (eq (char-before) ?.)
2170 (setf (car bounds) (point))))
2171 (buffer-substring (car bounds) (cdr bounds)))))
2173 (defvar find-tag-marker-ring) ; etags
2175 (defun js-find-symbol (&optional arg)
2176 "Read a JavaScript symbol and jump to it.
2177 With a prefix argument, restrict symbols to those from the
2178 current buffer. Pushes a mark onto the tag ring just like
2182 (let (symbols marker)
2184 (setq symbols (js--get-all-known-symbols))
2185 (setq symbols (make-hash-table :test 'equal))
2186 (js--imenu-to-flat (js--imenu-create-index)
2189 (setq marker (cdr (js--read-symbol
2191 (js--guess-symbol-at-point))))
2193 (ring-insert find-tag-marker-ring (point-marker))
2194 (switch-to-buffer (marker-buffer marker))
2196 (goto-char marker)))
2198 ;;; MozRepl integration
2200 (put 'js-moz-bad-rpc 'error-conditions '(error timeout))
2201 (put 'js-moz-bad-rpc 'error-message "Mozilla RPC Error")
2203 (put 'js-js-error 'error-conditions '(error js-error))
2204 (put 'js-js-error 'error-message "Javascript Error")
2206 (defun js--wait-for-matching-output
2207 (process regexp timeout &optional start)
2208 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2209 On timeout, return nil. On success, return t with match data
2210 set. If START is non-nil, look for output starting from START.
2211 Otherwise, use the current value of `process-mark'."
2212 (with-current-buffer (process-buffer process)
2213 (loop with start-pos = (or start
2214 (marker-position (process-mark process)))
2215 with end-time = (+ (float-time) timeout)
2216 for time-left = (- end-time (float-time))
2217 do (goto-char (point-max))
2218 if (looking-back regexp start-pos) return t
2219 while (> time-left 0)
2220 do (accept-process-output process time-left nil t)
2221 do (goto-char (process-mark process))
2224 (list (format "Timed out waiting for output matching %S" regexp))))))
2226 (defstruct js--js-handle
2227 ;; Integer, mirrors the value we see in JS
2228 (id nil :read-only t)
2230 ;; Process to which this thing belongs
2231 (process nil :read-only t))
2233 (defun js--js-handle-expired-p (x)
2234 (not (eq (js--js-handle-process x)
2235 (inferior-moz-process))))
2237 (defvar js--js-references nil
2238 "Maps Elisp JavaScript proxy objects to their JavaScript IDs.")
2240 (defvar js--js-process nil
2241 "The most recent MozRepl process object.")
2243 (defvar js--js-gc-idle-timer nil
2244 "Idle timer for cleaning up JS object references.")
2246 (defvar js--js-last-gcs-done nil)
2248 (defconst js--moz-interactor
2249 (replace-regexp-in-string
2251 ; */" Make Emacs happy
2253 repl.defineInteractor('js', {
2254 onStart: function onStart(repl) {
2255 if(!repl._jsObjects) {
2256 repl._jsObjects = {};
2258 repl._jsGC = this._jsGC;
2263 _jsGC: function _jsGC(ids_in_use) {
2264 var objects = this._jsObjects;
2268 for(var pn in objects) {
2269 keys.push(Number(pn));
2272 keys.sort(function(x, y) x - y);
2273 ids_in_use.sort(function(x, y) x - y);
2277 while(i < ids_in_use.length && j < keys.length) {
2278 var id = ids_in_use[i++];
2279 while(j < keys.length && keys[j] !== id) {
2280 var k_id = keys[j++];
2281 delete objects[k_id];
2287 while(j < keys.length) {
2288 var k_id = keys[j++];
2289 delete objects[k_id];
2296 _mkArray: function _mkArray() {
2298 for(var i = 0; i < arguments.length; ++i) {
2299 result.push(arguments[i]);
2304 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2305 if(typeof parts === 'string') {
2312 if(typeof obj === 'string') {
2315 } else if(parts.length < 2) {
2316 throw new Error('expected at least 2 arguments');
2319 for(var i = start; i < parts.length - 1; ++i) {
2320 obj = obj[parts[i]];
2323 return [obj, parts[parts.length - 1]];
2326 _getProp: function _getProp(/*...*/) {
2327 if(arguments.length === 0) {
2328 throw new Error('no arguments supplied to getprop');
2331 if(arguments.length === 1 &&
2332 (typeof arguments[0]) !== 'string')
2334 return arguments[0];
2337 var [obj, propname] = this._parsePropDescriptor(arguments);
2338 return obj[propname];
2341 _putProp: function _putProp(properties, value) {
2342 var [obj, propname] = this._parsePropDescriptor(properties);
2343 obj[propname] = value;
2346 _delProp: function _delProp(propname) {
2347 var [obj, propname] = this._parsePropDescriptor(arguments);
2348 delete obj[propname];
2351 _typeOf: function _typeOf(thing) {
2352 return typeof thing;
2355 _callNew: function(constructor) {
2356 if(typeof constructor === 'string')
2358 constructor = window[constructor];
2359 } else if(constructor.length === 1 &&
2360 typeof constructor[0] !== 'string')
2362 constructor = constructor[0];
2364 var [obj,propname] = this._parsePropDescriptor(constructor);
2365 constructor = obj[propname];
2368 /* Hacky, but should be robust */
2369 var s = 'new constructor(';
2370 for(var i = 1; i < arguments.length; ++i) {
2375 s += 'arguments[' + i + ']';
2382 _callEval: function(thisobj, js) {
2383 return eval.call(thisobj, js);
2386 getPrompt: function getPrompt(repl) {
2390 _lookupObject: function _lookupObject(repl, id) {
2391 if(typeof id === 'string') {
2414 throw new Error('No object with special id:' + id);
2418 var ret = repl._jsObjects[id];
2419 if(ret === undefined) {
2420 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2425 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2426 if(typeof value !== 'object' && typeof value !== 'function') {
2427 throw new Error('_findOrAllocateObject called on non-object('
2428 + typeof(value) + '): '
2432 for(var id in repl._jsObjects) {
2434 var obj = repl._jsObjects[id];
2440 var id = ++repl._jsLastID;
2441 repl._jsObjects[id] = value;
2445 _fixupList: function _fixupList(repl, list) {
2446 for(var i = 0; i < list.length; ++i) {
2447 if(list[i] instanceof Array) {
2448 this._fixupList(repl, list[i]);
2449 } else if(typeof list[i] === 'object') {
2452 var parts = obj.funcall;
2453 this._fixupList(repl, parts);
2454 var [thisobj, func] = this._parseFunc(parts[0]);
2455 list[i] = func.apply(thisobj, parts.slice(1));
2456 } else if(obj.objid) {
2457 list[i] = this._lookupObject(repl, obj.objid);
2459 throw new Error('Unknown object type: ' + obj.toSource());
2465 _parseFunc: function(func) {
2468 if(typeof func === 'string') {
2469 func = window[func];
2470 } else if(func instanceof Array) {
2471 if(func.length === 1 && typeof func[0] !== 'string') {
2474 [thisobj, func] = this._parsePropDescriptor(func);
2475 func = thisobj[func];
2479 return [thisobj,func];
2482 _encodeReturn: function(value, array_as_mv) {
2485 if(value === null) {
2486 ret = ['special', 'null'];
2487 } else if(value === true) {
2488 ret = ['special', 'true'];
2489 } else if(value === false) {
2490 ret = ['special', 'false'];
2491 } else if(value === undefined) {
2492 ret = ['special', 'undefined'];
2493 } else if(typeof value === 'number') {
2495 ret = ['special', 'NaN'];
2496 } else if(value === Infinity) {
2497 ret = ['special', 'Infinity'];
2498 } else if(value === -Infinity) {
2499 ret = ['special', '-Infinity'];
2501 ret = ['atom', value];
2503 } else if(typeof value === 'string') {
2504 ret = ['atom', value];
2505 } else if(array_as_mv && value instanceof Array) {
2506 ret = ['array', value.map(this._encodeReturn, this)];
2508 ret = ['objid', this._findOrAllocateObject(repl, value)];
2514 _handleInputLine: function _handleInputLine(repl, line) {
2516 var array_as_mv = false;
2519 if(line[0] === '*') {
2521 line = line.substring(1);
2523 var parts = eval(line);
2524 this._fixupList(repl, parts);
2525 var [thisobj, func] = this._parseFunc(parts[0]);
2526 ret = this._encodeReturn(
2527 func.apply(thisobj, parts.slice(1)),
2530 ret = ['error', x.toString() ];
2533 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2534 repl.print(JSON.encode(ret));
2538 handleInput: function handleInput(repl, chunk) {
2539 this._input += chunk;
2541 while(match = this._input.match(/.*\\n/)) {
2544 if(line === 'EXIT\\n') {
2545 repl.popInteractor();
2550 this._input = this._input.substring(line.length);
2551 this._handleInputLine(repl, line);
2558 "String to set MozRepl up into a simple-minded evaluation mode.")
2560 (defun js--js-encode-value (x)
2561 "Marshall the given value for JS.
2562 Strings and numbers are JSON-encoded. Lists (including nil) are
2563 made into JavaScript array literals and their contents encoded
2564 with `js--js-encode-value'."
2565 (cond ((stringp x) (json-encode-string x))
2566 ((numberp x) (json-encode-number x))
2567 ((symbolp x) (format "{objid:%S}" (symbol-name x)))
2568 ((js--js-handle-p x)
2570 (when (js--js-handle-expired-p x)
2571 (error "Stale JS handle"))
2573 (format "{objid:%s}" (js--js-handle-id x)))
2576 (if (eq (car-safe x) 'js--funcall)
2577 (format "{funcall:[%s]}"
2578 (mapconcat #'js--js-encode-value (cdr x) ","))
2580 "[" (mapconcat #'js--js-encode-value x ",") "]")))
2582 (error "Unrecognized item: %S" x))))
2584 (defconst js--js-prompt-regexp "\\(repl[0-9]*\\)> $")
2585 (defconst js--js-repl-prompt-regexp "^EVAL>$")
2586 (defvar js--js-repl-depth 0)
2588 (defun js--js-wait-for-eval-prompt ()
2589 (js--wait-for-matching-output
2590 (inferior-moz-process)
2591 js--js-repl-prompt-regexp js-js-timeout
2593 ;; start matching against the beginning of the line in
2594 ;; order to catch a prompt that's only partially arrived
2595 (save-excursion (forward-line 0) (point))))
2597 (defun js--js-enter-repl ()
2598 (inferior-moz-process) ; called for side-effect
2599 (with-current-buffer inferior-moz-buffer
2600 (goto-char (point-max))
2602 ;; Do some initialization the first time we see a process
2603 (unless (eq (inferior-moz-process) js--js-process)
2604 (setq js--js-process (inferior-moz-process))
2605 (setq js--js-references (make-hash-table :test 'eq :weakness t))
2606 (setq js--js-repl-depth 0)
2608 ;; Send interactor definition
2609 (comint-send-string js--js-process js--moz-interactor)
2610 (comint-send-string js--js-process
2611 (concat "(" moz-repl-name ")\n"))
2612 (js--wait-for-matching-output
2613 (inferior-moz-process) js--js-prompt-regexp
2617 (when (looking-back js--js-prompt-regexp
2618 (save-excursion (forward-line 0) (point)))
2619 (setq js--js-repl-depth 0))
2621 (if (> js--js-repl-depth 0)
2622 ;; If js--js-repl-depth > 0, we *should* be seeing an
2623 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2625 (js--js-wait-for-eval-prompt)
2627 ;; Otherwise, tell Mozilla to enter the interactor mode
2628 (insert (match-string-no-properties 1)
2629 ".pushInteractor('js')")
2630 (comint-send-input nil t)
2631 (js--wait-for-matching-output
2632 (inferior-moz-process) js--js-repl-prompt-regexp
2635 (incf js--js-repl-depth)))
2637 (defun js--js-leave-repl ()
2638 (assert (> js--js-repl-depth 0))
2639 (when (= 0 (decf js--js-repl-depth))
2640 (with-current-buffer inferior-moz-buffer
2641 (goto-char (point-max))
2642 (js--js-wait-for-eval-prompt)
2644 (comint-send-input nil t)
2645 (js--wait-for-matching-output
2646 (inferior-moz-process) js--js-prompt-regexp
2649 (defsubst js--js-not (value)
2650 (memq value '(nil null false undefined)))
2652 (defsubst js--js-true (value)
2653 (not (js--js-not value)))
2656 (defun js--optimize-arglist (arglist)
2657 "Convert immediate js< and js! references to deferred ones."
2658 (loop for item in arglist
2659 if (eq (car-safe item) 'js<)
2660 collect (append (list 'list ''js--funcall
2661 '(list 'interactor "_getProp"))
2662 (js--optimize-arglist (cdr item)))
2663 else if (eq (car-safe item) 'js>)
2664 collect (append (list 'list ''js--funcall
2665 '(list 'interactor "_putProp"))
2667 (if (atom (cadr item))
2671 (list 'list ''js--funcall
2672 '(list 'interactor "_mkArray"))
2673 (js--optimize-arglist (cadr item)))))
2674 (js--optimize-arglist (cddr item)))
2675 else if (eq (car-safe item) 'js!)
2676 collect (destructuring-bind (ignored function &rest body) item
2677 (append (list 'list ''js--funcall
2678 (if (consp function)
2680 (js--optimize-arglist function))
2682 (js--optimize-arglist body)))
2686 (defmacro js--js-get-service (class-name interface-name)
2687 `(js! ("Components" "classes" ,class-name "getService")
2688 (js< "Components" "interfaces" ,interface-name)))
2690 (defmacro js--js-create-instance (class-name interface-name)
2691 `(js! ("Components" "classes" ,class-name "createInstance")
2692 (js< "Components" "interfaces" ,interface-name)))
2694 (defmacro js--js-qi (object interface-name)
2695 `(js! (,object "QueryInterface")
2696 (js< "Components" "interfaces" ,interface-name)))
2698 (defmacro with-js (&rest forms)
2699 "Run FORMS with the Mozilla repl set up for js commands.
2700 Inside the lexical scope of `with-js', `js?', `js!',
2701 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2702 `js-create-instance', and `js-qi' are defined."
2707 (macrolet ((js? (&rest body) `(js--js-true ,@body))
2708 (js! (function &rest body)
2710 ,(if (consp function)
2712 (js--optimize-arglist function))
2714 ,@(js--optimize-arglist body)))
2716 (js-new (function &rest body)
2718 ,(if (consp function)
2720 (js--optimize-arglist function))
2724 (js-eval (thisobj js)
2726 ,@(js--optimize-arglist
2727 (list thisobj js))))
2729 (js-list (&rest args)
2731 ,@(js--optimize-arglist args)))
2733 (js-get-service (&rest args)
2734 `(js--js-get-service
2735 ,@(js--optimize-arglist args)))
2737 (js-create-instance (&rest args)
2738 `(js--js-create-instance
2739 ,@(js--optimize-arglist args)))
2743 ,@(js--optimize-arglist args)))
2745 (js< (&rest body) `(js--js-get
2746 ,@(js--optimize-arglist body)))
2749 '(interactor "_putProp")
2752 (js--optimize-arglist props))
2754 ,@(js--optimize-arglist (list value))
2756 (js-handle? (arg) `(js--js-handle-p ,arg)))
2758 (js--js-leave-repl))))
2760 (defvar js--js-array-as-list nil
2761 "Whether to listify any Array returned by a Mozilla function.
2762 If nil, the whole Array is treated as a JS symbol.")
2764 (defun js--js-decode-retval (result)
2765 (ecase (intern (first result))
2766 (atom (second result))
2767 (special (intern (second result)))
2769 (mapcar #'js--js-decode-retval (second result)))
2771 (or (gethash (second result)
2773 (puthash (second result)
2776 :process (inferior-moz-process))
2777 js--js-references)))
2779 (error (signal 'js-js-error (list (second result))))))
2781 (defun js--js-funcall (function &rest arguments)
2782 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2783 If function is a string, look it up as a property on the global
2784 object and use the global object for `this'.
2785 If FUNCTION is a list with one element, use that element as the
2786 function with the global object for `this', except that if that
2787 single element is a string, look it up on the global object.
2788 If FUNCTION is a list with more than one argument, use the list
2789 up to the last value as a property descriptor and the last
2790 argument as a function."
2793 (let ((argstr (js--js-encode-value
2794 (cons function arguments))))
2796 (with-current-buffer inferior-moz-buffer
2798 (when js--js-array-as-list
2801 (comint-send-input nil t)
2802 (js--wait-for-matching-output
2803 (inferior-moz-process) "EVAL>"
2805 (goto-char comint-last-input-end)
2808 (let* ((json-array-type 'list)
2809 (result (prog1 (json-read)
2810 (goto-char (point-max)))))
2811 (js--js-decode-retval result))))))
2813 (defun js--js-new (constructor &rest arguments)
2814 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2815 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2816 (apply #'js--js-funcall
2817 '(interactor "_callNew")
2818 constructor arguments))
2820 (defun js--js-eval (thisobj js)
2821 (js--js-funcall '(interactor "_callEval") thisobj js))
2823 (defun js--js-list (&rest arguments)
2824 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2825 (let ((js--js-array-as-list t))
2826 (apply #'js--js-funcall '(interactor "_mkArray")
2829 (defun js--js-get (&rest props)
2830 (apply #'js--js-funcall '(interactor "_getProp") props))
2832 (defun js--js-put (props value)
2833 (js--js-funcall '(interactor "_putProp") props value))
2835 (defun js-gc (&optional force)
2836 "Tell the repl about any objects we don't reference anymore.
2837 With argument, run even if no intervening GC has happened."
2841 (setq js--js-last-gcs-done nil))
2843 (let ((this-gcs-done gcs-done) keys num)
2844 (when (and js--js-references
2845 (boundp 'inferior-moz-buffer)
2846 (buffer-live-p inferior-moz-buffer)
2848 ;; Don't bother running unless we've had an intervening
2849 ;; garbage collection; without a gc, nothing is deleted
2850 ;; from the weak hash table, so it's pointless telling
2851 ;; MozRepl about that references we still hold
2852 (not (eq js--js-last-gcs-done this-gcs-done))
2854 ;; Are we looking at a normal prompt? Make sure not to
2855 ;; interrupt the user if he's doing something
2856 (with-current-buffer inferior-moz-buffer
2858 (goto-char (point-max))
2859 (looking-back js--js-prompt-regexp
2860 (save-excursion (forward-line 0) (point))))))
2862 (setq keys (loop for x being the hash-keys
2863 of js--js-references
2865 (setq num (js--js-funcall '(repl "_jsGC") (or keys [])))
2867 (setq js--js-last-gcs-done this-gcs-done)
2868 (when (called-interactively-p 'interactive)
2869 (message "Cleaned %s entries" num))
2873 (run-with-idle-timer 30 t #'js-gc)
2876 "Evaluate the JavaScript in JS and return JSON-decoded result."
2877 (interactive "MJavascript to evaluate: ")
2879 (let* ((content-window (js--js-content-window
2880 (js--get-js-context)))
2881 (result (js-eval content-window js)))
2882 (when (called-interactively-p 'interactive)
2883 (message "%s" (js! "String" result)))
2886 (defun js--get-tabs ()
2887 "Enumerate all JavaScript contexts available.
2888 Each context is a list:
2889 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2890 (TITLE URL WINDOW) for windows
2892 All tabs of a given window are grouped together. The most recent
2893 window is first. Within each window, the tabs are returned
2898 (loop with window-mediator = (js! ("Components" "classes"
2899 "@mozilla.org/appshell/window-mediator;1"
2901 (js< "Components" "interfaces"
2902 "nsIWindowMediator"))
2903 with enumerator = (js! (window-mediator "getEnumerator") nil)
2905 while (js? (js! (enumerator "hasMoreElements")))
2906 for window = (js! (enumerator "getNext"))
2907 for window-info = (js-list window
2908 (js< window "document" "title")
2909 (js! (window "location" "toString"))
2910 (js< window "closed")
2911 (js< window "windowState"))
2913 unless (or (js? (fourth window-info))
2914 (eq (fifth window-info) 2))
2915 do (push window-info windows))
2917 (loop for window-info in windows
2918 for window = (first window-info)
2919 collect (list (second window-info)
2923 for gbrowser = (js< window "gBrowser")
2924 if (js-handle? gbrowser)
2926 for x below (js< gbrowser "browsers" "length")
2927 collect (js-list (js< gbrowser
2951 (defvar js-read-tab-history nil)
2953 (defun js--read-tab (prompt)
2954 "Read a Mozilla tab with prompt PROMPT.
2955 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2956 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2957 browser, respectively."
2965 (lexical-let ((tabs (js--get-tabs)) selected-tab-cname
2966 selected-tab prev-hitab)
2968 ;; Disambiguate names
2969 (setq tabs (loop with tab-names = (make-hash-table :test 'equal)
2971 for cname = (format "%s (%s)" (second tab) (first tab))
2972 for num = (incf (gethash cname tab-names -1))
2974 do (setq cname (format "%s <%d>" cname num))
2975 collect (cons cname tab)))
2977 (labels ((find-tab-by-cname
2979 (loop for tab in tabs
2980 if (equal (car tab) cname)
2983 (mogrify-highlighting
2986 ;; Hack to reduce the number of
2987 ;; round-trips to mozilla
2992 (push '(js! ((fourth hitab) "setAttribute")
2994 "color: red; font-weight: bold")
2997 ;; Highlight window proper
2998 (push '(js! ((third hitab)
3001 "border: 8px solid red")
3004 ;; Select tab, when appropriate
3005 (when js-js-switch-tabs
3007 '(js> ((fifth hitab) "selectedTab") (fourth hitab))
3010 ;; Hilighting whole window
3012 (push '(js! ((third hitab) "document"
3013 "documentElement" "setAttribute")
3015 (concat "-moz-appearance: none;"
3016 "border: 8px solid red;"))
3020 ;; Unhighlighting tab
3022 (push '(js! ((fourth unhitab) "setAttribute") "style" "")
3024 (push '(js! ((third unhitab) "setAttribute") "style" "")
3027 ;; Unhighlighting window
3029 (push '(js! ((third unhitab) "document"
3030 "documentElement" "setAttribute")
3034 (eval (list 'with-js
3035 (cons 'js-list (nreverse cmds))))))
3039 (let* ((tab (find-tab-by-cname (car ido-matches))))
3040 (mogrify-highlighting tab prev-hitab)
3041 (setq prev-hitab tab)))
3045 ;; Fiddle with the match list a bit: if our first match
3046 ;; is a tabbrowser window, rotate the match list until
3047 ;; the active tab comes up
3048 (let ((matched-tab (find-tab-by-cname (car ido-matches))))
3049 (when (and matched-tab
3050 (null (fourth matched-tab))
3051 (equal "navigator:browser"
3052 (js! ((third matched-tab)
3058 (loop with tab-to-match = (js< (third matched-tab)
3063 for match in ido-matches
3064 for candidate-tab = (find-tab-by-cname match)
3065 if (eq (fourth candidate-tab) tab-to-match)
3066 do (setq ido-cur-list (ido-chop ido-cur-list match))
3069 (add-hook 'post-command-hook #'command-hook t t)))
3073 (setq selected-tab-cname
3074 (let ((ido-minibuffer-setup-hook
3075 (cons #'setup-hook ido-minibuffer-setup-hook)))
3076 (ido-completing-read
3080 'js-read-tab-history)))
3083 (mogrify-highlighting nil prev-hitab)
3084 (setq prev-hitab nil)))
3086 (add-to-history 'js-read-tab-history selected-tab-cname)
3088 (setq selected-tab (loop for tab in tabs
3089 if (equal (car tab) selected-tab-cname)
3092 (if (fourth selected-tab)
3093 (cons 'browser (third selected-tab))
3094 (cons 'window (third selected-tab)))))))
3096 (defun js--guess-eval-defun-info (pstate)
3097 "Helper function for `js-eval-defun'.
3098 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3099 strings making up the class name and NAME is the name of the
3101 (cond ((and (= (length pstate) 3)
3102 (eq (js--pitem-type (first pstate)) 'function)
3103 (= (length (js--pitem-name (first pstate))) 1)
3104 (consp (js--pitem-type (second pstate))))
3106 (append (js--pitem-name (second pstate))
3107 (list (first (js--pitem-name (first pstate))))))
3109 ((and (= (length pstate) 2)
3110 (eq (js--pitem-type (first pstate)) 'function))
3113 (butlast (js--pitem-name (first pstate)))
3114 (list (car (last (js--pitem-name (first pstate)))))))
3116 (t (error "Function not a toplevel defun or class member"))))
3118 (defvar js--js-context nil
3119 "The current JavaScript context.
3120 This is a cons like the one returned from `js--read-tab'.
3121 Change with `js-set-js-context'.")
3123 (defconst js--js-inserter
3124 "(function(func_info,func) {
3125 func_info.unshift('window');
3127 for(var i = 1; i < func_info.length - 1; ++i) {
3128 var next = obj[func_info[i]];
3129 if(typeof next !== 'object' && typeof next !== 'function') {
3130 next = obj.prototype && obj.prototype[func_info[i]];
3131 if(typeof next !== 'object' && typeof next !== 'function') {
3132 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3133 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3137 func_info.splice(i+1, 0, 'prototype');
3142 obj[func_info[i]] = func;
3143 alert('Successfully updated '+func_info.join('.'));
3146 (defun js-set-js-context (context)
3147 "Set the JavaScript context to CONTEXT.
3148 When called interactively, prompt for CONTEXT."
3149 (interactive (list (js--read-tab "Javascript Context: ")))
3150 (setq js--js-context context))
3152 (defun js--get-js-context ()
3153 "Return a valid JavaScript context.
3154 If one hasn't been set, or if it's stale, prompt for a new one."
3156 (when (or (null js--js-context)
3157 (js--js-handle-expired-p (cdr js--js-context))
3158 (ecase (car js--js-context)
3159 (window (js? (js< (cdr js--js-context) "closed")))
3160 (browser (not (js? (js< (cdr js--js-context)
3161 "contentDocument"))))))
3162 (setq js--js-context (js--read-tab "Javascript Context: ")))
3165 (defun js--js-content-window (context)
3167 (ecase (car context)
3168 (window (cdr context))
3169 (browser (js< (cdr context)
3170 "contentWindow" "wrappedJSObject")))))
3172 (defun js--make-nsilocalfile (path)
3174 (let ((file (js-create-instance "@mozilla.org/file/local;1"
3176 (js! (file "initWithPath") path)
3179 (defun js--js-add-resource-alias (alias path)
3181 (let* ((io-service (js-get-service "@mozilla.org/network/io-service;1"
3183 (res-prot (js! (io-service "getProtocolHandler") "resource"))
3184 (res-prot (js-qi res-prot "nsIResProtocolHandler"))
3185 (path-file (js--make-nsilocalfile path))
3186 (path-uri (js! (io-service "newFileURI") path-file)))
3187 (js! (res-prot "setSubstitution") alias path-uri))))
3189 (defun* js-eval-defun ()
3190 "Update a Mozilla tab using the JavaScript defun at point."
3193 ;; This function works by generating a temporary file that contains
3194 ;; the function we'd like to insert. We then use the elisp-js bridge
3195 ;; to command mozilla to load this file by inserting a script tag
3196 ;; into the document we set. This way, debuggers and such will have
3197 ;; a way to find the source of the just-inserted function.
3199 ;; We delete the temporary file if there's an error, but otherwise
3200 ;; we add an unload event listener on the Mozilla side to delete the
3204 (let (begin end pstate defun-info temp-name defun-body)
3208 (js-beginning-of-defun)
3209 (re-search-forward "\\_<function\\_>")
3210 (setq begin (match-beginning 0))
3211 (setq pstate (js--forward-pstate))
3213 (when (or (null pstate)
3215 (error "Could not locate function definition"))
3217 (setq defun-info (js--guess-eval-defun-info pstate))
3219 (let ((overlay (make-overlay begin end)))
3220 (overlay-put overlay 'face 'highlight)
3222 (unless (y-or-n-p (format "Send %s to Mozilla? "
3223 (mapconcat #'identity defun-info ".")))
3224 (message "") ; question message lingers until next command
3225 (return-from js-eval-defun))
3226 (delete-overlay overlay)))
3228 (setq defun-body (buffer-substring-no-properties begin end))
3230 (make-directory js-js-tmpdir t)
3232 ;; (Re)register a Mozilla resource URL to point to the
3233 ;; temporary directory
3234 (js--js-add-resource-alias "js" js-js-tmpdir)
3236 (setq temp-name (make-temp-file (concat js-js-tmpdir
3242 (insert js--js-inserter)
3244 (insert (json-encode-list defun-info))
3248 (write-region (point-min) (point-max) temp-name
3251 ;; Give Mozilla responsibility for deleting this file
3252 (let* ((content-window (js--js-content-window
3253 (js--get-js-context)))
3254 (content-document (js< content-window "document"))
3255 (head (if (js? (js< content-document "body"))
3257 (js< (js! (content-document "getElementsByTagName")
3261 (js< content-document "documentElement")))
3262 (elem (js! (content-document "createElementNS")
3263 "http://www.w3.org/1999/xhtml" "script")))
3265 (js! (elem "setAttribute") "type" "text/javascript")
3266 (js! (elem "setAttribute") "src"
3267 (format "resource://js/%s"
3268 (file-name-nondirectory temp-name)))
3270 (js! (head "appendChild") elem)
3272 (js! (content-window "addEventListener") "unload"
3275 "return function() { file.remove(false) }"))
3276 (js--make-nsilocalfile temp-name))
3278 (setq temp-name nil)
3284 ;; temp-name is set to nil on success
3286 (delete-file temp-name))))))
3291 (define-derived-mode js-mode prog-mode "Javascript"
3292 "Major mode for editing JavaScript."
3295 (set (make-local-variable 'indent-line-function) 'js-indent-line)
3296 (set (make-local-variable 'beginning-of-defun-function)
3297 'js-beginning-of-defun)
3298 (set (make-local-variable 'end-of-defun-function)
3301 (set (make-local-variable 'open-paren-in-column-0-is-defun-start) nil)
3302 (set (make-local-variable 'font-lock-defaults)
3303 (list js--font-lock-keywords))
3304 (set (make-local-variable 'syntax-propertize-function)
3305 js-syntax-propertize-function)
3307 (set (make-local-variable 'parse-sexp-ignore-comments) t)
3308 (set (make-local-variable 'parse-sexp-lookup-properties) t)
3309 (set (make-local-variable 'which-func-imenu-joiner-function)
3310 #'js--which-func-joiner)
3313 (set (make-local-variable 'comment-start) "// ")
3314 (set (make-local-variable 'comment-end) "")
3315 (set (make-local-variable 'fill-paragraph-function)
3316 'js-c-fill-paragraph)
3319 (add-hook 'before-change-functions #'js--flush-caches t t)
3322 (js--update-quick-match-re)
3325 (setq imenu-case-fold-search nil)
3326 (set (make-local-variable 'imenu-create-index-function)
3327 #'js--imenu-create-index)
3329 ;; for filling, pretend we're cc-mode
3330 (setq c-comment-prefix-regexp "//+\\|\\**"
3331 c-paragraph-start "$"
3332 c-paragraph-separate "$"
3333 c-block-comment-prefix "* "
3334 c-line-comment-starter "//"
3335 c-comment-start-regexp "/[*/]\\|\\s!"
3336 comment-start-skip "\\(//+\\|/\\*+\\)\\s *")
3338 (let ((c-buffer-is-cc-mode t))
3339 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3340 ;; we call it instead? (Bug#6071)
3341 (make-local-variable 'paragraph-start)
3342 (make-local-variable 'paragraph-separate)
3343 (make-local-variable 'paragraph-ignore-fill-prefix)
3344 (make-local-variable 'adaptive-fill-mode)
3345 (make-local-variable 'adaptive-fill-regexp)
3346 (c-setup-paragraph-variables))
3348 (set (make-local-variable 'syntax-begin-function)
3349 #'js--syntax-begin-function)
3351 ;; Important to fontify the whole buffer syntactically! If we don't,
3352 ;; then we might have regular expression literals that aren't marked
3353 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3354 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3355 ;; When we attempt to find the error and scroll to the portion of
3356 ;; the buffer containing the problem, JIT-lock will apply the
3357 ;; correct syntax to the regular expresion literal and the problem
3358 ;; will mysteriously disappear.
3359 ;; FIXME: We should actually do this fontification lazily by adding
3360 ;; calls to syntax-propertize wherever it's really needed.
3361 (syntax-propertize (point-max)))
3364 (defalias 'javascript-mode 'js-mode)
3366 (eval-after-load 'folding
3367 '(when (fboundp 'folding-add-to-marks-list)
3368 (folding-add-to-marks-list 'js-mode "// {{{" "// }}}" )))