| blob | c25e52cdc6a0f498681d10176b3362ad1e021796 |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2015 Free Software Foundation, Inc.
5 ;; Author: Karl Landstrom <karl.landstrom@brgeight.se>
6 ;; Daniel Colascione <dan.colascione@gmail.com>
7 ;; Maintainer: Daniel Colascione <dan.colascione@gmail.com>
8 ;; Version: 9
9 ;; Date: 2009-07-25
10 ;; Keywords: languages, javascript
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;;; Commentary
29 ;; This is based on Karl Landstrom's barebones javascript-mode. This
30 ;; is much more robust and works with cc-mode's comment filling
31 ;; (mostly).
32 ;;
33 ;; The main features of this JavaScript mode are syntactic
34 ;; highlighting (enabled with `font-lock-mode' or
35 ;; `global-font-lock-mode'), automatic indentation and filling of
36 ;; comments, C preprocessor fontification, and MozRepl integration.
37 ;;
38 ;; General Remarks:
39 ;;
40 ;; XXX: This mode assumes that block comments are not nested inside block
41 ;; XXX: comments
42 ;;
43 ;; Exported names start with "js-"; private names start with
44 ;; "js--".
46 ;;; Code:
67 ;;; Constants
89 "Regexp matching the prefix of a cpp directive.
90 This includes the directive name, or nil in languages without
91 preprocessor support. The first submatch surrounds the directive
98 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
107 ;; var NewClass = BaseClass.extend(
115 ;; var NewClass = Class.create()
131 ;; var NewClass = Class.create({
138 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
139 ;; matched with dedicated font-lock matchers
167 :prototype t
173 :prototype t
189 :prototype t
195 :prototype t
206 :prototype t
220 "List of JavaScript class definition styles.
222 A class definition style is a plist with the following keys:
224 :name is a human-readable name of the class type
226 :class-decl is a regular expression giving the start of the
227 class. Its first group must match the name of its class. If there
228 is a parent class, the second group should match, and it should be
229 the name of the class.
231 If :prototype is present and non-nil, the parser will merge
232 declarations for this constructs with others at the same lexical
233 level that have the same name. Otherwise, multiple definitions
234 will create multiple top-level entries. Don't use :prototype
235 unnecessarily: it has an associated cost in performance.
237 If :strip-prototype is present and non-nil, then if the class
238 name as matched contains
245 collect framework into available-frameworks
246 finally return available-frameworks)
252 "Regexp matching the start of a JavaScript function header.
258 "Regexp matching the start of a function entry in an associative array.
270 "Regexp matching a CPP macro definition, up to the opening parenthesis.
320 ;; js--pitem is the basic building block of the lexical
321 ;; database. When one refers to a real part of the buffer, the region
322 ;; of text to which it refers is split into a conceptual header and
323 ;; body. Consider the (very short) block described by a hypothetical
324 ;; js--pitem:
325 ;;
326 ;; function foo(a,b,c) { return 42; }
327 ;; ^ ^ ^
328 ;; | | |
329 ;; +- h-begin +- h-end +- b-end
330 ;;
331 ;; (Remember that these are buffer positions, and therefore point
332 ;; between characters, not at them. An arrow drawn to a character
333 ;; indicates the corresponding position is between that character and
334 ;; the one immediately preceding it.)
335 ;;
336 ;; The header is the region of text [h-begin, h-end], and is
337 ;; the text needed to unambiguously recognize the start of the
338 ;; construct. If the entire header is not present, the construct is
339 ;; not recognized at all. No other pitems may be nested inside the
340 ;; header.
341 ;;
342 ;; The body is the region [h-end, b-end]. It may contain nested
343 ;; js--pitem instances. The body of a pitem may be empty: in
344 ;; that case, b-end is equal to header-end.
345 ;;
346 ;; The three points obey the following relationship:
347 ;;
348 ;; h-begin < h-end <= b-end
349 ;;
350 ;; We put a text property in the buffer on the character *before*
351 ;; h-end, and if we see it, on the character *before* b-end.
352 ;;
353 ;; The text property for h-end, js--pstate, is actually a list
354 ;; of all js--pitem instances open after the marked character.
355 ;;
356 ;; The text property for b-end, js--pend, is simply the
357 ;; js--pitem that ends after the marked character. (Because
358 ;; pitems always end when the paren-depth drops below a critical
359 ;; value, and because we can only drop one level per character, only
360 ;; one pitem may end at a given character.)
361 ;;
362 ;; In the structure below, we only store h-begin and (sometimes)
363 ;; b-end. We can trivially and quickly find h-end by going to h-begin
364 ;; and searching for an js--pstate text property. Since no other
365 ;; js--pitem instances can be nested inside the header of a
366 ;; pitem, the location after the character with this text property
367 ;; must be h-end.
368 ;;
369 ;; js--pitem instances are never modified (with the exception
370 ;; of the b-end field). Instead, modified copies are added at
371 ;; subsequence parse points.
372 ;; (The exception for b-end and its caveats is described below.)
373 ;;
376 ;; IMPORTANT: Do not alter the position of fields within the list.
377 ;; Various bits of code depend on their positions, particularly
378 ;; anything that manipulates the list of children.
380 ;; List of children inside this pitem's body
383 ;; When we reach this paren depth after h-end, the pitem ends
386 ;; Symbol or class-style plist if this is a class
389 ;; See above
392 ;; List of strings giving the parts of the name of this pitem (e.g.,
393 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
396 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
397 ;; this pitem: when we copy-and-modify pitem instances, we share
398 ;; their tail structures, so all the copies actually have the same
399 ;; terminating cons cell. We modify that shared cons cell directly.
400 ;;
401 ;; The field value is either a number (buffer location) or nil if
402 ;; unknown.
403 ;;
404 ;; If the field's value is greater than `js--cache-end', the
405 ;; value is stale and must be treated as if it were nil. Conversely,
406 ;; if this field is nil, it is guaranteed that this pitem is open up
407 ;; to at least `js--cache-end'. (This property is handy when
408 ;; computing whether we're inside a given pitem.)
409 ;;
412 ;; The pitem we start parsing with.
415 :paren-depth most-negative-fixnum
418 ;;; User Customization
421 "Customization variables for JavaScript mode."
426 "Number of spaces for each indentation step in `js-mode'."
432 "Number of additional spaces for indenting continued expressions.
433 The value must be no less than minus `js-indent-level'."
439 "Number of additional spaces for indenting expressions in parentheses.
440 The value must be no less than minus `js-indent-level'."
447 "Number of additional spaces for indenting expressions in square braces.
448 The value must be no less than minus `js-indent-level'."
455 "Number of additional spaces for indenting expressions in curly braces.
456 The value must be no less than minus `js-indent-level'."
463 "Number of additional spaces for indenting the contents of a switch block.
464 The value must not be negative."
471 "Treat nested functions as top-level functions in `js-mode'.
472 This applies to function movement, marking, and so on."
477 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
482 "Frameworks recognized by `js-mode'.
483 To improve performance, you may turn off some frameworks you
484 seldom use, either globally or on a per-buffer basis."
487 js--available-frameworks))
492 "Whether `js-mode' should display tabs while selecting them.
493 This is useful only if the windowing system has a good mechanism
494 for preventing Firefox from stealing the keyboard focus."
499 "~/.emacs.d/js/js"
500 "Temporary directory used by `js-mode' to communicate with Mozilla.
501 This directory must be readable and writable by both Mozilla and Emacs."
506 "Reply timeout for executing commands in Mozilla via `js-mode'.
507 The value is given in seconds. Increase this value if you are
508 getting timeout messages."
512 ;;; KeyMap
528 keymap)
531 ;;; Syntax table and parsing
537 table)
568 "Helper function for `js--update-quick-match-re'.
569 If LIST contains any element that is not nil, return its non-nil
570 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
571 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
572 nil. If any element in LIST is itself a list, flatten that
573 element."
579 "Internal function used by `js-mode' for caching buffer constructs.
580 This updates `js--quick-match-re', based on the current set of
581 enabled frameworks."
586 ;; #define mumble
595 ;; var mumble = THING (
616 ;; mumble.prototypeTHING
624 ;; mumble.prototype = {
631 "Move over the next value of PROPNAME in the buffer.
632 If found, return that value and leave point after the character
633 having that value; otherwise, return nil and leave point at EOB."
644 next-value))
647 "Move over the previous value of PROPNAME in the buffer.
648 If found, return that value and leave point just before the
649 character that has that value, otherwise return nil and leave
650 point at BOB."
663 prev-value)))
676 "Helper function for `js--re-search-forward'."
678 str-terminator
707 "Search forward, ignoring strings, cpp macros, and comments.
708 This function invokes `re-search-forward', but treats the buffer
709 as if strings, cpp macros, and comments have been removed.
711 If invoked while inside a macro, it treats the contents of the
712 macro as normal text."
729 "Auxiliary function for `js--re-search-backward'."
731 str-terminator
762 "Search backward, ignoring strings, preprocessor macros, and comments.
764 This function invokes `re-search-backward' but treats the buffer
765 as if strings, preprocessor macros, and comments have been
766 removed.
768 If invoked while inside a macro, treat the macro as normal text."
772 "Move forward over a whole JavaScript expression.
773 This function doesn't move over expressions continued across
774 lines."
776 ;; non-continued case; simplistic, but good enough?
789 "Move forward over a JavaScript function declaration.
790 This puts point at the 'function' keyword.
792 If this is a syntactically-correct non-expression function,
793 return the name of the function, or t if the name could not be
794 determined. Otherwise, return nil."
810 name)))))
813 "Return the start of the JavaScript function prologue containing POS.
814 A function prologue is everything from start of the definition up
815 to and including the opening brace. POS defaults to point.
816 If POS is not in a function prologue, return nil."
843 "Helper function for `js-beginning-of-defun'.
844 Go to previous defun-beginning and return the parse state for it,
845 or nil if we went all the way back to bob and don't find
846 anything."
854 "Helper function for `js--beginning-of-defun-nested'.
855 If PSTATE represents a non-empty top-level defun, return the
856 top-most pitem. Otherwise, return nil."
859 with func-pitem
866 "Helper function for `js--beginning-of-defun'.
867 Return the pitem of the function we went to the beginning of."
869 ;; Look for the smallest function that encloses point...
874 and return pitem)
876 ;; ...and if that isn't found, look for the previous top-level
877 ;; defun
879 while pstate
882 and return it)))
885 "Helper function for `js-beginning-of-defun'."
891 "Value of `beginning-of-defun-function' for `js-mode'."
907 ;; If we're just past the end of a function, the user probably wants
908 ;; to go to the beginning of *that* function
922 "Flush the `js-mode' syntax cache after position BEG.
923 BEG defaults to `point-min', meaning to flush the entire cache."
929 ;; `(message ,@arguments)
930 )
939 ;; open-items must contain at least two items for this to
940 ;; work, but because we push a dummy item to start with,
941 ;; that assumption holds.
944 open-items)
947 "Helper function for `js--ensure-cache'.
948 Update parsing information up to point, referring to parse,
949 prev-parse-point, goal-point, and open-items bound lexically in
950 the body of `js--ensure-cache'."
957 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
958 ;; the given depth -- i.e., make sure we're deeper than the target
959 ;; depth.
963 prev-parse-point goal-point
965 nil parse))
967 ;; (let ((overlay (make-overlay prev-parse-point (point))))
968 ;; (overlay-put overlay 'face '(:background "red"))
969 ;; (unwind-protect
970 ;; (progn
971 ;; (js--debug "parsed: %S" parse)
972 ;; (sit-for 1))
973 ;; (delete-overlay overlay)))
989 "Split a JavaScript name into its dot-separated parts.
990 This also removes any prototype parts from the split name
1002 "Guess the name of the JavaScript function at POSITION.
1004 Return the name of the function, or nil if the name could not be
1005 guessed.
1007 This function clobbers match data. If we find the preamble
1008 begins earlier than expected while guessing the function name,
1009 set `js--guess-function-name-start' to that position; otherwise,
1010 set that variable to nil."
1027 ;; Clear any endings that occur after point
1034 ;; Remove any cache properties after this point
1039 "Ensures brace cache is valid up to the character before LIMIT.
1040 LIMIT defaults to point."
1046 parse
1047 prev-parse-point
1048 name
1049 case-fold-search
1050 filtered-class-styles
1051 goal-point)
1053 ;; Figure out which class styles we need to look for
1057 js-enabled-frameworks)
1058 collect style))
1064 ;; Find last known good position
1080 ;; Make a placeholder for the top-level definition
1096 ;; Each of these conditions should return non-nil if
1097 ;; we should add a new item and leave point at the end
1098 ;; of the new item's header (h-end in the
1099 ;; js--pitem diagram). This point is the one
1100 ;; after the last character we need to unambiguously
1101 ;; detect this construct. If one of these evaluates to
1102 ;; nil, the location of the point is ignored.
1104 ;; In comment or string
1107 ;; Regular function declaration
1116 js--guess-function-name-start))
1123 :paren-depth orig-depth
1124 :h-begin orig-match-start
1127 name
1130 ;; Macro
1133 ;; Macros often contain unbalanced parentheses.
1134 ;; Make sure that h-end is at the textual end of
1135 ;; the macro no matter what the parenthesis say.
1141 :h-begin orig-match-start
1145 ;; "Prototype function" declaration
1152 :paren-depth orig-depth
1153 :h-begin orig-match-start
1159 ;; Class definition
1161 with syntactic-context =
1163 for class-style in filtered-class-styles
1169 and return
1171 :paren-depth orig-depth
1172 :h-begin orig-match-start
1173 :type class-style
1188 )))))
1191 "Helper function for `js-end-of-defun'."
1196 return t
1200 "Helper function for `js-end-of-defun'."
1209 found)
1212 ;; We're already inside a function; just go to its end.
1215 ;; Otherwise, go to the end of the next function...
1222 ;; ... or eob.
1226 "Value of `end-of-defun-function' for `js-mode'."
1237 ;; look for function backward. if we're inside it, go to that
1238 ;; function's end. otherwise, search for the next function's end and
1239 ;; go there
1243 ;; if we're doing nested functions, see whether we're in the
1244 ;; prologue. If we are, go to the end of the function; otherwise,
1245 ;; call js--end-of-defun-nested to do the real work
1266 t
1268 nil))))
1271 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1282 pos
1286 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1296 pos
1299 ;; Like (up-list -1), but only considers lists that end nearby"
1302 ;; Look at a very small region so our computation time doesn't
1303 ;; explode in pathological cases.
1308 "Return non-nil if point is in a function parameter list."
1319 "Return non-nil if point is in a Dojo multiple-inheritance class block."
1341 ;;; Font Lock
1343 "Helper function for building `js--font-lock-keywords'.
1344 Create a byte-compiled function for matching a concatenation of
1345 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1356 "Move forward over a JavaScript destructuring spec.
1357 If FUNC is supplied, call it with no arguments before every
1358 variable name in the spec. Return true if this was actually a
1359 spec. FUNC must preserve the match data."
1371 t)
1376 t))))
1379 t))
1393 t))
1398 t)))))
1401 t))))
1404 "Font-lock matcher for variable names in a variable declaration.
1405 This is a cc-mode-style matcher that *always* fails, from the
1406 point of view of font-lock. It applies highlighting directly with
1407 `font-lock-apply-highlight'."
1419 t))
1441 ;; Conditions to handle
1445 ;; Matcher always "fails"
1446 nil)
1449 `(
1450 ;; This goes before keywords-2 so it gets used preferentially
1451 ;; instead of the keywords in keywords-2. Don't use override
1452 ;; because that will override syntactic fontification too, which
1453 ;; will fontify commented-out directives as if they weren't
1454 ;; commented out.
1457 ,@js--font-lock-keywords-2
1462 ;; Highlights class being declared, in parts
1466 nil
1469 ;; Highlights parent class, in parts, if available
1486 ;; Highlights parent class
1490 ;; Dojo needs its own matcher to override the string highlighting
1492 'dojo
1499 ;; Match Dojo base classes. Of course Mojo has to be different
1500 ;; from everything else under the sun...
1502 'dojo
1511 ;; continued Dojo base-class list
1513 'dojo
1524 ;; variable declarations
1529 ;; class instantiation
1534 ;; instanceof
1539 ;; formal parameters
1543 js--name-start-re)
1549 ;; continued formal parameter list
1563 "Return whether point is inside the given pitem's header or body."
1573 "Parse the JavaScript program state at point.
1574 Return a list of `js--pitem' instances that apply to point, most
1575 specific first. In the worst case, the current toplevel instance
1576 will be returned."
1585 ;; Loop until we either hit a pitem at BOB or pitem ends after
1586 ;; point (or at point if we're at eob)
1593 pstate))))
1596 "Return the JavaScript syntactic context corresponding to PSTATE."
1599 type)
1605 "Return the JavaScript syntactic context at point.
1606 When called interactively, also display a message with that
1607 context."
1615 syntactic-context))
1618 "Font lock function used by `js-mode'.
1619 This performs fontification according to `js--class-styles'."
1627 js-enabled-frameworks)
1630 decl-re
1633 and return t)
1634 return t
1639 js--font-lock-keywords-2
1640 js--font-lock-keywords-3)
1648 st))
1653 ;; A /.../ regexp.
1658 js--syntax-propertize-regexp-syntax-table
1661 ;; A / within a character class is not the end of a regexp.
1662 t
1665 nil))))))
1668 ;; Javascript allows immediate regular expression objects, written /.../.
1673 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1674 ;; FIXME: Allow regexps after infix ops like + ...
1675 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1676 ;; We can probably just add +, -, !, <, >, %, ^, ~, |, &, ?, : at which
1677 ;; point I think only * and / would be missing which could also be added,
1678 ;; but need care to avoid affecting the // and */ comment markers.
1683 ;; If the / is at the beginning of line, we have to check
1684 ;; the end of the previous text.
1695 ;;; Indentation
1713 "Return non-nil if point is on a JavaScript operator, other than a comma."
1723 "Return non-nil if the current line continues an expression."
1740 Otherwise, return nil. A braceless do-while statement spanning
1741 several lines requires that the start of the loop is indented to
1742 the same column as the current line."
1764 "Helper function for `js--proper-indentation'.
1765 Return the proper indentation of the current line if it starts
1766 the body of a control statement without braces; otherwise, return
1767 nil."
1795 "Helper function for `js--proper-indentation'.
1796 Return the proper indentation of the current line if it belongs to a declaration
1797 statement spanning multiple lines; otherwise, return nil."
1825 "Return non-nil if we think we're in an array comprehension.
1826 In particular, return the buffer position of the first `for' kwd."
1840 ;; To skip arbitrary expressions we need the parser,
1841 ;; so we'll just guess at it.
1844 ;; Not inside comment or string literal.
1850 ;; First continuation line.
1861 "Return the proper indentation for the current line."
1869 ;; Indent array comprehension continuation lines specially.
1871 beg)
1875 ;; At or after the first loop?
1881 ;; A single closing paren/bracket should be indented at the
1882 ;; same level as the opening statement. Same goes for
1883 ;; "case" and "default".
1897 in-switch-p)))
1903 js-expr-indent-offset))
1912 indent)))
1913 ;; If there is something following the opening
1914 ;; paren/bracket, everything else should be indented at
1915 ;; the same level.
1926 "Indent the current line as JavaScript."
1934 ;;; Filling
1938 ;; FIXME: Such redefinitions are bad style. We should try and use some other
1939 ;; way to get the same result.
1943 ad-do-it))
1948 ad-do-it))
1953 ad-do-it))
1956 "Fill the paragraph with `c-fill-paragraph'."
1962 ;;; Type database and Imenu
1964 ;; We maintain a cache of semantic information, i.e., the classes and
1965 ;; functions we've encountered so far. In order to avoid having to
1966 ;; re-parse the buffer on every change, we cache the parse state at
1967 ;; each interesting point in the buffer. Each parse state is a
1968 ;; modified copy of the previous one, or in the case of the first
1969 ;; parse state, the empty state.
1970 ;;
1971 ;; The parse state itself is just a stack of js--pitem
1972 ;; instances. It starts off containing one element that is never
1973 ;; closed, that is initially js--initial-pitem.
1974 ;;
1982 name
1984 type
1988 "Helper function for `js--splice-into-items'.
1989 Return a new item that is the result of merging CHILD into
1990 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1991 that we haven't consumed yet."
1996 ;; If the item we're merging into isn't a class, make it into one
2002 ;; Use the child's class-style if it's available
2004 js--dummy-class-style
2009 ;; Now we can merge either a function or a class into a class
2013 ;; if we have more name-parts to go before we get to the
2014 ;; bottom of the class hierarchy, call the merger
2015 ;; recursively
2021 ;; Not merging a class, but something else, so just prepend
2022 ;; it
2026 ;; Otherwise, merge the new child's items into those
2027 ;; of the new class
2033 "Last part of the name of PITEM, as a string or symbol."
2037 name)))
2040 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
2041 If a class doesn't exist in the tree, create it. Return
2042 the new items list. NAME-PARTS is a list of strings given
2043 the broken-down class name of the item to insert."
2047 new-items last-new-item new-cons)
2050 name-parts
2056 ;; If top-name isn't found in items, then we build a copy of items
2057 ;; and throw it away. But that's okay, since most of the time, we
2058 ;; *will* find an instance.
2062 ;; Okay, we found an entry with the right name. Splice
2063 ;; the merged item into the list...
2066 name-parts)
2073 ;; ...and terminate the loop
2074 nil)
2077 ;; Otherwise, copy the current cons and move onto the
2078 ;; text. This is tricky; we keep track of the tail of
2079 ;; the list that begins with new-items in
2080 ;; last-new-item.
2087 ;; Go to the next cell in items
2091 ;; Yay! We stopped because we found something, not because
2092 ;; we ran out of items to search. Just return the new
2093 ;; list.
2096 new-items)
2098 ;; We didn't find anything. If the child is a class and we don't
2099 ;; have any classes to drill down into, just push that class;
2100 ;; otherwise, make a fake class and carry on.
2103 ;; We have name-parts left to process. Make a fake
2104 ;; class for this particular part...
2106 ;; ...and recursively digest the rest of the name
2109 :type js--dummy-class-style
2112 ;; Otherwise, this is the only name we have, so stick
2113 ;; the item on the front of the list
2114 child)
2115 items))))
2118 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2123 t))
2125 ;; This trick works because we know (based on our defstructs) that
2126 ;; the child list is always the first element, and so the second
2127 ;; element and beyond can be shared when we make our "copy".
2134 ;; Use slow path because we need class lookup
2140 ;; Use slow path because we need class merging. We know
2141 ;; name is a list here because down in
2142 ;; `js--ensure-cache', we made sure to only add
2143 ;; class entries with lists for :name
2148 ;; Fast path
2154 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2157 location))
2160 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2177 imenu-items))
2182 unknown-ctr))
2185 imenu-items))
2194 imenu-items))))
2198 imenu-items))
2201 "Return an imenu index for the current buffer."
2213 ;; Make sure everything is closed
2221 ;; Convert the new-finalized state into what imenu expects
2224 unknown-ctr))))))
2226 ;; Silence the compiler.
2237 symbols)
2238 else
2249 "Return a hash table of all JavaScript symbols.
2250 This searches all existing `js-mode' buffers. Each key is the
2251 name of a symbol (possibly disambiguated with <N>, where N > 1),
2252 and each value is a marker giving the location of that symbol."
2254 with imenu-use-markers = t
2255 for buffer being the buffers
2260 finally return symbols))
2266 "Helper function for `js-find-symbol'.
2267 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2268 one from `js--get-all-known-symbols', using prompt PROMPT and
2269 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2270 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2271 marker."
2277 prompt
2279 collect key)
2295 ;; etags loads ring.
2299 "Read a JavaScript symbol and jump to it.
2300 With a prefix argument, restrict symbols to those from the
2301 current buffer. Pushes a mark onto the tag ring just like
2302 `find-tag'."
2313 symbols "Jump to: "
2321 ;;; MozRepl integration
2328 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2329 On timeout, return nil. On success, return t with match data
2330 set. If START is non-nil, look for output starting from START.
2331 Otherwise, use the current value of `process-mark'."
2343 'js-moz-bad-rpc
2347 ;; Integer, mirrors the value we see in JS
2350 ;; Process to which this thing belongs
2371 ; */" Make Emacs happy
2372 "(function(repl) {
2373 repl.defineInteractor('js', {
2374 onStart: function onStart(repl) {
2375 if(!repl._jsObjects) {
2376 repl._jsObjects = {};
2377 repl._jsLastID = 0;
2378 repl._jsGC = this._jsGC;
2379 }
2380 this._input = '';
2381 },
2383 _jsGC: function _jsGC(ids_in_use) {
2384 var objects = this._jsObjects;
2385 var keys = [];
2386 var num_freed = 0;
2388 for(var pn in objects) {
2389 keys.push(Number(pn));
2390 }
2392 keys.sort(function(x, y) x - y);
2393 ids_in_use.sort(function(x, y) x - y);
2394 var i = 0;
2395 var j = 0;
2397 while(i < ids_in_use.length && j < keys.length) {
2398 var id = ids_in_use[i++];
2399 while(j < keys.length && keys[j] !== id) {
2400 var k_id = keys[j++];
2401 delete objects[k_id];
2402 ++num_freed;
2403 }
2404 ++j;
2405 }
2407 while(j < keys.length) {
2408 var k_id = keys[j++];
2409 delete objects[k_id];
2410 ++num_freed;
2411 }
2413 return num_freed;
2414 },
2416 _mkArray: function _mkArray() {
2417 var result = [];
2418 for(var i = 0; i < arguments.length; ++i) {
2419 result.push(arguments[i]);
2420 }
2421 return result;
2422 },
2424 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2425 if(typeof parts === 'string') {
2426 parts = [ parts ];
2427 }
2429 var obj = parts[0];
2430 var start = 1;
2432 if(typeof obj === 'string') {
2433 obj = window;
2434 start = 0;
2435 } else if(parts.length < 2) {
2436 throw new Error('expected at least 2 arguments');
2437 }
2439 for(var i = start; i < parts.length - 1; ++i) {
2440 obj = obj[parts[i]];
2441 }
2443 return [obj, parts[parts.length - 1]];
2444 },
2446 _getProp: function _getProp(/*...*/) {
2447 if(arguments.length === 0) {
2448 throw new Error('no arguments supplied to getprop');
2449 }
2451 if(arguments.length === 1 &&
2452 (typeof arguments[0]) !== 'string')
2453 {
2454 return arguments[0];
2455 }
2457 var [obj, propname] = this._parsePropDescriptor(arguments);
2458 return obj[propname];
2459 },
2461 _putProp: function _putProp(properties, value) {
2462 var [obj, propname] = this._parsePropDescriptor(properties);
2463 obj[propname] = value;
2464 },
2466 _delProp: function _delProp(propname) {
2467 var [obj, propname] = this._parsePropDescriptor(arguments);
2468 delete obj[propname];
2469 },
2471 _typeOf: function _typeOf(thing) {
2472 return typeof thing;
2473 },
2475 _callNew: function(constructor) {
2476 if(typeof constructor === 'string')
2477 {
2478 constructor = window[constructor];
2479 } else if(constructor.length === 1 &&
2480 typeof constructor[0] !== 'string')
2481 {
2482 constructor = constructor[0];
2483 } else {
2484 var [obj,propname] = this._parsePropDescriptor(constructor);
2485 constructor = obj[propname];
2486 }
2488 /* Hacky, but should be robust */
2489 var s = 'new constructor(';
2490 for(var i = 1; i < arguments.length; ++i) {
2491 if(i != 1) {
2492 s += ',';
2493 }
2495 s += 'arguments[' + i + ']';
2496 }
2498 s += ')';
2499 return eval(s);
2500 },
2502 _callEval: function(thisobj, js) {
2503 return eval.call(thisobj, js);
2504 },
2506 getPrompt: function getPrompt(repl) {
2507 return 'EVAL>'
2508 },
2510 _lookupObject: function _lookupObject(repl, id) {
2511 if(typeof id === 'string') {
2512 switch(id) {
2513 case 'global':
2514 return window;
2515 case 'nil':
2516 return null;
2517 case 't':
2518 return true;
2519 case 'false':
2520 return false;
2521 case 'undefined':
2522 return undefined;
2523 case 'repl':
2524 return repl;
2525 case 'interactor':
2526 return this;
2527 case 'NaN':
2528 return NaN;
2529 case 'Infinity':
2530 return Infinity;
2531 case '-Infinity':
2532 return -Infinity;
2533 default:
2534 throw new Error('No object with special id:' + id);
2535 }
2536 }
2538 var ret = repl._jsObjects[id];
2539 if(ret === undefined) {
2540 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2541 }
2542 return ret;
2543 },
2545 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2546 if(typeof value !== 'object' && typeof value !== 'function') {
2547 throw new Error('_findOrAllocateObject called on non-object('
2548 + typeof(value) + '): '
2549 + value)
2550 }
2552 for(var id in repl._jsObjects) {
2553 id = Number(id);
2554 var obj = repl._jsObjects[id];
2555 if(obj === value) {
2556 return id;
2557 }
2558 }
2560 var id = ++repl._jsLastID;
2561 repl._jsObjects[id] = value;
2562 return id;
2563 },
2565 _fixupList: function _fixupList(repl, list) {
2566 for(var i = 0; i < list.length; ++i) {
2567 if(list[i] instanceof Array) {
2568 this._fixupList(repl, list[i]);
2569 } else if(typeof list[i] === 'object') {
2570 var obj = list[i];
2571 if(obj.funcall) {
2572 var parts = obj.funcall;
2573 this._fixupList(repl, parts);
2574 var [thisobj, func] = this._parseFunc(parts[0]);
2575 list[i] = func.apply(thisobj, parts.slice(1));
2576 } else if(obj.objid) {
2577 list[i] = this._lookupObject(repl, obj.objid);
2578 } else {
2579 throw new Error('Unknown object type: ' + obj.toSource());
2580 }
2581 }
2582 }
2583 },
2585 _parseFunc: function(func) {
2586 var thisobj = null;
2588 if(typeof func === 'string') {
2589 func = window[func];
2590 } else if(func instanceof Array) {
2591 if(func.length === 1 && typeof func[0] !== 'string') {
2592 func = func[0];
2593 } else {
2594 [thisobj, func] = this._parsePropDescriptor(func);
2595 func = thisobj[func];
2596 }
2597 }
2599 return [thisobj,func];
2600 },
2602 _encodeReturn: function(value, array_as_mv) {
2603 var ret;
2605 if(value === null) {
2606 ret = ['special', 'null'];
2607 } else if(value === true) {
2608 ret = ['special', 'true'];
2609 } else if(value === false) {
2610 ret = ['special', 'false'];
2611 } else if(value === undefined) {
2612 ret = ['special', 'undefined'];
2613 } else if(typeof value === 'number') {
2614 if(isNaN(value)) {
2615 ret = ['special', 'NaN'];
2616 } else if(value === Infinity) {
2617 ret = ['special', 'Infinity'];
2618 } else if(value === -Infinity) {
2619 ret = ['special', '-Infinity'];
2620 } else {
2621 ret = ['atom', value];
2622 }
2623 } else if(typeof value === 'string') {
2624 ret = ['atom', value];
2625 } else if(array_as_mv && value instanceof Array) {
2626 ret = ['array', value.map(this._encodeReturn, this)];
2627 } else {
2628 ret = ['objid', this._findOrAllocateObject(repl, value)];
2629 }
2631 return ret;
2632 },
2634 _handleInputLine: function _handleInputLine(repl, line) {
2635 var ret;
2636 var array_as_mv = false;
2638 try {
2639 if(line[0] === '*') {
2640 array_as_mv = true;
2641 line = line.substring(1);
2642 }
2643 var parts = eval(line);
2644 this._fixupList(repl, parts);
2645 var [thisobj, func] = this._parseFunc(parts[0]);
2646 ret = this._encodeReturn(
2647 func.apply(thisobj, parts.slice(1)),
2648 array_as_mv);
2649 } catch(x) {
2650 ret = ['error', x.toString() ];
2651 }
2653 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2654 repl.print(JSON.encode(ret));
2655 repl._prompt();
2656 },
2658 handleInput: function handleInput(repl, chunk) {
2659 this._input += chunk;
2660 var match, line;
2662 line = match[0];
2665 repl.popInteractor();
2666 repl._prompt();
2667 return;
2668 }
2670 this._input = this._input.substring(line.length);
2671 this._handleInputLine(repl, line);
2672 }
2673 }
2674 });
2675 })
2681 "Marshall the given value for JS.
2682 Strings and numbers are JSON-encoded. Lists (including nil) are
2683 made into JavaScript array literals and their contents encoded
2684 with `js--js-encode-value'."
2711 js--js-repl-prompt-regexp js-js-timeout
2713 ;; start matching against the beginning of the line in
2714 ;; order to catch a prompt that's only partially arrived
2717 ;; Presumably "inferior-moz-process" loads comint.
2727 ;; Do some initialization the first time we see a process
2733 ;; Send interactor definition
2739 js-js-timeout))
2741 ;; Sanity check
2747 ;; If js--js-repl-depth > 0, we *should* be seeing an
2748 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2749 ;; up with us.
2752 ;; Otherwise, tell Mozilla to enter the interactor mode
2758 js-js-timeout))
2772 js-js-timeout))))
2780 ;; The somewhat complex code layout confuses the byte-compiler into
2781 ;; thinking this function "might not be defined at runtime".
2786 "Convert immediate js< and js! references to deferred ones."
2810 function))
2812 else
2813 collect item)))
2828 "Run FORMS with the Mozilla repl set up for js commands.
2829 Inside the lexical scope of `with-js', `js?', `js!',
2830 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2831 `js-create-instance', and `js-qi' are defined."
2842 function)
2850 function)
2882 props)
2884 ))
2890 "Whether to listify any Array returned by a Mozilla function.
2897 (`array
2899 (`objid
2901 js--js-references)
2906 js--js-references)))
2914 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2915 If function is a string, look it up as a property on the global
2916 object and use the global object for `this'.
2917 If FUNCTION is a list with one element, use that element as the
2918 function with the global object for `this', except that if that
2919 single element is a string, look it up on the global object.
2920 If FUNCTION is a list with more than one argument, use the list
2921 up to the last value as a property descriptor and the last
2922 argument as a function."
2929 ;; Actual funcall
2936 js-js-timeout)
2939 ;; Read the result
2946 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2947 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2950 constructor arguments))
2956 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2959 arguments)))
2968 "Tell the repl about any objects we don't reference anymore.
2969 With argument, run even if no intervening GC has happened."
2980 ;; Don't bother running unless we've had an intervening
2981 ;; garbage collection; without a gc, nothing is deleted
2982 ;; from the weak hash table, so it's pointless telling
2983 ;; MozRepl about that references we still hold
2986 ;; Are we looking at a normal prompt? Make sure not to
2987 ;; interrupt the user if he's doing something
2995 of js--js-references
2996 collect x))
3003 num)))
3008 "Evaluate the JavaScript in JS and return JSON-decoded result."
3016 result)))
3019 "Enumerate all JavaScript contexts available.
3020 Each context is a list:
3021 (TITLE URL BROWSER TAB TABBROWSER) for content documents
3022 (TITLE URL WINDOW) for windows
3024 All tabs of a given window are grouped together. The most recent
3025 window is first. Within each window, the tabs are returned
3026 left-to-right."
3031 "@mozilla.org/appshell/window-mediator;1"
3053 window)
3060 "browsers"
3061 x
3062 "contentDocument"
3066 "browsers"
3067 x
3068 "contentWindow"
3069 "location"
3072 "browsers"
3073 x)
3076 "tabContainer"
3077 "childNodes"
3079 x)
3081 gbrowser))))))
3088 "Read a Mozilla tab with prompt PROMPT.
3089 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
3090 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
3091 browser, respectively."
3093 ;; Prime IDO
3100 selected-tab prev-hitab)
3102 ;; Disambiguate names
3105 for tab in tabs
3123 ;; Hack to reduce the number of
3124 ;; round-trips to mozilla
3127 ;; Highlighting tab
3130 "style"
3132 cmds)
3134 ;; Highlight window proper
3137 "style"
3139 cmds)
3141 ;; Select tab, when appropriate
3145 cmds)))
3147 ;; Highlighting whole window
3151 "style"
3154 cmds)))
3157 ;; Unhighlighting tab
3160 cmds)
3162 cmds))
3164 ;; Unhighlighting window
3169 cmds)))
3175 ()
3181 ()
3182 ;; Fiddle with the match list a bit: if our first match
3183 ;; is a tabbrowser window, rotate the match list until
3184 ;; the active tab comes up
3190 "document"
3191 "documentElement"
3196 "gBrowser"
3199 for match in ido-matches
3204 and return t)))
3214 prompt
3216 nil t nil
3233 "Helper function for `js-eval-defun'.
3234 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3235 strings making up the class name and NAME is the name of the
3236 function part."
3255 "The current JavaScript context.
3256 This is a cons like the one returned from `js--read-tab'.
3260 "(function(func_info,func) {
3261 func_info.unshift('window');
3262 var obj = window;
3263 for(var i = 1; i < func_info.length - 1; ++i) {
3264 var next = obj[func_info[i]];
3265 if(typeof next !== 'object' && typeof next !== 'function') {
3266 next = obj.prototype && obj.prototype[func_info[i]];
3267 if(typeof next !== 'object' && typeof next !== 'function') {
3268 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3269 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3270 return;
3271 }
3273 func_info.splice(i+1, 0, 'prototype');
3274 ++i;
3275 }
3276 }
3278 obj[func_info[i]] = func;
3279 alert('Successfully updated '+func_info.join('.'));
3283 "Set the JavaScript context to CONTEXT.
3284 When called interactively, prompt for CONTEXT."
3289 "Return a valid JavaScript context.
3290 If one hasn't been set, or if it's stale, prompt for a new one."
3300 js--js-context))
3315 file)))
3328 "Update a Mozilla tab using the JavaScript defun at point."
3331 ;; This function works by generating a temporary file that contains
3332 ;; the function we'd like to insert. We then use the elisp-js bridge
3333 ;; to command mozilla to load this file by inserting a script tag
3334 ;; into the document we set. This way, debuggers and such will have
3335 ;; a way to find the source of the just-inserted function.
3336 ;;
3337 ;; We delete the temporary file if there's an error, but otherwise
3338 ;; we add an unload event listener on the Mozilla side to delete the
3339 ;; file.
3370 ;; (Re)register a Mozilla resource URL to point to the
3371 ;; temporary directory
3389 ;; Give Mozilla responsibility for deleting this file
3394 ;; Regular content
3398 ;; Chrome
3420 ))
3422 ;; temp-name is set to nil on success
3426 ;;; Main Function
3428 ;;;###autoload
3430 "Major mode for editing JavaScript."
3443 ;; Comments
3448 ;; Parse cache
3451 ;; Frameworks
3454 ;; Imenu
3458 ;; for filling, pretend we're cc-mode
3460 c-paragraph-start "$"
3461 c-paragraph-separate "$"
3462 c-block-comment-prefix "* "
3463 c-line-comment-starter "//"
3473 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3474 ;; we call it instead? (Bug#6071)
3484 ;; Important to fontify the whole buffer syntactically! If we don't,
3485 ;; then we might have regular expression literals that aren't marked
3486 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3487 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3488 ;; When we attempt to find the error and scroll to the portion of
3489 ;; the buffer containing the problem, JIT-lock will apply the
3490 ;; correct syntax to the regular expression literal and the problem
3491 ;; will mysteriously disappear.
3492 ;; FIXME: We should actually do this fontification lazily by adding
3493 ;; calls to syntax-propertize wherever it's really needed.
3496 ;;;###autoload (defalias 'javascript-mode 'js-mode)
3502 ;;;###autoload
3508 ;; js.el ends here