| blob | e42e01481b634da4fccd2ec130065f468bae8391 |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2017 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;"
561 let x = svg.mumble()
562 .chained;
563 "
569 ;;; KeyMap
585 keymap)
588 ;;; Syntax table and parsing
595 table)
626 "Helper function for `js--update-quick-match-re'.
627 If LIST contains any element that is not nil, return its non-nil
628 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
629 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
630 nil. If any element in LIST is itself a list, flatten that
631 element."
637 "Internal function used by `js-mode' for caching buffer constructs.
638 This updates `js--quick-match-re', based on the current set of
639 enabled frameworks."
644 ;; #define mumble
653 ;; var mumble = THING (
674 ;; mumble.prototypeTHING
682 ;; mumble.prototype = {
689 "Move over the next value of PROPNAME in the buffer.
690 If found, return that value and leave point after the character
691 having that value; otherwise, return nil and leave point at EOB."
702 next-value))
705 "Move over the previous value of PROPNAME in the buffer.
706 If found, return that value and leave point just before the
707 character that has that value, otherwise return nil and leave
708 point at BOB."
721 prev-value)))
734 "Helper function for `js--re-search-forward'."
736 str-terminator
765 "Search forward, ignoring strings, cpp macros, and comments.
766 This function invokes `re-search-forward', but treats the buffer
767 as if strings, cpp macros, and comments have been removed.
769 If invoked while inside a macro, it treats the contents of the
770 macro as normal text."
787 "Auxiliary function for `js--re-search-backward'."
789 str-terminator
820 "Search backward, ignoring strings, preprocessor macros, and comments.
822 This function invokes `re-search-backward' but treats the buffer
823 as if strings, preprocessor macros, and comments have been
824 removed.
826 If invoked while inside a macro, treat the macro as normal text."
830 "Move forward over a whole JavaScript expression.
831 This function doesn't move over expressions continued across
832 lines."
834 ;; non-continued case; simplistic, but good enough?
847 "Move forward over a JavaScript function declaration.
848 This puts point at the `function' keyword.
850 If this is a syntactically-correct non-expression function,
851 return the name of the function, or t if the name could not be
852 determined. Otherwise, return nil."
868 name)))))
871 "Return the start of the JavaScript function prologue containing POS.
872 A function prologue is everything from start of the definition up
873 to and including the opening brace. POS defaults to point.
874 If POS is not in a function prologue, return nil."
901 "Helper function for `js-beginning-of-defun'.
902 Go to previous defun-beginning and return the parse state for it,
903 or nil if we went all the way back to bob and don't find
904 anything."
912 "Helper function for `js--beginning-of-defun-nested'.
913 If PSTATE represents a non-empty top-level defun, return the
914 top-most pitem. Otherwise, return nil."
917 with func-pitem
924 "Helper function for `js--beginning-of-defun'.
925 Return the pitem of the function we went to the beginning of."
927 ;; Look for the smallest function that encloses point...
932 and return pitem)
934 ;; ...and if that isn't found, look for the previous top-level
935 ;; defun
937 while pstate
940 and return it)))
943 "Helper function for `js-beginning-of-defun'."
949 "Value of `beginning-of-defun-function' for `js-mode'."
965 ;; If we're just past the end of a function, the user probably wants
966 ;; to go to the beginning of *that* function
980 "Flush the `js-mode' syntax cache after position BEG.
981 BEG defaults to `point-min', meaning to flush the entire cache."
987 ;; `(message ,@arguments)
988 )
997 ;; open-items must contain at least two items for this to
998 ;; work, but because we push a dummy item to start with,
999 ;; that assumption holds.
1002 open-items)
1005 "Helper function for `js--ensure-cache'.
1006 Update parsing information up to point, referring to parse,
1007 prev-parse-point, goal-point, and open-items bound lexically in
1008 the body of `js--ensure-cache'."
1015 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
1016 ;; the given depth -- i.e., make sure we're deeper than the target
1017 ;; depth.
1021 prev-parse-point goal-point
1023 nil parse))
1025 ;; (let ((overlay (make-overlay prev-parse-point (point))))
1026 ;; (overlay-put overlay 'face '(:background "red"))
1027 ;; (unwind-protect
1028 ;; (progn
1029 ;; (js--debug "parsed: %S" parse)
1030 ;; (sit-for 1))
1031 ;; (delete-overlay overlay)))
1047 "Split a JavaScript name into its dot-separated parts.
1048 This also removes any prototype parts from the split name
1060 "Guess the name of the JavaScript function at POSITION.
1062 Return the name of the function, or nil if the name could not be
1063 guessed.
1065 This function clobbers match data. If we find the preamble
1066 begins earlier than expected while guessing the function name,
1067 set `js--guess-function-name-start' to that position; otherwise,
1068 set that variable to nil."
1085 ;; Clear any endings that occur after point
1092 ;; Remove any cache properties after this point
1097 "Ensures brace cache is valid up to the character before LIMIT.
1098 LIMIT defaults to point."
1104 parse
1105 prev-parse-point
1106 name
1107 case-fold-search
1108 filtered-class-styles
1109 goal-point)
1111 ;; Figure out which class styles we need to look for
1115 js-enabled-frameworks)
1116 collect style))
1122 ;; Find last known good position
1138 ;; Make a placeholder for the top-level definition
1154 ;; Each of these conditions should return non-nil if
1155 ;; we should add a new item and leave point at the end
1156 ;; of the new item's header (h-end in the
1157 ;; js--pitem diagram). This point is the one
1158 ;; after the last character we need to unambiguously
1159 ;; detect this construct. If one of these evaluates to
1160 ;; nil, the location of the point is ignored.
1162 ;; In comment or string
1165 ;; Regular function declaration
1174 js--guess-function-name-start))
1181 :paren-depth orig-depth
1182 :h-begin orig-match-start
1185 name
1188 ;; Macro
1191 ;; Macros often contain unbalanced parentheses.
1192 ;; Make sure that h-end is at the textual end of
1193 ;; the macro no matter what the parenthesis say.
1199 :h-begin orig-match-start
1203 ;; "Prototype function" declaration
1210 :paren-depth orig-depth
1211 :h-begin orig-match-start
1217 ;; Class definition
1219 with syntactic-context =
1221 for class-style in filtered-class-styles
1227 and return
1229 :paren-depth orig-depth
1230 :h-begin orig-match-start
1231 :type class-style
1246 )))))
1249 "Helper function for `js-end-of-defun'."
1254 return t
1258 "Helper function for `js-end-of-defun'."
1267 found)
1270 ;; We're already inside a function; just go to its end.
1273 ;; Otherwise, go to the end of the next function...
1280 ;; ... or eob.
1284 "Value of `end-of-defun-function' for `js-mode'."
1295 ;; look for function backward. if we're inside it, go to that
1296 ;; function's end. otherwise, search for the next function's end and
1297 ;; go there
1301 ;; if we're doing nested functions, see whether we're in the
1302 ;; prologue. If we are, go to the end of the function; otherwise,
1303 ;; call js--end-of-defun-nested to do the real work
1324 t
1326 nil))))
1329 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1340 pos
1344 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1354 pos
1357 ;; Like (up-list -1), but only considers lists that end nearby"
1360 ;; Look at a very small region so our computation time doesn't
1361 ;; explode in pathological cases.
1366 "Return non-nil if point is in a function parameter list."
1377 "Return non-nil if point is in a Dojo multiple-inheritance class block."
1388 ;;; Font Lock
1390 "Helper function for building `js--font-lock-keywords'.
1391 Create a byte-compiled function for matching a concatenation of
1392 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1403 "Move forward over a JavaScript destructuring spec.
1404 If FUNC is supplied, call it with no arguments before every
1405 variable name in the spec. Return true if this was actually a
1406 spec. FUNC must preserve the match data."
1418 t)
1423 t))))
1426 t))
1440 t))
1445 t)))))
1448 t))))
1451 "Font-lock matcher for variable names in a variable declaration.
1452 This is a cc-mode-style matcher that *always* fails, from the
1453 point of view of font-lock. It applies highlighting directly with
1454 `font-lock-apply-highlight'."
1466 t))
1488 ;; Conditions to handle
1492 ;; Matcher always "fails"
1493 nil)
1496 `(
1497 ;; This goes before keywords-2 so it gets used preferentially
1498 ;; instead of the keywords in keywords-2. Don't use override
1499 ;; because that will override syntactic fontification too, which
1500 ;; will fontify commented-out directives as if they weren't
1501 ;; commented out.
1504 ,@js--font-lock-keywords-2
1509 ;; Highlights class being declared, in parts
1513 nil
1516 ;; Highlights parent class, in parts, if available
1533 ;; Highlights parent class
1537 ;; Dojo needs its own matcher to override the string highlighting
1539 'dojo
1546 ;; Match Dojo base classes. Of course Mojo has to be different
1547 ;; from everything else under the sun...
1549 'dojo
1558 ;; continued Dojo base-class list
1560 'dojo
1571 ;; variable declarations
1576 ;; class instantiation
1581 ;; instanceof
1586 ;; formal parameters
1590 js--name-start-re)
1596 ;; continued formal parameter list
1610 "Return whether point is inside the given pitem's header or body."
1620 "Parse the JavaScript program state at point.
1621 Return a list of `js--pitem' instances that apply to point, most
1622 specific first. In the worst case, the current toplevel instance
1623 will be returned."
1632 ;; Loop until we either hit a pitem at BOB or pitem ends after
1633 ;; point (or at point if we're at eob)
1640 pstate))))
1643 "Return the JavaScript syntactic context corresponding to PSTATE."
1646 type)
1652 "Return the JavaScript syntactic context at point.
1653 When called interactively, also display a message with that
1654 context."
1662 syntactic-context))
1665 "Font lock function used by `js-mode'.
1666 This performs fontification according to `js--class-styles'."
1674 js-enabled-frameworks)
1677 decl-re
1680 and return t)
1681 return t
1686 js--font-lock-keywords-2
1687 js--font-lock-keywords-3)
1695 st))
1700 ;; A /.../ regexp.
1705 js--syntax-propertize-regexp-syntax-table
1708 ;; A / within a character class is not the end of a regexp.
1709 t
1712 nil))))))
1715 ;; JavaScript allows immediate regular expression objects, written /.../.
1720 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1721 ;; FIXME: Allow regexps after infix ops like + ...
1722 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1723 ;; We can probably just add +, -, <, >, %, ^, ~, ?, : at which
1724 ;; point I think only * and / would be missing which could also be added,
1725 ;; but need care to avoid affecting the // and */ comment markers.
1730 ;; If the / is at the beginning of line, we have to check
1731 ;; the end of the previous text.
1749 ;;; Indentation
1767 "Return non-nil if point is on a JavaScript operator, other than a comma."
1780 ;; Generator method (possibly using computed property).
1784 ;; We might misindent some expressions that would
1785 ;; return NaN anyway. Shouldn't be a problem.
1789 "Move backward to the nearest newline that is not in a block comment."
1796 ;; We match the end of a // comment but not a newline in a
1797 ;; block comment.
1800 ;; If we saw a block comment, keep trying.
1804 result))
1807 "Return non-nil if the current line continues an expression."
1826 "Skip a term before point; return t if a term was skipped."
1828 ;; Skip backward over balanced parens.
1832 ;; First skip whitespace.
1834 ;; Now if we're looking at closing paren, skip to the opener.
1835 ;; This doesn't strictly follow JS syntax, in that we might
1836 ;; skip something nonsensical like "()[]{}", but it is enough
1837 ;; if it works ok for valid input.
1841 ;; Maybe skip over a symbol.
1845 ;; Skipped.
1849 ;; Did not skip, so restore point.
1856 "Skip any number of terms backward.
1858 Returns t if successful, nil if no term was found."
1860 ;; Found at least one.
1865 t)))
1868 "A helper for js--proper-indentation that handles chained expressions.
1869 A chained expression is when the current line starts with '.' and the
1870 previous line also has a '.' expression.
1871 This function returns the indentation for the current line if it is
1872 a chained expression line; otherwise nil.
1873 This should only be called while point is at the start of the line's content,
1874 as determined by `back-to-indentation'."
1885 Otherwise, return nil. A braceless do-while statement spanning
1886 several lines requires that the start of the loop is indented to
1887 the same column as the current line."
1909 "Helper function for `js--proper-indentation'.
1910 Return the proper indentation of the current line if it starts
1911 the body of a control statement without braces; otherwise, return
1912 nil."
1941 "Helper function for `js--proper-indentation'.
1942 Return the proper indentation of the current line if it belongs to a declaration
1943 statement spanning multiple lines; otherwise, return nil."
1945 at-opening-bracket)
1972 "Return non-nil if we think we're in an array comprehension.
1973 In particular, return the buffer position of the first `for' kwd."
1987 ;; To skip arbitrary expressions we need the parser,
1988 ;; so we'll just guess at it.
1991 ;; Not inside comment or string literal.
1999 ;; First continuation line.
2010 "Helper function for `js--proper-indentation'.
2011 Depending on the value of `js-indent-first-init', move
2012 point to the end of a variable declaration keyword so that
2013 indentation is aligned to that column."
2020 declaration-keyword-end
2021 at-closing-bracket-p
2022 forward-sexp-function ; Use Lisp version.
2023 comma-p)
2032 t)
2041 "Return the proper indentation for the current line."
2049 ;; Indent array comprehension continuation lines specially.
2051 beg)
2055 ;; At or after the first loop?
2062 ;; A single closing paren/bracket should be indented at the
2063 ;; same level as the opening statement. Same goes for
2064 ;; "case" and "default".
2079 in-switch-p)))
2085 js-expr-indent-offset))
2094 indent)))
2095 ;; If there is something following the opening
2096 ;; paren/bracket, everything else should be indented at
2097 ;; the same level.
2107 ;;; JSX Indentation
2110 "Find where JSX starts.
2112 Assume JSX appears in the following instances:
2113 - Inside parentheses, when returned or as the first argument
2114 to a function, and after a newline
2115 - When assigned to variables or object properties, but only
2116 on a single line
2117 - As the N+1th argument to a function
2120 nil t), except set point to the end of the match. This logic
2121 executes up to the number of lines in the file, so it should be
2122 really fast to reduce that impact."
2130 pos))
2137 "Find where JSX ends.
2138 This complements the assumption of where JSX appears from
2142 "Determine if/how the current line should be indented as JSX.
2144 Return `first' for the first JSXElement on its own line.
2145 Return `nth' for subsequent lines of the first JSXElement.
2146 Return `expression' for an embedded JS expression.
2147 Return `after' for anything after the last JSXElement.
2148 Return nil for non-JSX lines.
2150 Currently, JSX indentation supports the following styles:
2152 - Single-line elements (indented like normal JS):
2154 var element = <div></div>;
2156 - Multi-line elements (enclosed in parentheses):
2158 function () {
2159 return (
2160 <div>
2161 <div></div>
2162 </div>
2163 );
2164 }
2166 - Function arguments:
2168 React.render(
2169 <div></div>,
2170 document.querySelector('.root')
2171 );"
2174 last-pos
2175 before-tag-pos before-tag-line
2176 tag-start-pos tag-start-line
2177 tag-end-pos tag-end-line
2178 after-tag-line
2179 parens paren type)
2182 ;; Determine if we're inside a jsx element
2192 tag-start-pos)
2197 ;; A "before" line which also starts an element begins with js, so
2198 ;; indent it like js
2200 ;; Only indent the jsx lines like jsx
2203 ;; Analyze bounds if there are any
2210 tag-end-pos)
2214 ;; Ensure we're actually within the bounds of the jsx
2216 ;; An "after" line which does not end an element begins with
2217 ;; js, so indent it like js
2220 ;; Handle another case where there could be e.g. comments after
2221 ;; the element
2225 ;; They may not be any bounds (yet)
2227 ;; Check if we're inside an embedded multi-line js expression
2237 ;; Curly bracket indicates the start of an embedded expression
2239 ;; The first line of the expression is indented like sgml
2241 ;; Check if within a closing curly bracket (if any)
2242 ;; (exclusive, as the closing bracket is indented like sgml)
2250 ;; Indicate this guy will be indented specially
2253 t)
2257 ;; Indent the first jsx thing like js so we can indent future jsx things
2258 ;; like sgml relative to the first thing
2263 "Execute BODY as if in sgml-mode."
2266 parse-sexp-lookup-properties)
2270 "Indent the current line as JavaScript or SGML (whichever is farther)."
2273 ;; Don't whine about errors/warnings when we're indenting.
2274 ;; This has to be set before calling parse-partial-sexp below.
2278 ;; Don't touch multiline strings.
2285 'noindent
2286 ;; Use whichever indentation column is greater, such that the sgml
2287 ;; column is effectively a minimum
2295 "Indent the current line as JavaScript."
2305 "Indent the current line as JSX (with SGML offsets).
2306 i.e., customize JSX element indentation with `sgml-basic-offset',
2307 `sgml-attribute-offset' et al."
2315 ;; Don't treat this first thing as a continued expression (often a "<" or
2316 ;; ">" causes this misinterpretation)
2323 ;;; Filling
2327 ;; FIXME: Such redefinitions are bad style. We should try and use some other
2328 ;; way to get the same result.
2332 ad-do-it))
2337 ad-do-it))
2342 ad-do-it))
2345 "Fill the paragraph with `c-fill-paragraph'."
2351 ;;; Type database and Imenu
2353 ;; We maintain a cache of semantic information, i.e., the classes and
2354 ;; functions we've encountered so far. In order to avoid having to
2355 ;; re-parse the buffer on every change, we cache the parse state at
2356 ;; each interesting point in the buffer. Each parse state is a
2357 ;; modified copy of the previous one, or in the case of the first
2358 ;; parse state, the empty state.
2359 ;;
2360 ;; The parse state itself is just a stack of js--pitem
2361 ;; instances. It starts off containing one element that is never
2362 ;; closed, that is initially js--initial-pitem.
2363 ;;
2371 name
2373 type
2377 "Helper function for `js--splice-into-items'.
2378 Return a new item that is the result of merging CHILD into
2379 ITEM. NAME-PARTS is a list of parts of the name of CHILD
2380 that we haven't consumed yet."
2385 ;; If the item we're merging into isn't a class, make it into one
2391 ;; Use the child's class-style if it's available
2393 js--dummy-class-style
2398 ;; Now we can merge either a function or a class into a class
2402 ;; if we have more name-parts to go before we get to the
2403 ;; bottom of the class hierarchy, call the merger
2404 ;; recursively
2410 ;; Not merging a class, but something else, so just prepend
2411 ;; it
2415 ;; Otherwise, merge the new child's items into those
2416 ;; of the new class
2422 "Last part of the name of PITEM, as a string or symbol."
2426 name)))
2429 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
2430 If a class doesn't exist in the tree, create it. Return
2431 the new items list. NAME-PARTS is a list of strings given
2432 the broken-down class name of the item to insert."
2436 new-items last-new-item new-cons)
2439 name-parts
2445 ;; If top-name isn't found in items, then we build a copy of items
2446 ;; and throw it away. But that's okay, since most of the time, we
2447 ;; *will* find an instance.
2451 ;; Okay, we found an entry with the right name. Splice
2452 ;; the merged item into the list...
2455 name-parts)
2462 ;; ...and terminate the loop
2463 nil)
2466 ;; Otherwise, copy the current cons and move onto the
2467 ;; text. This is tricky; we keep track of the tail of
2468 ;; the list that begins with new-items in
2469 ;; last-new-item.
2476 ;; Go to the next cell in items
2480 ;; Yay! We stopped because we found something, not because
2481 ;; we ran out of items to search. Just return the new
2482 ;; list.
2485 new-items)
2487 ;; We didn't find anything. If the child is a class and we don't
2488 ;; have any classes to drill down into, just push that class;
2489 ;; otherwise, make a fake class and carry on.
2492 ;; We have name-parts left to process. Make a fake
2493 ;; class for this particular part...
2495 ;; ...and recursively digest the rest of the name
2498 :type js--dummy-class-style
2501 ;; Otherwise, this is the only name we have, so stick
2502 ;; the item on the front of the list
2503 child)
2504 items))))
2507 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2512 t))
2514 ;; This trick works because we know (based on our defstructs) that
2515 ;; the child list is always the first element, and so the second
2516 ;; element and beyond can be shared when we make our "copy".
2523 ;; Use slow path because we need class lookup
2529 ;; Use slow path because we need class merging. We know
2530 ;; name is a list here because down in
2531 ;; `js--ensure-cache', we made sure to only add
2532 ;; class entries with lists for :name
2537 ;; Fast path
2543 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2546 location))
2549 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2566 imenu-items))
2571 unknown-ctr))
2574 imenu-items))
2583 imenu-items))))
2587 imenu-items))
2590 "Return an imenu index for the current buffer."
2602 ;; Make sure everything is closed
2610 ;; Convert the new-finalized state into what imenu expects
2613 unknown-ctr))))))
2615 ;; Silence the compiler.
2626 symbols)
2627 else
2638 "Return a hash table of all JavaScript symbols.
2639 This searches all existing `js-mode' buffers. Each key is the
2640 name of a symbol (possibly disambiguated with <N>, where N > 1),
2641 and each value is a marker giving the location of that symbol."
2643 with imenu-use-markers = t
2644 for buffer being the buffers
2649 finally return symbols))
2655 "Helper function for `js-find-symbol'.
2656 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2657 one from `js--get-all-known-symbols', using prompt PROMPT and
2658 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2659 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2660 marker."
2666 prompt
2668 collect key)
2684 ;; etags loads ring.
2688 "Read a JavaScript symbol and jump to it.
2689 With a prefix argument, restrict symbols to those from the
2690 current buffer. Pushes a mark onto the tag ring just like
2691 `find-tag'."
2702 symbols "Jump to: "
2710 ;;; MozRepl integration
2717 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2718 On timeout, return nil. On success, return t with match data
2719 set. If START is non-nil, look for output starting from START.
2720 Otherwise, use the current value of `process-mark'."
2732 'js-moz-bad-rpc
2736 ;; Integer, mirrors the value we see in JS
2739 ;; Process to which this thing belongs
2760 ; */" Make Emacs happy
2761 "(function(repl) {
2762 repl.defineInteractor('js', {
2763 onStart: function onStart(repl) {
2764 if(!repl._jsObjects) {
2765 repl._jsObjects = {};
2766 repl._jsLastID = 0;
2767 repl._jsGC = this._jsGC;
2768 }
2769 this._input = '';
2770 },
2772 _jsGC: function _jsGC(ids_in_use) {
2773 var objects = this._jsObjects;
2774 var keys = [];
2775 var num_freed = 0;
2777 for(var pn in objects) {
2778 keys.push(Number(pn));
2779 }
2781 keys.sort(function(x, y) x - y);
2782 ids_in_use.sort(function(x, y) x - y);
2783 var i = 0;
2784 var j = 0;
2786 while(i < ids_in_use.length && j < keys.length) {
2787 var id = ids_in_use[i++];
2788 while(j < keys.length && keys[j] !== id) {
2789 var k_id = keys[j++];
2790 delete objects[k_id];
2791 ++num_freed;
2792 }
2793 ++j;
2794 }
2796 while(j < keys.length) {
2797 var k_id = keys[j++];
2798 delete objects[k_id];
2799 ++num_freed;
2800 }
2802 return num_freed;
2803 },
2805 _mkArray: function _mkArray() {
2806 var result = [];
2807 for(var i = 0; i < arguments.length; ++i) {
2808 result.push(arguments[i]);
2809 }
2810 return result;
2811 },
2813 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2814 if(typeof parts === 'string') {
2815 parts = [ parts ];
2816 }
2818 var obj = parts[0];
2819 var start = 1;
2821 if(typeof obj === 'string') {
2822 obj = window;
2823 start = 0;
2824 } else if(parts.length < 2) {
2825 throw new Error('expected at least 2 arguments');
2826 }
2828 for(var i = start; i < parts.length - 1; ++i) {
2829 obj = obj[parts[i]];
2830 }
2832 return [obj, parts[parts.length - 1]];
2833 },
2835 _getProp: function _getProp(/*...*/) {
2836 if(arguments.length === 0) {
2837 throw new Error('no arguments supplied to getprop');
2838 }
2840 if(arguments.length === 1 &&
2841 (typeof arguments[0]) !== 'string')
2842 {
2843 return arguments[0];
2844 }
2846 var [obj, propname] = this._parsePropDescriptor(arguments);
2847 return obj[propname];
2848 },
2850 _putProp: function _putProp(properties, value) {
2851 var [obj, propname] = this._parsePropDescriptor(properties);
2852 obj[propname] = value;
2853 },
2855 _delProp: function _delProp(propname) {
2856 var [obj, propname] = this._parsePropDescriptor(arguments);
2857 delete obj[propname];
2858 },
2860 _typeOf: function _typeOf(thing) {
2861 return typeof thing;
2862 },
2864 _callNew: function(constructor) {
2865 if(typeof constructor === 'string')
2866 {
2867 constructor = window[constructor];
2868 } else if(constructor.length === 1 &&
2869 typeof constructor[0] !== 'string')
2870 {
2871 constructor = constructor[0];
2872 } else {
2873 var [obj,propname] = this._parsePropDescriptor(constructor);
2874 constructor = obj[propname];
2875 }
2877 /* Hacky, but should be robust */
2878 var s = 'new constructor(';
2879 for(var i = 1; i < arguments.length; ++i) {
2880 if(i != 1) {
2881 s += ',';
2882 }
2884 s += 'arguments[' + i + ']';
2885 }
2887 s += ')';
2888 return eval(s);
2889 },
2891 _callEval: function(thisobj, js) {
2892 return eval.call(thisobj, js);
2893 },
2895 getPrompt: function getPrompt(repl) {
2896 return 'EVAL>'
2897 },
2899 _lookupObject: function _lookupObject(repl, id) {
2900 if(typeof id === 'string') {
2901 switch(id) {
2902 case 'global':
2903 return window;
2904 case 'nil':
2905 return null;
2906 case 't':
2907 return true;
2908 case 'false':
2909 return false;
2910 case 'undefined':
2911 return undefined;
2912 case 'repl':
2913 return repl;
2914 case 'interactor':
2915 return this;
2916 case 'NaN':
2917 return NaN;
2918 case 'Infinity':
2919 return Infinity;
2920 case '-Infinity':
2921 return -Infinity;
2922 default:
2923 throw new Error('No object with special id:' + id);
2924 }
2925 }
2927 var ret = repl._jsObjects[id];
2928 if(ret === undefined) {
2929 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2930 }
2931 return ret;
2932 },
2934 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2935 if(typeof value !== 'object' && typeof value !== 'function') {
2936 throw new Error('_findOrAllocateObject called on non-object('
2937 + typeof(value) + '): '
2938 + value)
2939 }
2941 for(var id in repl._jsObjects) {
2942 id = Number(id);
2943 var obj = repl._jsObjects[id];
2944 if(obj === value) {
2945 return id;
2946 }
2947 }
2949 var id = ++repl._jsLastID;
2950 repl._jsObjects[id] = value;
2951 return id;
2952 },
2954 _fixupList: function _fixupList(repl, list) {
2955 for(var i = 0; i < list.length; ++i) {
2956 if(list[i] instanceof Array) {
2957 this._fixupList(repl, list[i]);
2958 } else if(typeof list[i] === 'object') {
2959 var obj = list[i];
2960 if(obj.funcall) {
2961 var parts = obj.funcall;
2962 this._fixupList(repl, parts);
2963 var [thisobj, func] = this._parseFunc(parts[0]);
2964 list[i] = func.apply(thisobj, parts.slice(1));
2965 } else if(obj.objid) {
2966 list[i] = this._lookupObject(repl, obj.objid);
2967 } else {
2968 throw new Error('Unknown object type: ' + obj.toSource());
2969 }
2970 }
2971 }
2972 },
2974 _parseFunc: function(func) {
2975 var thisobj = null;
2977 if(typeof func === 'string') {
2978 func = window[func];
2979 } else if(func instanceof Array) {
2980 if(func.length === 1 && typeof func[0] !== 'string') {
2981 func = func[0];
2982 } else {
2983 [thisobj, func] = this._parsePropDescriptor(func);
2984 func = thisobj[func];
2985 }
2986 }
2988 return [thisobj,func];
2989 },
2991 _encodeReturn: function(value, array_as_mv) {
2992 var ret;
2994 if(value === null) {
2995 ret = ['special', 'null'];
2996 } else if(value === true) {
2997 ret = ['special', 'true'];
2998 } else if(value === false) {
2999 ret = ['special', 'false'];
3000 } else if(value === undefined) {
3001 ret = ['special', 'undefined'];
3002 } else if(typeof value === 'number') {
3003 if(isNaN(value)) {
3004 ret = ['special', 'NaN'];
3005 } else if(value === Infinity) {
3006 ret = ['special', 'Infinity'];
3007 } else if(value === -Infinity) {
3008 ret = ['special', '-Infinity'];
3009 } else {
3010 ret = ['atom', value];
3011 }
3012 } else if(typeof value === 'string') {
3013 ret = ['atom', value];
3014 } else if(array_as_mv && value instanceof Array) {
3015 ret = ['array', value.map(this._encodeReturn, this)];
3016 } else {
3017 ret = ['objid', this._findOrAllocateObject(repl, value)];
3018 }
3020 return ret;
3021 },
3023 _handleInputLine: function _handleInputLine(repl, line) {
3024 var ret;
3025 var array_as_mv = false;
3027 try {
3028 if(line[0] === '*') {
3029 array_as_mv = true;
3030 line = line.substring(1);
3031 }
3032 var parts = eval(line);
3033 this._fixupList(repl, parts);
3034 var [thisobj, func] = this._parseFunc(parts[0]);
3035 ret = this._encodeReturn(
3036 func.apply(thisobj, parts.slice(1)),
3037 array_as_mv);
3038 } catch(x) {
3039 ret = ['error', x.toString() ];
3040 }
3042 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
3043 repl.print(JSON.encode(ret));
3044 repl._prompt();
3045 },
3047 handleInput: function handleInput(repl, chunk) {
3048 this._input += chunk;
3049 var match, line;
3051 line = match[0];
3054 repl.popInteractor();
3055 repl._prompt();
3056 return;
3057 }
3059 this._input = this._input.substring(line.length);
3060 this._handleInputLine(repl, line);
3061 }
3062 }
3063 });
3064 })
3070 "Marshall the given value for JS.
3071 Strings and numbers are JSON-encoded. Lists (including nil) are
3072 made into JavaScript array literals and their contents encoded
3073 with `js--js-encode-value'."
3100 js--js-repl-prompt-regexp js-js-timeout
3102 ;; start matching against the beginning of the line in
3103 ;; order to catch a prompt that's only partially arrived
3106 ;; Presumably "inferior-moz-process" loads comint.
3116 ;; Do some initialization the first time we see a process
3122 ;; Send interactor definition
3128 js-js-timeout))
3130 ;; Sanity check
3136 ;; If js--js-repl-depth > 0, we *should* be seeing an
3137 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
3138 ;; up with us.
3141 ;; Otherwise, tell Mozilla to enter the interactor mode
3147 js-js-timeout))
3161 js-js-timeout))))
3171 "Convert immediate js< and js! references to deferred ones."
3195 function))
3197 else
3198 collect item)))
3213 "Run FORMS with the Mozilla repl set up for js commands.
3214 Inside the lexical scope of `with-js', `js?', `js!',
3215 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
3216 `js-create-instance', and `js-qi' are defined."
3227 function)
3235 function)
3267 props)
3269 ))
3275 "Whether to listify any Array returned by a Mozilla function.
3282 (`array
3284 (`objid
3286 js--js-references)
3291 js--js-references)))
3299 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
3300 If function is a string, look it up as a property on the global
3301 object and use the global object for `this'.
3302 If FUNCTION is a list with one element, use that element as the
3303 function with the global object for `this', except that if that
3304 single element is a string, look it up on the global object.
3305 If FUNCTION is a list with more than one argument, use the list
3306 up to the last value as a property descriptor and the last
3307 argument as a function."
3314 ;; Actual funcall
3321 js-js-timeout)
3324 ;; Read the result
3331 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
3332 CONSTRUCTOR is a JS handle, a string, or a list of these things."
3335 constructor arguments))
3341 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
3344 arguments)))
3353 "Tell the repl about any objects we don't reference anymore.
3354 With argument, run even if no intervening GC has happened."
3365 ;; Don't bother running unless we've had an intervening
3366 ;; garbage collection; without a gc, nothing is deleted
3367 ;; from the weak hash table, so it's pointless telling
3368 ;; MozRepl about that references we still hold
3371 ;; Are we looking at a normal prompt? Make sure not to
3372 ;; interrupt the user if he's doing something
3380 of js--js-references
3381 collect x))
3388 num)))
3393 "Evaluate the JavaScript in JS and return JSON-decoded result."
3401 result)))
3404 "Enumerate all JavaScript contexts available.
3405 Each context is a list:
3406 (TITLE URL BROWSER TAB TABBROWSER) for content documents
3407 (TITLE URL WINDOW) for windows
3409 All tabs of a given window are grouped together. The most recent
3410 window is first. Within each window, the tabs are returned
3411 left-to-right."
3416 "@mozilla.org/appshell/window-mediator;1"
3442 "browsers"
3443 x
3444 "contentDocument"
3448 "browsers"
3449 x
3450 "contentWindow"
3451 "location"
3454 "browsers"
3455 x)
3458 "tabContainer"
3459 "childNodes"
3461 x)
3463 gbrowser))))))
3470 "Read a Mozilla tab with prompt PROMPT.
3471 Return a cons of (TYPE . OBJECT). TYPE is either `window' or
3472 `tab', and OBJECT is a JavaScript handle to a ChromeWindow or a
3473 browser, respectively."
3475 ;; Prime IDO
3482 selected-tab prev-hitab)
3484 ;; Disambiguate names
3487 for tab in tabs
3505 ;; Hack to reduce the number of
3506 ;; round-trips to mozilla
3509 ;; Highlighting tab
3512 "style"
3514 cmds)
3516 ;; Highlight window proper
3519 "style"
3521 cmds)
3523 ;; Select tab, when appropriate
3527 cmds)))
3529 ;; Highlighting whole window
3533 "style"
3536 cmds)))
3539 ;; Unhighlighting tab
3542 cmds)
3544 cmds))
3546 ;; Unhighlighting window
3551 cmds)))
3557 ()
3563 ()
3564 ;; Fiddle with the match list a bit: if our first match
3565 ;; is a tabbrowser window, rotate the match list until
3566 ;; the active tab comes up
3572 "document"
3573 "documentElement"
3578 "gBrowser"
3581 for match in ido-matches
3586 and return t)))
3592 ;; FIXME: Don't impose IDO on the user.
3597 prompt
3599 nil t nil
3616 "Helper function for `js-eval-defun'.
3617 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3618 strings making up the class name and NAME is the name of the
3619 function part."
3638 "The current JavaScript context.
3639 This is a cons like the one returned from `js--read-tab'.
3643 "(function(func_info,func) {
3644 func_info.unshift('window');
3645 var obj = window;
3646 for(var i = 1; i < func_info.length - 1; ++i) {
3647 var next = obj[func_info[i]];
3648 if(typeof next !== 'object' && typeof next !== 'function') {
3649 next = obj.prototype && obj.prototype[func_info[i]];
3650 if(typeof next !== 'object' && typeof next !== 'function') {
3651 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3652 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3653 return;
3654 }
3656 func_info.splice(i+1, 0, 'prototype');
3657 ++i;
3658 }
3659 }
3661 obj[func_info[i]] = func;
3662 alert('Successfully updated '+func_info.join('.'));
3666 "Set the JavaScript context to CONTEXT.
3667 When called interactively, prompt for CONTEXT."
3672 "Return a valid JavaScript context.
3673 If one hasn't been set, or if it's stale, prompt for a new one."
3683 js--js-context))
3698 file)))
3711 "Update a Mozilla tab using the JavaScript defun at point."
3714 ;; This function works by generating a temporary file that contains
3715 ;; the function we'd like to insert. We then use the elisp-js bridge
3716 ;; to command mozilla to load this file by inserting a script tag
3717 ;; into the document we set. This way, debuggers and such will have
3718 ;; a way to find the source of the just-inserted function.
3719 ;;
3720 ;; We delete the temporary file if there's an error, but otherwise
3721 ;; we add an unload event listener on the Mozilla side to delete the
3722 ;; file.
3753 ;; (Re)register a Mozilla resource URL to point to the
3754 ;; temporary directory
3772 ;; Give Mozilla responsibility for deleting this file
3777 ;; Regular content
3781 ;; Chrome
3803 ))
3805 ;; temp-name is set to nil on success
3809 ;;; Main Function
3811 ;;;###autoload
3813 "Major mode for editing JavaScript."
3827 ;; Comments
3832 ;; Parse cache
3835 ;; Frameworks
3838 ;; Imenu
3842 ;; for filling, pretend we're cc-mode
3845 c-paragraph-separate "$"
3846 c-block-comment-prefix "* "
3847 c-line-comment-starter "//"
3860 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3861 ;; we call it instead? (Bug#6071)
3869 ;; Important to fontify the whole buffer syntactically! If we don't,
3870 ;; then we might have regular expression literals that aren't marked
3871 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3872 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3873 ;; When we attempt to find the error and scroll to the portion of
3874 ;; the buffer containing the problem, JIT-lock will apply the
3875 ;; correct syntax to the regular expression literal and the problem
3876 ;; will mysteriously disappear.
3877 ;; FIXME: We should instead do this fontification lazily by adding
3878 ;; calls to syntax-propertize wherever it's really needed.
3879 ;;(syntax-propertize (point-max))
3880 )
3882 ;;;###autoload
3884 "Major mode for editing JSX.
3886 To customize the indentation for this mode, set the SGML offset
3887 variables (`sgml-basic-offset', `sgml-attribute-offset' et al.)
3888 locally, like so:
3890 (defun set-jsx-indentation ()
3891 (setq-local sgml-basic-offset js-indent-level))
3896 ;;;###autoload (defalias 'javascript-mode 'js-mode)
3902 ;;;###autoload
3908 ;; js.el ends here