| blob | ff002983d12d6e091c143177ea86f45715b19dbd |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2015 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>
8 ;; Version: 9
9 ;; Date: 2009-07-25
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/>.
27 ;;; Commentary
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
31 ;; (mostly).
32 ;;
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.
37 ;;
38 ;; General Remarks:
39 ;;
40 ;; XXX: This mode assumes that block comments are not nested inside block
41 ;; XXX: comments
42 ;;
43 ;; Exported names start with "js-"; private names start with
44 ;; "js--".
46 ;;; Code:
67 ;;; Constants
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
98 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
107 ;; var NewClass = BaseClass.extend(
115 ;; var NewClass = Class.create()
131 ;; var NewClass = Class.create({
138 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
139 ;; matched with dedicated font-lock matchers
167 :prototype t
173 :prototype t
189 :prototype t
195 :prototype t
206 :prototype t
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
245 collect framework into available-frameworks
246 finally return available-frameworks)
252 "Regexp matching the start of a JavaScript function header.
258 "Regexp matching the start of a function entry in an associative array.
270 "Regexp matching a CPP macro definition, up to the opening parenthesis.
320 ;; js--pitem is the basic building block of the lexical
321 ;; database. When one refers to a real part of the buffer, the region
322 ;; of text to which it refers is split into a conceptual header and
323 ;; body. Consider the (very short) block described by a hypothetical
324 ;; js--pitem:
325 ;;
326 ;; function foo(a,b,c) { return 42; }
327 ;; ^ ^ ^
328 ;; | | |
329 ;; +- h-begin +- h-end +- b-end
330 ;;
331 ;; (Remember that these are buffer positions, and therefore point
332 ;; between characters, not at them. An arrow drawn to a character
333 ;; indicates the corresponding position is between that character and
334 ;; the one immediately preceding it.)
335 ;;
336 ;; The header is the region of text [h-begin, h-end], and is
337 ;; the text needed to unambiguously recognize the start of the
338 ;; construct. If the entire header is not present, the construct is
339 ;; not recognized at all. No other pitems may be nested inside the
340 ;; header.
341 ;;
342 ;; The body is the region [h-end, b-end]. It may contain nested
343 ;; js--pitem instances. The body of a pitem may be empty: in
344 ;; that case, b-end is equal to header-end.
345 ;;
346 ;; The three points obey the following relationship:
347 ;;
348 ;; h-begin < h-end <= b-end
349 ;;
350 ;; We put a text property in the buffer on the character *before*
351 ;; h-end, and if we see it, on the character *before* b-end.
352 ;;
353 ;; The text property for h-end, js--pstate, is actually a list
354 ;; of all js--pitem instances open after the marked character.
355 ;;
356 ;; The text property for b-end, js--pend, is simply the
357 ;; js--pitem that ends after the marked character. (Because
358 ;; pitems always end when the paren-depth drops below a critical
359 ;; value, and because we can only drop one level per character, only
360 ;; one pitem may end at a given character.)
361 ;;
362 ;; In the structure below, we only store h-begin and (sometimes)
363 ;; b-end. We can trivially and quickly find h-end by going to h-begin
364 ;; and searching for an js--pstate text property. Since no other
365 ;; js--pitem instances can be nested inside the header of a
366 ;; pitem, the location after the character with this text property
367 ;; must be h-end.
368 ;;
369 ;; js--pitem instances are never modified (with the exception
370 ;; of the b-end field). Instead, modified copies are added at
371 ;; subsequence parse points.
372 ;; (The exception for b-end and its caveats is described below.)
373 ;;
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
383 ;; When we reach this paren depth after h-end, the pitem ends
386 ;; Symbol or class-style plist if this is a class
389 ;; See above
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
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.
400 ;;
401 ;; The field value is either a number (buffer location) or nil if
402 ;; unknown.
403 ;;
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.)
409 ;;
412 ;; The pitem we start parsing with.
415 :paren-depth most-negative-fixnum
418 ;;; User Customization
421 "Customization variables for JavaScript mode."
426 "Number of spaces for each indentation step in `js-mode'."
432 "Number of additional spaces for indenting continued expressions.
433 The value must be no less than minus `js-indent-level'."
439 "Number of additional spaces for indenting expressions in parentheses.
440 The value must be no less than minus `js-indent-level'."
447 "Number of additional spaces for indenting expressions in square braces.
448 The value must be no less than minus `js-indent-level'."
455 "Number of additional spaces for indenting expressions in curly braces.
456 The value must be no less than minus `js-indent-level'."
463 "Number of additional spaces for indenting the contents of a switch block.
464 The value must not be negative."
471 "Treat nested functions as top-level functions in `js-mode'.
472 This applies to function movement, marking, and so on."
477 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
482 "Frameworks recognized by `js-mode'.
483 To improve performance, you may turn off some frameworks you
484 seldom use, either globally or on a per-buffer basis."
487 js--available-frameworks))
492 "Whether `js-mode' should display tabs while selecting them.
493 This is useful only if the windowing system has a good mechanism
494 for preventing Firefox from stealing the keyboard focus."
499 "~/.emacs.d/js/js"
500 "Temporary directory used by `js-mode' to communicate with Mozilla.
501 This directory must be readable and writable by both Mozilla and Emacs."
506 "Reply timeout for executing commands in Mozilla via `js-mode'.
507 The value is given in seconds. Increase this value if you are
508 getting timeout messages."
513 "Non-nil means specially indent the first variable declaration's initializer.
514 Normally, the first declaration's initializer is unindented, and
515 subsequent declarations have their identifiers aligned with it:
517 var o = {
518 foo: 3
519 };
521 var o = {
522 foo: 3
523 },
524 bar = 2;
526 If this option has the value t, indent the first declaration's
527 initializer by an additional level:
529 var o = {
530 foo: 3
531 };
533 var o = {
534 foo: 3
535 },
536 bar = 2;
538 If this option has the value `dynamic', if there is only one declaration,
539 don't indent the first one's initializer; otherwise, indent it.
541 var o = {
542 foo: 3
543 };
545 var o = {
546 foo: 3
547 },
548 bar = 2;"
554 ;;; KeyMap
570 keymap)
573 ;;; Syntax table and parsing
580 table)
611 "Helper function for `js--update-quick-match-re'.
612 If LIST contains any element that is not nil, return its non-nil
613 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
614 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
615 nil. If any element in LIST is itself a list, flatten that
616 element."
622 "Internal function used by `js-mode' for caching buffer constructs.
623 This updates `js--quick-match-re', based on the current set of
624 enabled frameworks."
629 ;; #define mumble
638 ;; var mumble = THING (
659 ;; mumble.prototypeTHING
667 ;; mumble.prototype = {
674 "Move over the next value of PROPNAME in the buffer.
675 If found, return that value and leave point after the character
676 having that value; otherwise, return nil and leave point at EOB."
687 next-value))
690 "Move over the previous value of PROPNAME in the buffer.
691 If found, return that value and leave point just before the
692 character that has that value, otherwise return nil and leave
693 point at BOB."
706 prev-value)))
719 "Helper function for `js--re-search-forward'."
721 str-terminator
750 "Search forward, ignoring strings, cpp macros, and comments.
751 This function invokes `re-search-forward', but treats the buffer
752 as if strings, cpp macros, and comments have been removed.
754 If invoked while inside a macro, it treats the contents of the
755 macro as normal text."
772 "Auxiliary function for `js--re-search-backward'."
774 str-terminator
805 "Search backward, ignoring strings, preprocessor macros, and comments.
807 This function invokes `re-search-backward' but treats the buffer
808 as if strings, preprocessor macros, and comments have been
809 removed.
811 If invoked while inside a macro, treat the macro as normal text."
815 "Move forward over a whole JavaScript expression.
816 This function doesn't move over expressions continued across
817 lines."
819 ;; non-continued case; simplistic, but good enough?
832 "Move forward over a JavaScript function declaration.
833 This puts point at the 'function' keyword.
835 If this is a syntactically-correct non-expression function,
836 return the name of the function, or t if the name could not be
837 determined. Otherwise, return nil."
853 name)))))
856 "Return the start of the JavaScript function prologue containing POS.
857 A function prologue is everything from start of the definition up
858 to and including the opening brace. POS defaults to point.
859 If POS is not in a function prologue, return nil."
886 "Helper function for `js-beginning-of-defun'.
887 Go to previous defun-beginning and return the parse state for it,
888 or nil if we went all the way back to bob and don't find
889 anything."
897 "Helper function for `js--beginning-of-defun-nested'.
898 If PSTATE represents a non-empty top-level defun, return the
899 top-most pitem. Otherwise, return nil."
902 with func-pitem
909 "Helper function for `js--beginning-of-defun'.
910 Return the pitem of the function we went to the beginning of."
912 ;; Look for the smallest function that encloses point...
917 and return pitem)
919 ;; ...and if that isn't found, look for the previous top-level
920 ;; defun
922 while pstate
925 and return it)))
928 "Helper function for `js-beginning-of-defun'."
934 "Value of `beginning-of-defun-function' for `js-mode'."
950 ;; If we're just past the end of a function, the user probably wants
951 ;; to go to the beginning of *that* function
965 "Flush the `js-mode' syntax cache after position BEG.
966 BEG defaults to `point-min', meaning to flush the entire cache."
972 ;; `(message ,@arguments)
973 )
982 ;; open-items must contain at least two items for this to
983 ;; work, but because we push a dummy item to start with,
984 ;; that assumption holds.
987 open-items)
990 "Helper function for `js--ensure-cache'.
991 Update parsing information up to point, referring to parse,
992 prev-parse-point, goal-point, and open-items bound lexically in
993 the body of `js--ensure-cache'."
1000 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
1001 ;; the given depth -- i.e., make sure we're deeper than the target
1002 ;; depth.
1006 prev-parse-point goal-point
1008 nil parse))
1010 ;; (let ((overlay (make-overlay prev-parse-point (point))))
1011 ;; (overlay-put overlay 'face '(:background "red"))
1012 ;; (unwind-protect
1013 ;; (progn
1014 ;; (js--debug "parsed: %S" parse)
1015 ;; (sit-for 1))
1016 ;; (delete-overlay overlay)))
1032 "Split a JavaScript name into its dot-separated parts.
1033 This also removes any prototype parts from the split name
1045 "Guess the name of the JavaScript function at POSITION.
1047 Return the name of the function, or nil if the name could not be
1048 guessed.
1050 This function clobbers match data. If we find the preamble
1051 begins earlier than expected while guessing the function name,
1052 set `js--guess-function-name-start' to that position; otherwise,
1053 set that variable to nil."
1070 ;; Clear any endings that occur after point
1077 ;; Remove any cache properties after this point
1082 "Ensures brace cache is valid up to the character before LIMIT.
1083 LIMIT defaults to point."
1089 parse
1090 prev-parse-point
1091 name
1092 case-fold-search
1093 filtered-class-styles
1094 goal-point)
1096 ;; Figure out which class styles we need to look for
1100 js-enabled-frameworks)
1101 collect style))
1107 ;; Find last known good position
1123 ;; Make a placeholder for the top-level definition
1139 ;; Each of these conditions should return non-nil if
1140 ;; we should add a new item and leave point at the end
1141 ;; of the new item's header (h-end in the
1142 ;; js--pitem diagram). This point is the one
1143 ;; after the last character we need to unambiguously
1144 ;; detect this construct. If one of these evaluates to
1145 ;; nil, the location of the point is ignored.
1147 ;; In comment or string
1150 ;; Regular function declaration
1159 js--guess-function-name-start))
1166 :paren-depth orig-depth
1167 :h-begin orig-match-start
1170 name
1173 ;; Macro
1176 ;; Macros often contain unbalanced parentheses.
1177 ;; Make sure that h-end is at the textual end of
1178 ;; the macro no matter what the parenthesis say.
1184 :h-begin orig-match-start
1188 ;; "Prototype function" declaration
1195 :paren-depth orig-depth
1196 :h-begin orig-match-start
1202 ;; Class definition
1204 with syntactic-context =
1206 for class-style in filtered-class-styles
1212 and return
1214 :paren-depth orig-depth
1215 :h-begin orig-match-start
1216 :type class-style
1231 )))))
1234 "Helper function for `js-end-of-defun'."
1239 return t
1243 "Helper function for `js-end-of-defun'."
1252 found)
1255 ;; We're already inside a function; just go to its end.
1258 ;; Otherwise, go to the end of the next function...
1265 ;; ... or eob.
1269 "Value of `end-of-defun-function' for `js-mode'."
1280 ;; look for function backward. if we're inside it, go to that
1281 ;; function's end. otherwise, search for the next function's end and
1282 ;; go there
1286 ;; if we're doing nested functions, see whether we're in the
1287 ;; prologue. If we are, go to the end of the function; otherwise,
1288 ;; call js--end-of-defun-nested to do the real work
1309 t
1311 nil))))
1314 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1325 pos
1329 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1339 pos
1342 ;; Like (up-list -1), but only considers lists that end nearby"
1345 ;; Look at a very small region so our computation time doesn't
1346 ;; explode in pathological cases.
1351 "Return non-nil if point is in a function parameter list."
1362 "Return non-nil if point is in a Dojo multiple-inheritance class block."
1384 ;;; Font Lock
1386 "Helper function for building `js--font-lock-keywords'.
1387 Create a byte-compiled function for matching a concatenation of
1388 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1399 "Move forward over a JavaScript destructuring spec.
1400 If FUNC is supplied, call it with no arguments before every
1401 variable name in the spec. Return true if this was actually a
1402 spec. FUNC must preserve the match data."
1414 t)
1419 t))))
1422 t))
1436 t))
1441 t)))))
1444 t))))
1447 "Font-lock matcher for variable names in a variable declaration.
1448 This is a cc-mode-style matcher that *always* fails, from the
1449 point of view of font-lock. It applies highlighting directly with
1450 `font-lock-apply-highlight'."
1462 t))
1484 ;; Conditions to handle
1488 ;; Matcher always "fails"
1489 nil)
1492 `(
1493 ;; This goes before keywords-2 so it gets used preferentially
1494 ;; instead of the keywords in keywords-2. Don't use override
1495 ;; because that will override syntactic fontification too, which
1496 ;; will fontify commented-out directives as if they weren't
1497 ;; commented out.
1500 ,@js--font-lock-keywords-2
1505 ;; Highlights class being declared, in parts
1509 nil
1512 ;; Highlights parent class, in parts, if available
1529 ;; Highlights parent class
1533 ;; Dojo needs its own matcher to override the string highlighting
1535 'dojo
1542 ;; Match Dojo base classes. Of course Mojo has to be different
1543 ;; from everything else under the sun...
1545 'dojo
1554 ;; continued Dojo base-class list
1556 'dojo
1567 ;; variable declarations
1572 ;; class instantiation
1577 ;; instanceof
1582 ;; formal parameters
1586 js--name-start-re)
1592 ;; continued formal parameter list
1606 "Return whether point is inside the given pitem's header or body."
1616 "Parse the JavaScript program state at point.
1617 Return a list of `js--pitem' instances that apply to point, most
1618 specific first. In the worst case, the current toplevel instance
1619 will be returned."
1628 ;; Loop until we either hit a pitem at BOB or pitem ends after
1629 ;; point (or at point if we're at eob)
1636 pstate))))
1639 "Return the JavaScript syntactic context corresponding to PSTATE."
1642 type)
1648 "Return the JavaScript syntactic context at point.
1649 When called interactively, also display a message with that
1650 context."
1658 syntactic-context))
1661 "Font lock function used by `js-mode'.
1662 This performs fontification according to `js--class-styles'."
1670 js-enabled-frameworks)
1673 decl-re
1676 and return t)
1677 return t
1682 js--font-lock-keywords-2
1683 js--font-lock-keywords-3)
1691 st))
1696 ;; A /.../ regexp.
1701 js--syntax-propertize-regexp-syntax-table
1704 ;; A / within a character class is not the end of a regexp.
1705 t
1708 nil))))))
1711 ;; Javascript allows immediate regular expression objects, written /.../.
1716 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1717 ;; FIXME: Allow regexps after infix ops like + ...
1718 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1719 ;; We can probably just add +, -, !, <, >, %, ^, ~, |, &, ?, : at which
1720 ;; point I think only * and / would be missing which could also be added,
1721 ;; but need care to avoid affecting the // and */ comment markers.
1726 ;; If the / is at the beginning of line, we have to check
1727 ;; the end of the previous text.
1738 ;;; Indentation
1756 "Return non-nil if point is on a JavaScript operator, other than a comma."
1766 "Return non-nil if the current line continues an expression."
1783 Otherwise, return nil. A braceless do-while statement spanning
1784 several lines requires that the start of the loop is indented to
1785 the same column as the current line."
1807 "Helper function for `js--proper-indentation'.
1808 Return the proper indentation of the current line if it starts
1809 the body of a control statement without braces; otherwise, return
1810 nil."
1838 "Helper function for `js--proper-indentation'.
1839 Return the proper indentation of the current line if it belongs to a declaration
1840 statement spanning multiple lines; otherwise, return nil."
1868 "Return non-nil if we think we're in an array comprehension.
1869 In particular, return the buffer position of the first `for' kwd."
1883 ;; To skip arbitrary expressions we need the parser,
1884 ;; so we'll just guess at it.
1887 ;; Not inside comment or string literal.
1893 ;; First continuation line.
1904 "Helper function for `js--proper-indentation'.
1905 Depending on the value of `js-indent-first-init', move
1906 point to the end of a variable declaration keyword so that
1907 indentation is aligned to that column."
1914 declaration-keyword-end
1915 at-closing-bracket-p
1916 comma-p)
1925 t)
1934 "Return the proper indentation for the current line."
1942 ;; Indent array comprehension continuation lines specially.
1944 beg)
1948 ;; At or after the first loop?
1954 ;; A single closing paren/bracket should be indented at the
1955 ;; same level as the opening statement. Same goes for
1956 ;; "case" and "default".
1971 in-switch-p)))
1977 js-expr-indent-offset))
1986 indent)))
1987 ;; If there is something following the opening
1988 ;; paren/bracket, everything else should be indented at
1989 ;; the same level.
2000 "Indent the current line as JavaScript."
2008 ;;; Filling
2012 ;; FIXME: Such redefinitions are bad style. We should try and use some other
2013 ;; way to get the same result.
2017 ad-do-it))
2022 ad-do-it))
2027 ad-do-it))
2030 "Fill the paragraph with `c-fill-paragraph'."
2036 ;;; Type database and Imenu
2038 ;; We maintain a cache of semantic information, i.e., the classes and
2039 ;; functions we've encountered so far. In order to avoid having to
2040 ;; re-parse the buffer on every change, we cache the parse state at
2041 ;; each interesting point in the buffer. Each parse state is a
2042 ;; modified copy of the previous one, or in the case of the first
2043 ;; parse state, the empty state.
2044 ;;
2045 ;; The parse state itself is just a stack of js--pitem
2046 ;; instances. It starts off containing one element that is never
2047 ;; closed, that is initially js--initial-pitem.
2048 ;;
2056 name
2058 type
2062 "Helper function for `js--splice-into-items'.
2063 Return a new item that is the result of merging CHILD into
2064 ITEM. NAME-PARTS is a list of parts of the name of CHILD
2065 that we haven't consumed yet."
2070 ;; If the item we're merging into isn't a class, make it into one
2076 ;; Use the child's class-style if it's available
2078 js--dummy-class-style
2083 ;; Now we can merge either a function or a class into a class
2087 ;; if we have more name-parts to go before we get to the
2088 ;; bottom of the class hierarchy, call the merger
2089 ;; recursively
2095 ;; Not merging a class, but something else, so just prepend
2096 ;; it
2100 ;; Otherwise, merge the new child's items into those
2101 ;; of the new class
2107 "Last part of the name of PITEM, as a string or symbol."
2111 name)))
2114 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
2115 If a class doesn't exist in the tree, create it. Return
2116 the new items list. NAME-PARTS is a list of strings given
2117 the broken-down class name of the item to insert."
2121 new-items last-new-item new-cons)
2124 name-parts
2130 ;; If top-name isn't found in items, then we build a copy of items
2131 ;; and throw it away. But that's okay, since most of the time, we
2132 ;; *will* find an instance.
2136 ;; Okay, we found an entry with the right name. Splice
2137 ;; the merged item into the list...
2140 name-parts)
2147 ;; ...and terminate the loop
2148 nil)
2151 ;; Otherwise, copy the current cons and move onto the
2152 ;; text. This is tricky; we keep track of the tail of
2153 ;; the list that begins with new-items in
2154 ;; last-new-item.
2161 ;; Go to the next cell in items
2165 ;; Yay! We stopped because we found something, not because
2166 ;; we ran out of items to search. Just return the new
2167 ;; list.
2170 new-items)
2172 ;; We didn't find anything. If the child is a class and we don't
2173 ;; have any classes to drill down into, just push that class;
2174 ;; otherwise, make a fake class and carry on.
2177 ;; We have name-parts left to process. Make a fake
2178 ;; class for this particular part...
2180 ;; ...and recursively digest the rest of the name
2183 :type js--dummy-class-style
2186 ;; Otherwise, this is the only name we have, so stick
2187 ;; the item on the front of the list
2188 child)
2189 items))))
2192 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2197 t))
2199 ;; This trick works because we know (based on our defstructs) that
2200 ;; the child list is always the first element, and so the second
2201 ;; element and beyond can be shared when we make our "copy".
2208 ;; Use slow path because we need class lookup
2214 ;; Use slow path because we need class merging. We know
2215 ;; name is a list here because down in
2216 ;; `js--ensure-cache', we made sure to only add
2217 ;; class entries with lists for :name
2222 ;; Fast path
2228 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2231 location))
2234 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2251 imenu-items))
2256 unknown-ctr))
2259 imenu-items))
2268 imenu-items))))
2272 imenu-items))
2275 "Return an imenu index for the current buffer."
2287 ;; Make sure everything is closed
2295 ;; Convert the new-finalized state into what imenu expects
2298 unknown-ctr))))))
2300 ;; Silence the compiler.
2311 symbols)
2312 else
2323 "Return a hash table of all JavaScript symbols.
2324 This searches all existing `js-mode' buffers. Each key is the
2325 name of a symbol (possibly disambiguated with <N>, where N > 1),
2326 and each value is a marker giving the location of that symbol."
2328 with imenu-use-markers = t
2329 for buffer being the buffers
2334 finally return symbols))
2340 "Helper function for `js-find-symbol'.
2341 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2342 one from `js--get-all-known-symbols', using prompt PROMPT and
2343 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2344 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2345 marker."
2351 prompt
2353 collect key)
2369 ;; etags loads ring.
2373 "Read a JavaScript symbol and jump to it.
2374 With a prefix argument, restrict symbols to those from the
2375 current buffer. Pushes a mark onto the tag ring just like
2376 `find-tag'."
2387 symbols "Jump to: "
2395 ;;; MozRepl integration
2402 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2403 On timeout, return nil. On success, return t with match data
2404 set. If START is non-nil, look for output starting from START.
2405 Otherwise, use the current value of `process-mark'."
2417 'js-moz-bad-rpc
2421 ;; Integer, mirrors the value we see in JS
2424 ;; Process to which this thing belongs
2445 ; */" Make Emacs happy
2446 "(function(repl) {
2447 repl.defineInteractor('js', {
2448 onStart: function onStart(repl) {
2449 if(!repl._jsObjects) {
2450 repl._jsObjects = {};
2451 repl._jsLastID = 0;
2452 repl._jsGC = this._jsGC;
2453 }
2454 this._input = '';
2455 },
2457 _jsGC: function _jsGC(ids_in_use) {
2458 var objects = this._jsObjects;
2459 var keys = [];
2460 var num_freed = 0;
2462 for(var pn in objects) {
2463 keys.push(Number(pn));
2464 }
2466 keys.sort(function(x, y) x - y);
2467 ids_in_use.sort(function(x, y) x - y);
2468 var i = 0;
2469 var j = 0;
2471 while(i < ids_in_use.length && j < keys.length) {
2472 var id = ids_in_use[i++];
2473 while(j < keys.length && keys[j] !== id) {
2474 var k_id = keys[j++];
2475 delete objects[k_id];
2476 ++num_freed;
2477 }
2478 ++j;
2479 }
2481 while(j < keys.length) {
2482 var k_id = keys[j++];
2483 delete objects[k_id];
2484 ++num_freed;
2485 }
2487 return num_freed;
2488 },
2490 _mkArray: function _mkArray() {
2491 var result = [];
2492 for(var i = 0; i < arguments.length; ++i) {
2493 result.push(arguments[i]);
2494 }
2495 return result;
2496 },
2498 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2499 if(typeof parts === 'string') {
2500 parts = [ parts ];
2501 }
2503 var obj = parts[0];
2504 var start = 1;
2506 if(typeof obj === 'string') {
2507 obj = window;
2508 start = 0;
2509 } else if(parts.length < 2) {
2510 throw new Error('expected at least 2 arguments');
2511 }
2513 for(var i = start; i < parts.length - 1; ++i) {
2514 obj = obj[parts[i]];
2515 }
2517 return [obj, parts[parts.length - 1]];
2518 },
2520 _getProp: function _getProp(/*...*/) {
2521 if(arguments.length === 0) {
2522 throw new Error('no arguments supplied to getprop');
2523 }
2525 if(arguments.length === 1 &&
2526 (typeof arguments[0]) !== 'string')
2527 {
2528 return arguments[0];
2529 }
2531 var [obj, propname] = this._parsePropDescriptor(arguments);
2532 return obj[propname];
2533 },
2535 _putProp: function _putProp(properties, value) {
2536 var [obj, propname] = this._parsePropDescriptor(properties);
2537 obj[propname] = value;
2538 },
2540 _delProp: function _delProp(propname) {
2541 var [obj, propname] = this._parsePropDescriptor(arguments);
2542 delete obj[propname];
2543 },
2545 _typeOf: function _typeOf(thing) {
2546 return typeof thing;
2547 },
2549 _callNew: function(constructor) {
2550 if(typeof constructor === 'string')
2551 {
2552 constructor = window[constructor];
2553 } else if(constructor.length === 1 &&
2554 typeof constructor[0] !== 'string')
2555 {
2556 constructor = constructor[0];
2557 } else {
2558 var [obj,propname] = this._parsePropDescriptor(constructor);
2559 constructor = obj[propname];
2560 }
2562 /* Hacky, but should be robust */
2563 var s = 'new constructor(';
2564 for(var i = 1; i < arguments.length; ++i) {
2565 if(i != 1) {
2566 s += ',';
2567 }
2569 s += 'arguments[' + i + ']';
2570 }
2572 s += ')';
2573 return eval(s);
2574 },
2576 _callEval: function(thisobj, js) {
2577 return eval.call(thisobj, js);
2578 },
2580 getPrompt: function getPrompt(repl) {
2581 return 'EVAL>'
2582 },
2584 _lookupObject: function _lookupObject(repl, id) {
2585 if(typeof id === 'string') {
2586 switch(id) {
2587 case 'global':
2588 return window;
2589 case 'nil':
2590 return null;
2591 case 't':
2592 return true;
2593 case 'false':
2594 return false;
2595 case 'undefined':
2596 return undefined;
2597 case 'repl':
2598 return repl;
2599 case 'interactor':
2600 return this;
2601 case 'NaN':
2602 return NaN;
2603 case 'Infinity':
2604 return Infinity;
2605 case '-Infinity':
2606 return -Infinity;
2607 default:
2608 throw new Error('No object with special id:' + id);
2609 }
2610 }
2612 var ret = repl._jsObjects[id];
2613 if(ret === undefined) {
2614 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2615 }
2616 return ret;
2617 },
2619 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2620 if(typeof value !== 'object' && typeof value !== 'function') {
2621 throw new Error('_findOrAllocateObject called on non-object('
2622 + typeof(value) + '): '
2623 + value)
2624 }
2626 for(var id in repl._jsObjects) {
2627 id = Number(id);
2628 var obj = repl._jsObjects[id];
2629 if(obj === value) {
2630 return id;
2631 }
2632 }
2634 var id = ++repl._jsLastID;
2635 repl._jsObjects[id] = value;
2636 return id;
2637 },
2639 _fixupList: function _fixupList(repl, list) {
2640 for(var i = 0; i < list.length; ++i) {
2641 if(list[i] instanceof Array) {
2642 this._fixupList(repl, list[i]);
2643 } else if(typeof list[i] === 'object') {
2644 var obj = list[i];
2645 if(obj.funcall) {
2646 var parts = obj.funcall;
2647 this._fixupList(repl, parts);
2648 var [thisobj, func] = this._parseFunc(parts[0]);
2649 list[i] = func.apply(thisobj, parts.slice(1));
2650 } else if(obj.objid) {
2651 list[i] = this._lookupObject(repl, obj.objid);
2652 } else {
2653 throw new Error('Unknown object type: ' + obj.toSource());
2654 }
2655 }
2656 }
2657 },
2659 _parseFunc: function(func) {
2660 var thisobj = null;
2662 if(typeof func === 'string') {
2663 func = window[func];
2664 } else if(func instanceof Array) {
2665 if(func.length === 1 && typeof func[0] !== 'string') {
2666 func = func[0];
2667 } else {
2668 [thisobj, func] = this._parsePropDescriptor(func);
2669 func = thisobj[func];
2670 }
2671 }
2673 return [thisobj,func];
2674 },
2676 _encodeReturn: function(value, array_as_mv) {
2677 var ret;
2679 if(value === null) {
2680 ret = ['special', 'null'];
2681 } else if(value === true) {
2682 ret = ['special', 'true'];
2683 } else if(value === false) {
2684 ret = ['special', 'false'];
2685 } else if(value === undefined) {
2686 ret = ['special', 'undefined'];
2687 } else if(typeof value === 'number') {
2688 if(isNaN(value)) {
2689 ret = ['special', 'NaN'];
2690 } else if(value === Infinity) {
2691 ret = ['special', 'Infinity'];
2692 } else if(value === -Infinity) {
2693 ret = ['special', '-Infinity'];
2694 } else {
2695 ret = ['atom', value];
2696 }
2697 } else if(typeof value === 'string') {
2698 ret = ['atom', value];
2699 } else if(array_as_mv && value instanceof Array) {
2700 ret = ['array', value.map(this._encodeReturn, this)];
2701 } else {
2702 ret = ['objid', this._findOrAllocateObject(repl, value)];
2703 }
2705 return ret;
2706 },
2708 _handleInputLine: function _handleInputLine(repl, line) {
2709 var ret;
2710 var array_as_mv = false;
2712 try {
2713 if(line[0] === '*') {
2714 array_as_mv = true;
2715 line = line.substring(1);
2716 }
2717 var parts = eval(line);
2718 this._fixupList(repl, parts);
2719 var [thisobj, func] = this._parseFunc(parts[0]);
2720 ret = this._encodeReturn(
2721 func.apply(thisobj, parts.slice(1)),
2722 array_as_mv);
2723 } catch(x) {
2724 ret = ['error', x.toString() ];
2725 }
2727 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2728 repl.print(JSON.encode(ret));
2729 repl._prompt();
2730 },
2732 handleInput: function handleInput(repl, chunk) {
2733 this._input += chunk;
2734 var match, line;
2736 line = match[0];
2739 repl.popInteractor();
2740 repl._prompt();
2741 return;
2742 }
2744 this._input = this._input.substring(line.length);
2745 this._handleInputLine(repl, line);
2746 }
2747 }
2748 });
2749 })
2755 "Marshall the given value for JS.
2756 Strings and numbers are JSON-encoded. Lists (including nil) are
2757 made into JavaScript array literals and their contents encoded
2758 with `js--js-encode-value'."
2785 js--js-repl-prompt-regexp js-js-timeout
2787 ;; start matching against the beginning of the line in
2788 ;; order to catch a prompt that's only partially arrived
2791 ;; Presumably "inferior-moz-process" loads comint.
2801 ;; Do some initialization the first time we see a process
2807 ;; Send interactor definition
2813 js-js-timeout))
2815 ;; Sanity check
2821 ;; If js--js-repl-depth > 0, we *should* be seeing an
2822 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2823 ;; up with us.
2826 ;; Otherwise, tell Mozilla to enter the interactor mode
2832 js-js-timeout))
2846 js-js-timeout))))
2854 ;; The somewhat complex code layout confuses the byte-compiler into
2855 ;; thinking this function "might not be defined at runtime".
2860 "Convert immediate js< and js! references to deferred ones."
2884 function))
2886 else
2887 collect item)))
2902 "Run FORMS with the Mozilla repl set up for js commands.
2903 Inside the lexical scope of `with-js', `js?', `js!',
2904 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2905 `js-create-instance', and `js-qi' are defined."
2916 function)
2924 function)
2956 props)
2958 ))
2964 "Whether to listify any Array returned by a Mozilla function.
2971 (`array
2973 (`objid
2975 js--js-references)
2980 js--js-references)))
2988 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2989 If function is a string, look it up as a property on the global
2990 object and use the global object for `this'.
2991 If FUNCTION is a list with one element, use that element as the
2992 function with the global object for `this', except that if that
2993 single element is a string, look it up on the global object.
2994 If FUNCTION is a list with more than one argument, use the list
2995 up to the last value as a property descriptor and the last
2996 argument as a function."
3003 ;; Actual funcall
3010 js-js-timeout)
3013 ;; Read the result
3020 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
3021 CONSTRUCTOR is a JS handle, a string, or a list of these things."
3024 constructor arguments))
3030 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
3033 arguments)))
3042 "Tell the repl about any objects we don't reference anymore.
3043 With argument, run even if no intervening GC has happened."
3054 ;; Don't bother running unless we've had an intervening
3055 ;; garbage collection; without a gc, nothing is deleted
3056 ;; from the weak hash table, so it's pointless telling
3057 ;; MozRepl about that references we still hold
3060 ;; Are we looking at a normal prompt? Make sure not to
3061 ;; interrupt the user if he's doing something
3069 of js--js-references
3070 collect x))
3077 num)))
3082 "Evaluate the JavaScript in JS and return JSON-decoded result."
3090 result)))
3093 "Enumerate all JavaScript contexts available.
3094 Each context is a list:
3095 (TITLE URL BROWSER TAB TABBROWSER) for content documents
3096 (TITLE URL WINDOW) for windows
3098 All tabs of a given window are grouped together. The most recent
3099 window is first. Within each window, the tabs are returned
3100 left-to-right."
3105 "@mozilla.org/appshell/window-mediator;1"
3127 window)
3134 "browsers"
3135 x
3136 "contentDocument"
3140 "browsers"
3141 x
3142 "contentWindow"
3143 "location"
3146 "browsers"
3147 x)
3150 "tabContainer"
3151 "childNodes"
3153 x)
3155 gbrowser))))))
3162 "Read a Mozilla tab with prompt PROMPT.
3163 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
3164 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
3165 browser, respectively."
3167 ;; Prime IDO
3174 selected-tab prev-hitab)
3176 ;; Disambiguate names
3179 for tab in tabs
3197 ;; Hack to reduce the number of
3198 ;; round-trips to mozilla
3201 ;; Highlighting tab
3204 "style"
3206 cmds)
3208 ;; Highlight window proper
3211 "style"
3213 cmds)
3215 ;; Select tab, when appropriate
3219 cmds)))
3221 ;; Highlighting whole window
3225 "style"
3228 cmds)))
3231 ;; Unhighlighting tab
3234 cmds)
3236 cmds))
3238 ;; Unhighlighting window
3243 cmds)))
3249 ()
3255 ()
3256 ;; Fiddle with the match list a bit: if our first match
3257 ;; is a tabbrowser window, rotate the match list until
3258 ;; the active tab comes up
3264 "document"
3265 "documentElement"
3270 "gBrowser"
3273 for match in ido-matches
3278 and return t)))
3288 prompt
3290 nil t nil
3307 "Helper function for `js-eval-defun'.
3308 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3309 strings making up the class name and NAME is the name of the
3310 function part."
3329 "The current JavaScript context.
3330 This is a cons like the one returned from `js--read-tab'.
3334 "(function(func_info,func) {
3335 func_info.unshift('window');
3336 var obj = window;
3337 for(var i = 1; i < func_info.length - 1; ++i) {
3338 var next = obj[func_info[i]];
3339 if(typeof next !== 'object' && typeof next !== 'function') {
3340 next = obj.prototype && obj.prototype[func_info[i]];
3341 if(typeof next !== 'object' && typeof next !== 'function') {
3342 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3343 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3344 return;
3345 }
3347 func_info.splice(i+1, 0, 'prototype');
3348 ++i;
3349 }
3350 }
3352 obj[func_info[i]] = func;
3353 alert('Successfully updated '+func_info.join('.'));
3357 "Set the JavaScript context to CONTEXT.
3358 When called interactively, prompt for CONTEXT."
3363 "Return a valid JavaScript context.
3364 If one hasn't been set, or if it's stale, prompt for a new one."
3374 js--js-context))
3389 file)))
3402 "Update a Mozilla tab using the JavaScript defun at point."
3405 ;; This function works by generating a temporary file that contains
3406 ;; the function we'd like to insert. We then use the elisp-js bridge
3407 ;; to command mozilla to load this file by inserting a script tag
3408 ;; into the document we set. This way, debuggers and such will have
3409 ;; a way to find the source of the just-inserted function.
3410 ;;
3411 ;; We delete the temporary file if there's an error, but otherwise
3412 ;; we add an unload event listener on the Mozilla side to delete the
3413 ;; file.
3444 ;; (Re)register a Mozilla resource URL to point to the
3445 ;; temporary directory
3463 ;; Give Mozilla responsibility for deleting this file
3468 ;; Regular content
3472 ;; Chrome
3494 ))
3496 ;; temp-name is set to nil on success
3500 ;;; Main Function
3502 ;;;###autoload
3504 "Major mode for editing JavaScript."
3517 ;; Comments
3522 ;; Parse cache
3525 ;; Frameworks
3528 ;; Imenu
3532 ;; for filling, pretend we're cc-mode
3534 c-paragraph-start "$"
3535 c-paragraph-separate "$"
3536 c-block-comment-prefix "* "
3537 c-line-comment-starter "//"
3547 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3548 ;; we call it instead? (Bug#6071)
3558 ;; Important to fontify the whole buffer syntactically! If we don't,
3559 ;; then we might have regular expression literals that aren't marked
3560 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3561 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3562 ;; When we attempt to find the error and scroll to the portion of
3563 ;; the buffer containing the problem, JIT-lock will apply the
3564 ;; correct syntax to the regular expression literal and the problem
3565 ;; will mysteriously disappear.
3566 ;; FIXME: We should actually do this fontification lazily by adding
3567 ;; calls to syntax-propertize wherever it's really needed.
3570 ;;;###autoload (defalias 'javascript-mode 'js-mode)
3576 ;;;###autoload
3582 ;; js.el ends here