| blob | 5d5d101835aa11ae20380971aeda059b0147f97a |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2016 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:
68 ;;; Constants
90 "Regexp matching the prefix of a cpp directive.
91 This includes the directive name, or nil in languages without
92 preprocessor support. The first submatch surrounds the directive
99 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
108 ;; var NewClass = BaseClass.extend(
116 ;; var NewClass = Class.create()
132 ;; var NewClass = Class.create({
139 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
140 ;; matched with dedicated font-lock matchers
168 :prototype t
174 :prototype t
190 :prototype t
196 :prototype t
207 :prototype t
221 "List of JavaScript class definition styles.
223 A class definition style is a plist with the following keys:
225 :name is a human-readable name of the class type
227 :class-decl is a regular expression giving the start of the
228 class. Its first group must match the name of its class. If there
229 is a parent class, the second group should match, and it should be
230 the name of the class.
232 If :prototype is present and non-nil, the parser will merge
233 declarations for this constructs with others at the same lexical
234 level that have the same name. Otherwise, multiple definitions
235 will create multiple top-level entries. Don't use :prototype
236 unnecessarily: it has an associated cost in performance.
238 If :strip-prototype is present and non-nil, then if the class
239 name as matched contains
246 collect framework into available-frameworks
247 finally return available-frameworks)
253 "Regexp matching the start of a JavaScript function header.
259 "Regexp matching the start of a function entry in an associative array.
271 "Regexp matching a CPP macro definition, up to the opening parenthesis.
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
325 ;; js--pitem:
326 ;;
327 ;; function foo(a,b,c) { return 42; }
328 ;; ^ ^ ^
329 ;; | | |
330 ;; +- h-begin +- h-end +- b-end
331 ;;
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.)
336 ;;
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
341 ;; header.
342 ;;
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.
346 ;;
347 ;; The three points obey the following relationship:
348 ;;
349 ;; h-begin < h-end <= b-end
350 ;;
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.
353 ;;
354 ;; The text property for h-end, js--pstate, is actually a list
355 ;; of all js--pitem instances open after the marked character.
356 ;;
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.)
362 ;;
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
368 ;; must be h-end.
369 ;;
370 ;; js--pitem instances are never modified (with the exception
371 ;; of the b-end field). Instead, modified copies are added at
372 ;; subsequence parse points.
373 ;; (The exception for b-end and its caveats is described below.)
374 ;;
377 ;; IMPORTANT: Do not alter the position of fields within the list.
378 ;; Various bits of code depend on their positions, particularly
379 ;; anything that manipulates the list of children.
381 ;; List of children inside this pitem's body
384 ;; When we reach this paren depth after h-end, the pitem ends
387 ;; Symbol or class-style plist if this is a class
390 ;; See above
393 ;; List of strings giving the parts of the name of this pitem (e.g.,
394 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
397 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
398 ;; this pitem: when we copy-and-modify pitem instances, we share
399 ;; their tail structures, so all the copies actually have the same
400 ;; terminating cons cell. We modify that shared cons cell directly.
401 ;;
402 ;; The field value is either a number (buffer location) or nil if
403 ;; unknown.
404 ;;
405 ;; If the field's value is greater than `js--cache-end', the
406 ;; value is stale and must be treated as if it were nil. Conversely,
407 ;; if this field is nil, it is guaranteed that this pitem is open up
408 ;; to at least `js--cache-end'. (This property is handy when
409 ;; computing whether we're inside a given pitem.)
410 ;;
413 ;; The pitem we start parsing with.
416 :paren-depth most-negative-fixnum
419 ;;; User Customization
422 "Customization variables for JavaScript mode."
427 "Number of spaces for each indentation step in `js-mode'."
433 "Number of additional spaces for indenting continued expressions.
434 The value must be no less than minus `js-indent-level'."
440 "Number of additional spaces for indenting expressions in parentheses.
441 The value must be no less than minus `js-indent-level'."
448 "Number of additional spaces for indenting expressions in square braces.
449 The value must be no less than minus `js-indent-level'."
456 "Number of additional spaces for indenting expressions in curly braces.
457 The value must be no less than minus `js-indent-level'."
464 "Number of additional spaces for indenting the contents of a switch block.
465 The value must not be negative."
472 "Treat nested functions as top-level functions in `js-mode'.
473 This applies to function movement, marking, and so on."
478 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
483 "Frameworks recognized by `js-mode'.
484 To improve performance, you may turn off some frameworks you
485 seldom use, either globally or on a per-buffer basis."
488 js--available-frameworks))
493 "Whether `js-mode' should display tabs while selecting them.
494 This is useful only if the windowing system has a good mechanism
495 for preventing Firefox from stealing the keyboard focus."
500 "~/.emacs.d/js/js"
501 "Temporary directory used by `js-mode' to communicate with Mozilla.
502 This directory must be readable and writable by both Mozilla and Emacs."
507 "Reply timeout for executing commands in Mozilla via `js-mode'.
508 The value is given in seconds. Increase this value if you are
509 getting timeout messages."
514 "Non-nil means specially indent the first variable declaration's initializer.
515 Normally, the first declaration's initializer is unindented, and
516 subsequent declarations have their identifiers aligned with it:
518 var o = {
519 foo: 3
520 };
522 var o = {
523 foo: 3
524 },
525 bar = 2;
527 If this option has the value t, indent the first declaration's
528 initializer by an additional level:
530 var o = {
531 foo: 3
532 };
534 var o = {
535 foo: 3
536 },
537 bar = 2;
539 If this option has the value `dynamic', if there is only one declaration,
540 don't indent the first one's initializer; otherwise, indent it.
542 var o = {
543 foo: 3
544 };
546 var o = {
547 foo: 3
548 },
549 bar = 2;"
555 ;;; KeyMap
571 keymap)
574 ;;; Syntax table and parsing
581 table)
612 "Helper function for `js--update-quick-match-re'.
613 If LIST contains any element that is not nil, return its non-nil
614 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
615 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
616 nil. If any element in LIST is itself a list, flatten that
617 element."
623 "Internal function used by `js-mode' for caching buffer constructs.
624 This updates `js--quick-match-re', based on the current set of
625 enabled frameworks."
630 ;; #define mumble
639 ;; var mumble = THING (
660 ;; mumble.prototypeTHING
668 ;; mumble.prototype = {
675 "Move over the next value of PROPNAME in the buffer.
676 If found, return that value and leave point after the character
677 having that value; otherwise, return nil and leave point at EOB."
688 next-value))
691 "Move over the previous value of PROPNAME in the buffer.
692 If found, return that value and leave point just before the
693 character that has that value, otherwise return nil and leave
694 point at BOB."
707 prev-value)))
720 "Helper function for `js--re-search-forward'."
722 str-terminator
751 "Search forward, ignoring strings, cpp macros, and comments.
752 This function invokes `re-search-forward', but treats the buffer
753 as if strings, cpp macros, and comments have been removed.
755 If invoked while inside a macro, it treats the contents of the
756 macro as normal text."
773 "Auxiliary function for `js--re-search-backward'."
775 str-terminator
806 "Search backward, ignoring strings, preprocessor macros, and comments.
808 This function invokes `re-search-backward' but treats the buffer
809 as if strings, preprocessor macros, and comments have been
810 removed.
812 If invoked while inside a macro, treat the macro as normal text."
816 "Move forward over a whole JavaScript expression.
817 This function doesn't move over expressions continued across
818 lines."
820 ;; non-continued case; simplistic, but good enough?
833 "Move forward over a JavaScript function declaration.
834 This puts point at the `function' keyword.
836 If this is a syntactically-correct non-expression function,
837 return the name of the function, or t if the name could not be
838 determined. Otherwise, return nil."
854 name)))))
857 "Return the start of the JavaScript function prologue containing POS.
858 A function prologue is everything from start of the definition up
859 to and including the opening brace. POS defaults to point.
860 If POS is not in a function prologue, return nil."
887 "Helper function for `js-beginning-of-defun'.
888 Go to previous defun-beginning and return the parse state for it,
889 or nil if we went all the way back to bob and don't find
890 anything."
898 "Helper function for `js--beginning-of-defun-nested'.
899 If PSTATE represents a non-empty top-level defun, return the
900 top-most pitem. Otherwise, return nil."
903 with func-pitem
910 "Helper function for `js--beginning-of-defun'.
911 Return the pitem of the function we went to the beginning of."
913 ;; Look for the smallest function that encloses point...
918 and return pitem)
920 ;; ...and if that isn't found, look for the previous top-level
921 ;; defun
923 while pstate
926 and return it)))
929 "Helper function for `js-beginning-of-defun'."
935 "Value of `beginning-of-defun-function' for `js-mode'."
951 ;; If we're just past the end of a function, the user probably wants
952 ;; to go to the beginning of *that* function
966 "Flush the `js-mode' syntax cache after position BEG.
967 BEG defaults to `point-min', meaning to flush the entire cache."
973 ;; `(message ,@arguments)
974 )
983 ;; open-items must contain at least two items for this to
984 ;; work, but because we push a dummy item to start with,
985 ;; that assumption holds.
988 open-items)
991 "Helper function for `js--ensure-cache'.
992 Update parsing information up to point, referring to parse,
993 prev-parse-point, goal-point, and open-items bound lexically in
994 the body of `js--ensure-cache'."
1001 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
1002 ;; the given depth -- i.e., make sure we're deeper than the target
1003 ;; depth.
1007 prev-parse-point goal-point
1009 nil parse))
1011 ;; (let ((overlay (make-overlay prev-parse-point (point))))
1012 ;; (overlay-put overlay 'face '(:background "red"))
1013 ;; (unwind-protect
1014 ;; (progn
1015 ;; (js--debug "parsed: %S" parse)
1016 ;; (sit-for 1))
1017 ;; (delete-overlay overlay)))
1033 "Split a JavaScript name into its dot-separated parts.
1034 This also removes any prototype parts from the split name
1046 "Guess the name of the JavaScript function at POSITION.
1048 Return the name of the function, or nil if the name could not be
1049 guessed.
1051 This function clobbers match data. If we find the preamble
1052 begins earlier than expected while guessing the function name,
1053 set `js--guess-function-name-start' to that position; otherwise,
1054 set that variable to nil."
1071 ;; Clear any endings that occur after point
1078 ;; Remove any cache properties after this point
1083 "Ensures brace cache is valid up to the character before LIMIT.
1084 LIMIT defaults to point."
1090 parse
1091 prev-parse-point
1092 name
1093 case-fold-search
1094 filtered-class-styles
1095 goal-point)
1097 ;; Figure out which class styles we need to look for
1101 js-enabled-frameworks)
1102 collect style))
1108 ;; Find last known good position
1124 ;; Make a placeholder for the top-level definition
1140 ;; Each of these conditions should return non-nil if
1141 ;; we should add a new item and leave point at the end
1142 ;; of the new item's header (h-end in the
1143 ;; js--pitem diagram). This point is the one
1144 ;; after the last character we need to unambiguously
1145 ;; detect this construct. If one of these evaluates to
1146 ;; nil, the location of the point is ignored.
1148 ;; In comment or string
1151 ;; Regular function declaration
1160 js--guess-function-name-start))
1167 :paren-depth orig-depth
1168 :h-begin orig-match-start
1171 name
1174 ;; Macro
1177 ;; Macros often contain unbalanced parentheses.
1178 ;; Make sure that h-end is at the textual end of
1179 ;; the macro no matter what the parenthesis say.
1185 :h-begin orig-match-start
1189 ;; "Prototype function" declaration
1196 :paren-depth orig-depth
1197 :h-begin orig-match-start
1203 ;; Class definition
1205 with syntactic-context =
1207 for class-style in filtered-class-styles
1213 and return
1215 :paren-depth orig-depth
1216 :h-begin orig-match-start
1217 :type class-style
1232 )))))
1235 "Helper function for `js-end-of-defun'."
1240 return t
1244 "Helper function for `js-end-of-defun'."
1253 found)
1256 ;; We're already inside a function; just go to its end.
1259 ;; Otherwise, go to the end of the next function...
1266 ;; ... or eob.
1270 "Value of `end-of-defun-function' for `js-mode'."
1281 ;; look for function backward. if we're inside it, go to that
1282 ;; function's end. otherwise, search for the next function's end and
1283 ;; go there
1287 ;; if we're doing nested functions, see whether we're in the
1288 ;; prologue. If we are, go to the end of the function; otherwise,
1289 ;; call js--end-of-defun-nested to do the real work
1310 t
1312 nil))))
1315 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1326 pos
1330 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1340 pos
1343 ;; Like (up-list -1), but only considers lists that end nearby"
1346 ;; Look at a very small region so our computation time doesn't
1347 ;; explode in pathological cases.
1352 "Return non-nil if point is in a function parameter list."
1363 "Return non-nil if point is in a Dojo multiple-inheritance class block."
1374 ;;; Font Lock
1376 "Helper function for building `js--font-lock-keywords'.
1377 Create a byte-compiled function for matching a concatenation of
1378 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1389 "Move forward over a JavaScript destructuring spec.
1390 If FUNC is supplied, call it with no arguments before every
1391 variable name in the spec. Return true if this was actually a
1392 spec. FUNC must preserve the match data."
1404 t)
1409 t))))
1412 t))
1426 t))
1431 t)))))
1434 t))))
1437 "Font-lock matcher for variable names in a variable declaration.
1438 This is a cc-mode-style matcher that *always* fails, from the
1439 point of view of font-lock. It applies highlighting directly with
1440 `font-lock-apply-highlight'."
1452 t))
1474 ;; Conditions to handle
1478 ;; Matcher always "fails"
1479 nil)
1482 `(
1483 ;; This goes before keywords-2 so it gets used preferentially
1484 ;; instead of the keywords in keywords-2. Don't use override
1485 ;; because that will override syntactic fontification too, which
1486 ;; will fontify commented-out directives as if they weren't
1487 ;; commented out.
1490 ,@js--font-lock-keywords-2
1495 ;; Highlights class being declared, in parts
1499 nil
1502 ;; Highlights parent class, in parts, if available
1519 ;; Highlights parent class
1523 ;; Dojo needs its own matcher to override the string highlighting
1525 'dojo
1532 ;; Match Dojo base classes. Of course Mojo has to be different
1533 ;; from everything else under the sun...
1535 'dojo
1544 ;; continued Dojo base-class list
1546 'dojo
1557 ;; variable declarations
1562 ;; class instantiation
1567 ;; instanceof
1572 ;; formal parameters
1576 js--name-start-re)
1582 ;; continued formal parameter list
1596 "Return whether point is inside the given pitem's header or body."
1606 "Parse the JavaScript program state at point.
1607 Return a list of `js--pitem' instances that apply to point, most
1608 specific first. In the worst case, the current toplevel instance
1609 will be returned."
1618 ;; Loop until we either hit a pitem at BOB or pitem ends after
1619 ;; point (or at point if we're at eob)
1626 pstate))))
1629 "Return the JavaScript syntactic context corresponding to PSTATE."
1632 type)
1638 "Return the JavaScript syntactic context at point.
1639 When called interactively, also display a message with that
1640 context."
1648 syntactic-context))
1651 "Font lock function used by `js-mode'.
1652 This performs fontification according to `js--class-styles'."
1660 js-enabled-frameworks)
1663 decl-re
1666 and return t)
1667 return t
1672 js--font-lock-keywords-2
1673 js--font-lock-keywords-3)
1681 st))
1686 ;; A /.../ regexp.
1691 js--syntax-propertize-regexp-syntax-table
1694 ;; A / within a character class is not the end of a regexp.
1695 t
1698 nil))))))
1701 ;; Javascript allows immediate regular expression objects, written /.../.
1706 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1707 ;; FIXME: Allow regexps after infix ops like + ...
1708 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1709 ;; We can probably just add +, -, !, <, >, %, ^, ~, |, &, ?, : at which
1710 ;; point I think only * and / would be missing which could also be added,
1711 ;; but need care to avoid affecting the // and */ comment markers.
1716 ;; If the / is at the beginning of line, we have to check
1717 ;; the end of the previous text.
1735 ;;; Indentation
1753 "Return non-nil if point is on a JavaScript operator, other than a comma."
1762 ;; Generator method (possibly using computed property).
1766 ;; We might misindent some expressions that would
1767 ;; return NaN anyway. Shouldn't be a problem.
1771 "Return non-nil if the current line continues an expression."
1792 Otherwise, return nil. A braceless do-while statement spanning
1793 several lines requires that the start of the loop is indented to
1794 the same column as the current line."
1816 "Helper function for `js--proper-indentation'.
1817 Return the proper indentation of the current line if it starts
1818 the body of a control statement without braces; otherwise, return
1819 nil."
1848 "Helper function for `js--proper-indentation'.
1849 Return the proper indentation of the current line if it belongs to a declaration
1850 statement spanning multiple lines; otherwise, return nil."
1878 "Return non-nil if we think we're in an array comprehension.
1879 In particular, return the buffer position of the first `for' kwd."
1893 ;; To skip arbitrary expressions we need the parser,
1894 ;; so we'll just guess at it.
1897 ;; Not inside comment or string literal.
1905 ;; First continuation line.
1916 "Helper function for `js--proper-indentation'.
1917 Depending on the value of `js-indent-first-init', move
1918 point to the end of a variable declaration keyword so that
1919 indentation is aligned to that column."
1926 declaration-keyword-end
1927 at-closing-bracket-p
1928 comma-p)
1937 t)
1946 "Return the proper indentation for the current line."
1954 ;; Indent array comprehension continuation lines specially.
1956 beg)
1960 ;; At or after the first loop?
1966 ;; A single closing paren/bracket should be indented at the
1967 ;; same level as the opening statement. Same goes for
1968 ;; "case" and "default".
1983 in-switch-p)))
1989 js-expr-indent-offset))
1998 indent)))
1999 ;; If there is something following the opening
2000 ;; paren/bracket, everything else should be indented at
2001 ;; the same level.
2011 ;;; JSX Indentation
2014 "Find where JSX starts.
2016 Assume JSX appears in the following instances:
2017 - Inside parentheses, when returned or as the first argument
2018 to a function, and after a newline
2019 - When assigned to variables or object properties, but only
2020 on a single line
2021 - As the N+1th argument to a function
2024 nil t), except set point to the end of the match. This logic
2025 executes up to the number of lines in the file, so it should be
2026 really fast to reduce that impact."
2034 pos))
2041 "Find where JSX ends.
2042 This complements the assumption of where JSX appears from
2046 "Determine if/how the current line should be indented as JSX.
2048 Return `first' for the first JSXElement on its own line.
2049 Return `nth' for subsequent lines of the first JSXElement.
2050 Return `expression' for an embedded JS expression.
2051 Return `after' for anything after the last JSXElement.
2052 Return nil for non-JSX lines.
2054 Currently, JSX indentation supports the following styles:
2056 - Single-line elements (indented like normal JS):
2058 var element = <div></div>;
2060 - Multi-line elements (enclosed in parentheses):
2062 function () {
2063 return (
2064 <div>
2065 <div></div>
2066 </div>
2067 );
2068 }
2070 - Function arguments:
2072 React.render(
2073 <div></div>,
2074 document.querySelector('.root')
2075 );"
2078 last-pos
2079 before-tag-pos before-tag-line
2080 tag-start-pos tag-start-line
2081 tag-end-pos tag-end-line
2082 after-tag-line
2083 parens paren type)
2086 ;; Determine if we're inside a jsx element
2096 tag-start-pos)
2101 ;; A "before" line which also starts an element begins with js, so
2102 ;; indent it like js
2104 ;; Only indent the jsx lines like jsx
2107 ;; Analyze bounds if there are any
2114 tag-end-pos)
2118 ;; Ensure we're actually within the bounds of the jsx
2120 ;; An "after" line which does not end an element begins with
2121 ;; js, so indent it like js
2124 ;; Handle another case where there could be e.g. comments after
2125 ;; the element
2129 ;; They may not be any bounds (yet)
2131 ;; Check if we're inside an embedded multi-line js expression
2141 ;; Curly bracket indicates the start of an embedded expression
2143 ;; The first line of the expression is indented like sgml
2145 ;; Check if within a closing curly bracket (if any)
2146 ;; (exclusive, as the closing bracket is indented like sgml)
2154 ;; Indicate this guy will be indented specially
2157 t)
2161 ;; Indent the first jsx thing like js so we can indent future jsx things
2162 ;; like sgml relative to the first thing
2167 "Execute BODY as if in sgml-mode."
2170 parse-sexp-lookup-properties)
2174 "Indent the current line as JavaScript or SGML (whichever is farther)."
2177 ;; Don't whine about errors/warnings when we're indenting.
2178 ;; This has to be set before calling parse-partial-sexp below.
2182 ;; Don't touch multiline strings.
2189 'noindent
2190 ;; Use whichever indentation column is greater, such that the sgml
2191 ;; column is effectively a minimum
2199 "Indent the current line as JavaScript."
2209 "Indent the current line as JSX (with SGML offsets).
2210 i.e., customize JSX element indentation with `sgml-basic-offset',
2211 `sgml-attribute-offset' et al."
2219 ;; Don't treat this first thing as a continued expression (often a "<" or
2220 ;; ">" causes this misinterpretation)
2227 ;;; Filling
2231 ;; FIXME: Such redefinitions are bad style. We should try and use some other
2232 ;; way to get the same result.
2236 ad-do-it))
2241 ad-do-it))
2246 ad-do-it))
2249 "Fill the paragraph with `c-fill-paragraph'."
2255 ;;; Type database and Imenu
2257 ;; We maintain a cache of semantic information, i.e., the classes and
2258 ;; functions we've encountered so far. In order to avoid having to
2259 ;; re-parse the buffer on every change, we cache the parse state at
2260 ;; each interesting point in the buffer. Each parse state is a
2261 ;; modified copy of the previous one, or in the case of the first
2262 ;; parse state, the empty state.
2263 ;;
2264 ;; The parse state itself is just a stack of js--pitem
2265 ;; instances. It starts off containing one element that is never
2266 ;; closed, that is initially js--initial-pitem.
2267 ;;
2275 name
2277 type
2281 "Helper function for `js--splice-into-items'.
2282 Return a new item that is the result of merging CHILD into
2283 ITEM. NAME-PARTS is a list of parts of the name of CHILD
2284 that we haven't consumed yet."
2289 ;; If the item we're merging into isn't a class, make it into one
2295 ;; Use the child's class-style if it's available
2297 js--dummy-class-style
2302 ;; Now we can merge either a function or a class into a class
2306 ;; if we have more name-parts to go before we get to the
2307 ;; bottom of the class hierarchy, call the merger
2308 ;; recursively
2314 ;; Not merging a class, but something else, so just prepend
2315 ;; it
2319 ;; Otherwise, merge the new child's items into those
2320 ;; of the new class
2326 "Last part of the name of PITEM, as a string or symbol."
2330 name)))
2333 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
2334 If a class doesn't exist in the tree, create it. Return
2335 the new items list. NAME-PARTS is a list of strings given
2336 the broken-down class name of the item to insert."
2340 new-items last-new-item new-cons)
2343 name-parts
2349 ;; If top-name isn't found in items, then we build a copy of items
2350 ;; and throw it away. But that's okay, since most of the time, we
2351 ;; *will* find an instance.
2355 ;; Okay, we found an entry with the right name. Splice
2356 ;; the merged item into the list...
2359 name-parts)
2366 ;; ...and terminate the loop
2367 nil)
2370 ;; Otherwise, copy the current cons and move onto the
2371 ;; text. This is tricky; we keep track of the tail of
2372 ;; the list that begins with new-items in
2373 ;; last-new-item.
2380 ;; Go to the next cell in items
2384 ;; Yay! We stopped because we found something, not because
2385 ;; we ran out of items to search. Just return the new
2386 ;; list.
2389 new-items)
2391 ;; We didn't find anything. If the child is a class and we don't
2392 ;; have any classes to drill down into, just push that class;
2393 ;; otherwise, make a fake class and carry on.
2396 ;; We have name-parts left to process. Make a fake
2397 ;; class for this particular part...
2399 ;; ...and recursively digest the rest of the name
2402 :type js--dummy-class-style
2405 ;; Otherwise, this is the only name we have, so stick
2406 ;; the item on the front of the list
2407 child)
2408 items))))
2411 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2416 t))
2418 ;; This trick works because we know (based on our defstructs) that
2419 ;; the child list is always the first element, and so the second
2420 ;; element and beyond can be shared when we make our "copy".
2427 ;; Use slow path because we need class lookup
2433 ;; Use slow path because we need class merging. We know
2434 ;; name is a list here because down in
2435 ;; `js--ensure-cache', we made sure to only add
2436 ;; class entries with lists for :name
2441 ;; Fast path
2447 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2450 location))
2453 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2470 imenu-items))
2475 unknown-ctr))
2478 imenu-items))
2487 imenu-items))))
2491 imenu-items))
2494 "Return an imenu index for the current buffer."
2506 ;; Make sure everything is closed
2514 ;; Convert the new-finalized state into what imenu expects
2517 unknown-ctr))))))
2519 ;; Silence the compiler.
2530 symbols)
2531 else
2542 "Return a hash table of all JavaScript symbols.
2543 This searches all existing `js-mode' buffers. Each key is the
2544 name of a symbol (possibly disambiguated with <N>, where N > 1),
2545 and each value is a marker giving the location of that symbol."
2547 with imenu-use-markers = t
2548 for buffer being the buffers
2553 finally return symbols))
2559 "Helper function for `js-find-symbol'.
2560 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2561 one from `js--get-all-known-symbols', using prompt PROMPT and
2562 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2563 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2564 marker."
2570 prompt
2572 collect key)
2588 ;; etags loads ring.
2592 "Read a JavaScript symbol and jump to it.
2593 With a prefix argument, restrict symbols to those from the
2594 current buffer. Pushes a mark onto the tag ring just like
2595 `find-tag'."
2606 symbols "Jump to: "
2614 ;;; MozRepl integration
2621 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2622 On timeout, return nil. On success, return t with match data
2623 set. If START is non-nil, look for output starting from START.
2624 Otherwise, use the current value of `process-mark'."
2636 'js-moz-bad-rpc
2640 ;; Integer, mirrors the value we see in JS
2643 ;; Process to which this thing belongs
2664 ; */" Make Emacs happy
2665 "(function(repl) {
2666 repl.defineInteractor('js', {
2667 onStart: function onStart(repl) {
2668 if(!repl._jsObjects) {
2669 repl._jsObjects = {};
2670 repl._jsLastID = 0;
2671 repl._jsGC = this._jsGC;
2672 }
2673 this._input = '';
2674 },
2676 _jsGC: function _jsGC(ids_in_use) {
2677 var objects = this._jsObjects;
2678 var keys = [];
2679 var num_freed = 0;
2681 for(var pn in objects) {
2682 keys.push(Number(pn));
2683 }
2685 keys.sort(function(x, y) x - y);
2686 ids_in_use.sort(function(x, y) x - y);
2687 var i = 0;
2688 var j = 0;
2690 while(i < ids_in_use.length && j < keys.length) {
2691 var id = ids_in_use[i++];
2692 while(j < keys.length && keys[j] !== id) {
2693 var k_id = keys[j++];
2694 delete objects[k_id];
2695 ++num_freed;
2696 }
2697 ++j;
2698 }
2700 while(j < keys.length) {
2701 var k_id = keys[j++];
2702 delete objects[k_id];
2703 ++num_freed;
2704 }
2706 return num_freed;
2707 },
2709 _mkArray: function _mkArray() {
2710 var result = [];
2711 for(var i = 0; i < arguments.length; ++i) {
2712 result.push(arguments[i]);
2713 }
2714 return result;
2715 },
2717 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2718 if(typeof parts === 'string') {
2719 parts = [ parts ];
2720 }
2722 var obj = parts[0];
2723 var start = 1;
2725 if(typeof obj === 'string') {
2726 obj = window;
2727 start = 0;
2728 } else if(parts.length < 2) {
2729 throw new Error('expected at least 2 arguments');
2730 }
2732 for(var i = start; i < parts.length - 1; ++i) {
2733 obj = obj[parts[i]];
2734 }
2736 return [obj, parts[parts.length - 1]];
2737 },
2739 _getProp: function _getProp(/*...*/) {
2740 if(arguments.length === 0) {
2741 throw new Error('no arguments supplied to getprop');
2742 }
2744 if(arguments.length === 1 &&
2745 (typeof arguments[0]) !== 'string')
2746 {
2747 return arguments[0];
2748 }
2750 var [obj, propname] = this._parsePropDescriptor(arguments);
2751 return obj[propname];
2752 },
2754 _putProp: function _putProp(properties, value) {
2755 var [obj, propname] = this._parsePropDescriptor(properties);
2756 obj[propname] = value;
2757 },
2759 _delProp: function _delProp(propname) {
2760 var [obj, propname] = this._parsePropDescriptor(arguments);
2761 delete obj[propname];
2762 },
2764 _typeOf: function _typeOf(thing) {
2765 return typeof thing;
2766 },
2768 _callNew: function(constructor) {
2769 if(typeof constructor === 'string')
2770 {
2771 constructor = window[constructor];
2772 } else if(constructor.length === 1 &&
2773 typeof constructor[0] !== 'string')
2774 {
2775 constructor = constructor[0];
2776 } else {
2777 var [obj,propname] = this._parsePropDescriptor(constructor);
2778 constructor = obj[propname];
2779 }
2781 /* Hacky, but should be robust */
2782 var s = 'new constructor(';
2783 for(var i = 1; i < arguments.length; ++i) {
2784 if(i != 1) {
2785 s += ',';
2786 }
2788 s += 'arguments[' + i + ']';
2789 }
2791 s += ')';
2792 return eval(s);
2793 },
2795 _callEval: function(thisobj, js) {
2796 return eval.call(thisobj, js);
2797 },
2799 getPrompt: function getPrompt(repl) {
2800 return 'EVAL>'
2801 },
2803 _lookupObject: function _lookupObject(repl, id) {
2804 if(typeof id === 'string') {
2805 switch(id) {
2806 case 'global':
2807 return window;
2808 case 'nil':
2809 return null;
2810 case 't':
2811 return true;
2812 case 'false':
2813 return false;
2814 case 'undefined':
2815 return undefined;
2816 case 'repl':
2817 return repl;
2818 case 'interactor':
2819 return this;
2820 case 'NaN':
2821 return NaN;
2822 case 'Infinity':
2823 return Infinity;
2824 case '-Infinity':
2825 return -Infinity;
2826 default:
2827 throw new Error('No object with special id:' + id);
2828 }
2829 }
2831 var ret = repl._jsObjects[id];
2832 if(ret === undefined) {
2833 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2834 }
2835 return ret;
2836 },
2838 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2839 if(typeof value !== 'object' && typeof value !== 'function') {
2840 throw new Error('_findOrAllocateObject called on non-object('
2841 + typeof(value) + '): '
2842 + value)
2843 }
2845 for(var id in repl._jsObjects) {
2846 id = Number(id);
2847 var obj = repl._jsObjects[id];
2848 if(obj === value) {
2849 return id;
2850 }
2851 }
2853 var id = ++repl._jsLastID;
2854 repl._jsObjects[id] = value;
2855 return id;
2856 },
2858 _fixupList: function _fixupList(repl, list) {
2859 for(var i = 0; i < list.length; ++i) {
2860 if(list[i] instanceof Array) {
2861 this._fixupList(repl, list[i]);
2862 } else if(typeof list[i] === 'object') {
2863 var obj = list[i];
2864 if(obj.funcall) {
2865 var parts = obj.funcall;
2866 this._fixupList(repl, parts);
2867 var [thisobj, func] = this._parseFunc(parts[0]);
2868 list[i] = func.apply(thisobj, parts.slice(1));
2869 } else if(obj.objid) {
2870 list[i] = this._lookupObject(repl, obj.objid);
2871 } else {
2872 throw new Error('Unknown object type: ' + obj.toSource());
2873 }
2874 }
2875 }
2876 },
2878 _parseFunc: function(func) {
2879 var thisobj = null;
2881 if(typeof func === 'string') {
2882 func = window[func];
2883 } else if(func instanceof Array) {
2884 if(func.length === 1 && typeof func[0] !== 'string') {
2885 func = func[0];
2886 } else {
2887 [thisobj, func] = this._parsePropDescriptor(func);
2888 func = thisobj[func];
2889 }
2890 }
2892 return [thisobj,func];
2893 },
2895 _encodeReturn: function(value, array_as_mv) {
2896 var ret;
2898 if(value === null) {
2899 ret = ['special', 'null'];
2900 } else if(value === true) {
2901 ret = ['special', 'true'];
2902 } else if(value === false) {
2903 ret = ['special', 'false'];
2904 } else if(value === undefined) {
2905 ret = ['special', 'undefined'];
2906 } else if(typeof value === 'number') {
2907 if(isNaN(value)) {
2908 ret = ['special', 'NaN'];
2909 } else if(value === Infinity) {
2910 ret = ['special', 'Infinity'];
2911 } else if(value === -Infinity) {
2912 ret = ['special', '-Infinity'];
2913 } else {
2914 ret = ['atom', value];
2915 }
2916 } else if(typeof value === 'string') {
2917 ret = ['atom', value];
2918 } else if(array_as_mv && value instanceof Array) {
2919 ret = ['array', value.map(this._encodeReturn, this)];
2920 } else {
2921 ret = ['objid', this._findOrAllocateObject(repl, value)];
2922 }
2924 return ret;
2925 },
2927 _handleInputLine: function _handleInputLine(repl, line) {
2928 var ret;
2929 var array_as_mv = false;
2931 try {
2932 if(line[0] === '*') {
2933 array_as_mv = true;
2934 line = line.substring(1);
2935 }
2936 var parts = eval(line);
2937 this._fixupList(repl, parts);
2938 var [thisobj, func] = this._parseFunc(parts[0]);
2939 ret = this._encodeReturn(
2940 func.apply(thisobj, parts.slice(1)),
2941 array_as_mv);
2942 } catch(x) {
2943 ret = ['error', x.toString() ];
2944 }
2946 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2947 repl.print(JSON.encode(ret));
2948 repl._prompt();
2949 },
2951 handleInput: function handleInput(repl, chunk) {
2952 this._input += chunk;
2953 var match, line;
2955 line = match[0];
2958 repl.popInteractor();
2959 repl._prompt();
2960 return;
2961 }
2963 this._input = this._input.substring(line.length);
2964 this._handleInputLine(repl, line);
2965 }
2966 }
2967 });
2968 })
2974 "Marshall the given value for JS.
2975 Strings and numbers are JSON-encoded. Lists (including nil) are
2976 made into JavaScript array literals and their contents encoded
2977 with `js--js-encode-value'."
3004 js--js-repl-prompt-regexp js-js-timeout
3006 ;; start matching against the beginning of the line in
3007 ;; order to catch a prompt that's only partially arrived
3010 ;; Presumably "inferior-moz-process" loads comint.
3020 ;; Do some initialization the first time we see a process
3026 ;; Send interactor definition
3032 js-js-timeout))
3034 ;; Sanity check
3040 ;; If js--js-repl-depth > 0, we *should* be seeing an
3041 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
3042 ;; up with us.
3045 ;; Otherwise, tell Mozilla to enter the interactor mode
3051 js-js-timeout))
3065 js-js-timeout))))
3075 "Convert immediate js< and js! references to deferred ones."
3099 function))
3101 else
3102 collect item)))
3117 "Run FORMS with the Mozilla repl set up for js commands.
3118 Inside the lexical scope of `with-js', `js?', `js!',
3119 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
3120 `js-create-instance', and `js-qi' are defined."
3131 function)
3139 function)
3171 props)
3173 ))
3179 "Whether to listify any Array returned by a Mozilla function.
3186 (`array
3188 (`objid
3190 js--js-references)
3195 js--js-references)))
3203 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
3204 If function is a string, look it up as a property on the global
3205 object and use the global object for `this'.
3206 If FUNCTION is a list with one element, use that element as the
3207 function with the global object for `this', except that if that
3208 single element is a string, look it up on the global object.
3209 If FUNCTION is a list with more than one argument, use the list
3210 up to the last value as a property descriptor and the last
3211 argument as a function."
3218 ;; Actual funcall
3225 js-js-timeout)
3228 ;; Read the result
3235 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
3236 CONSTRUCTOR is a JS handle, a string, or a list of these things."
3239 constructor arguments))
3245 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
3248 arguments)))
3257 "Tell the repl about any objects we don't reference anymore.
3258 With argument, run even if no intervening GC has happened."
3269 ;; Don't bother running unless we've had an intervening
3270 ;; garbage collection; without a gc, nothing is deleted
3271 ;; from the weak hash table, so it's pointless telling
3272 ;; MozRepl about that references we still hold
3275 ;; Are we looking at a normal prompt? Make sure not to
3276 ;; interrupt the user if he's doing something
3284 of js--js-references
3285 collect x))
3292 num)))
3297 "Evaluate the JavaScript in JS and return JSON-decoded result."
3305 result)))
3308 "Enumerate all JavaScript contexts available.
3309 Each context is a list:
3310 (TITLE URL BROWSER TAB TABBROWSER) for content documents
3311 (TITLE URL WINDOW) for windows
3313 All tabs of a given window are grouped together. The most recent
3314 window is first. Within each window, the tabs are returned
3315 left-to-right."
3320 "@mozilla.org/appshell/window-mediator;1"
3342 window)
3349 "browsers"
3350 x
3351 "contentDocument"
3355 "browsers"
3356 x
3357 "contentWindow"
3358 "location"
3361 "browsers"
3362 x)
3365 "tabContainer"
3366 "childNodes"
3368 x)
3370 gbrowser))))))
3377 "Read a Mozilla tab with prompt PROMPT.
3378 Return a cons of (TYPE . OBJECT). TYPE is either `window' or
3379 `tab', and OBJECT is a JavaScript handle to a ChromeWindow or a
3380 browser, respectively."
3382 ;; Prime IDO
3389 selected-tab prev-hitab)
3391 ;; Disambiguate names
3394 for tab in tabs
3412 ;; Hack to reduce the number of
3413 ;; round-trips to mozilla
3416 ;; Highlighting tab
3419 "style"
3421 cmds)
3423 ;; Highlight window proper
3426 "style"
3428 cmds)
3430 ;; Select tab, when appropriate
3434 cmds)))
3436 ;; Highlighting whole window
3440 "style"
3443 cmds)))
3446 ;; Unhighlighting tab
3449 cmds)
3451 cmds))
3453 ;; Unhighlighting window
3458 cmds)))
3464 ()
3470 ()
3471 ;; Fiddle with the match list a bit: if our first match
3472 ;; is a tabbrowser window, rotate the match list until
3473 ;; the active tab comes up
3479 "document"
3480 "documentElement"
3485 "gBrowser"
3488 for match in ido-matches
3493 and return t)))
3499 ;; FIXME: Don't impose IDO on the user.
3504 prompt
3506 nil t nil
3523 "Helper function for `js-eval-defun'.
3524 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3525 strings making up the class name and NAME is the name of the
3526 function part."
3545 "The current JavaScript context.
3546 This is a cons like the one returned from `js--read-tab'.
3550 "(function(func_info,func) {
3551 func_info.unshift('window');
3552 var obj = window;
3553 for(var i = 1; i < func_info.length - 1; ++i) {
3554 var next = obj[func_info[i]];
3555 if(typeof next !== 'object' && typeof next !== 'function') {
3556 next = obj.prototype && obj.prototype[func_info[i]];
3557 if(typeof next !== 'object' && typeof next !== 'function') {
3558 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3559 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3560 return;
3561 }
3563 func_info.splice(i+1, 0, 'prototype');
3564 ++i;
3565 }
3566 }
3568 obj[func_info[i]] = func;
3569 alert('Successfully updated '+func_info.join('.'));
3573 "Set the JavaScript context to CONTEXT.
3574 When called interactively, prompt for CONTEXT."
3579 "Return a valid JavaScript context.
3580 If one hasn't been set, or if it's stale, prompt for a new one."
3590 js--js-context))
3605 file)))
3618 "Update a Mozilla tab using the JavaScript defun at point."
3621 ;; This function works by generating a temporary file that contains
3622 ;; the function we'd like to insert. We then use the elisp-js bridge
3623 ;; to command mozilla to load this file by inserting a script tag
3624 ;; into the document we set. This way, debuggers and such will have
3625 ;; a way to find the source of the just-inserted function.
3626 ;;
3627 ;; We delete the temporary file if there's an error, but otherwise
3628 ;; we add an unload event listener on the Mozilla side to delete the
3629 ;; file.
3660 ;; (Re)register a Mozilla resource URL to point to the
3661 ;; temporary directory
3679 ;; Give Mozilla responsibility for deleting this file
3684 ;; Regular content
3688 ;; Chrome
3710 ))
3712 ;; temp-name is set to nil on success
3716 ;;; Main Function
3718 ;;;###autoload
3720 "Major mode for editing JavaScript."
3734 ;; Comments
3739 ;; Parse cache
3742 ;; Frameworks
3745 ;; Imenu
3749 ;; for filling, pretend we're cc-mode
3752 c-paragraph-separate "$"
3753 c-block-comment-prefix "* "
3754 c-line-comment-starter "//"
3764 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3765 ;; we call it instead? (Bug#6071)
3773 ;; Important to fontify the whole buffer syntactically! If we don't,
3774 ;; then we might have regular expression literals that aren't marked
3775 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3776 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3777 ;; When we attempt to find the error and scroll to the portion of
3778 ;; the buffer containing the problem, JIT-lock will apply the
3779 ;; correct syntax to the regular expression literal and the problem
3780 ;; will mysteriously disappear.
3781 ;; FIXME: We should instead do this fontification lazily by adding
3782 ;; calls to syntax-propertize wherever it's really needed.
3783 ;;(syntax-propertize (point-max))
3784 )
3786 ;;;###autoload
3788 "Major mode for editing JSX.
3790 To customize the indentation for this mode, set the SGML offset
3791 variables (`sgml-basic-offset', `sgml-attribute-offset' et al.)
3792 locally, like so:
3794 (defun set-jsx-indentation ()
3795 (setq-local sgml-basic-offset js-indent-level))
3800 ;;;###autoload (defalias 'javascript-mode 'js-mode)
3806 ;;;###autoload
3812 ;; js.el ends here