| blob | e6bba6a66090598ee60003087ba7640e8f25a1e1 |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2012 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 "Whether to automatically indent when typing punctuation characters.
465 If non-nil, the characters {}();,: also indent the current line
466 in Javascript mode."
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."
807 name)))))
810 "Return the start of the JavaScript function prologue containing POS.
811 A function prologue is everything from start of the definition up
812 to and including the opening brace. POS defaults to point.
813 If POS is not in a function prologue, return nil."
840 "Helper function for `js-beginning-of-defun'.
841 Go to previous defun-beginning and return the parse state for it,
842 or nil if we went all the way back to bob and don't find
843 anything."
851 "Helper function for `js--beginning-of-defun-nested'.
852 If PSTATE represents a non-empty top-level defun, return the
853 top-most pitem. Otherwise, return nil."
856 with func-pitem
863 "Helper function for `js--beginning-of-defun'.
864 Return the pitem of the function we went to the beginning of."
866 ;; Look for the smallest function that encloses point...
871 and return pitem)
873 ;; ...and if that isn't found, look for the previous top-level
874 ;; defun
876 while pstate
879 and return it)))
882 "Helper function for `js-beginning-of-defun'."
888 "Value of `beginning-of-defun-function' for `js-mode'."
904 ;; If we're just past the end of a function, the user probably wants
905 ;; to go to the beginning of *that* function
919 "Flush the `js-mode' syntax cache after position BEG.
920 BEG defaults to `point-min', meaning to flush the entire cache."
926 ;; `(message ,@arguments)
927 )
936 ;; open-items must contain at least two items for this to
937 ;; work, but because we push a dummy item to start with,
938 ;; that assumption holds.
941 open-items)
944 "Helper function for `js--ensure-cache'.
945 Update parsing information up to point, referring to parse,
946 prev-parse-point, goal-point, and open-items bound lexically in
947 the body of `js--ensure-cache'."
954 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
955 ;; the given depth -- i.e., make sure we're deeper than the target
956 ;; depth.
960 prev-parse-point goal-point
962 nil parse))
964 ;; (let ((overlay (make-overlay prev-parse-point (point))))
965 ;; (overlay-put overlay 'face '(:background "red"))
966 ;; (unwind-protect
967 ;; (progn
968 ;; (js--debug "parsed: %S" parse)
969 ;; (sit-for 1))
970 ;; (delete-overlay overlay)))
986 "Split a JavaScript name into its dot-separated parts.
987 This also removes any prototype parts from the split name
999 "Guess the name of the JavaScript function at POSITION.
1001 Return the name of the function, or nil if the name could not be
1002 guessed.
1004 This function clobbers match data. If we find the preamble
1005 begins earlier than expected while guessing the function name,
1006 set `js--guess-function-name-start' to that position; otherwise,
1007 set that variable to nil."
1024 ;; Clear any endings that occur after point
1031 ;; Remove any cache properties after this point
1036 "Ensures brace cache is valid up to the character before LIMIT.
1037 LIMIT defaults to point."
1043 parse
1044 prev-parse-point
1045 name
1046 case-fold-search
1047 filtered-class-styles
1048 goal-point)
1050 ;; Figure out which class styles we need to look for
1054 js-enabled-frameworks)
1055 collect style))
1061 ;; Find last known good position
1077 ;; Make a placeholder for the top-level definition
1093 ;; Each of these conditions should return non-nil if
1094 ;; we should add a new item and leave point at the end
1095 ;; of the new item's header (h-end in the
1096 ;; js--pitem diagram). This point is the one
1097 ;; after the last character we need to unambiguously
1098 ;; detect this construct. If one of these evaluates to
1099 ;; nil, the location of the point is ignored.
1101 ;; In comment or string
1104 ;; Regular function declaration
1113 js--guess-function-name-start))
1120 :paren-depth orig-depth
1121 :h-begin orig-match-start
1124 name
1127 ;; Macro
1130 ;; Macros often contain unbalanced parentheses.
1131 ;; Make sure that h-end is at the textual end of
1132 ;; the macro no matter what the parenthesis say.
1138 :h-begin orig-match-start
1142 ;; "Prototype function" declaration
1149 :paren-depth orig-depth
1150 :h-begin orig-match-start
1156 ;; Class definition
1158 with syntactic-context =
1160 for class-style in filtered-class-styles
1166 and return
1168 :paren-depth orig-depth
1169 :h-begin orig-match-start
1170 :type class-style
1185 )))))
1188 "Helper function for `js-end-of-defun'."
1193 return t
1197 "Helper function for `js-end-of-defun'."
1206 found)
1209 ;; We're already inside a function; just go to its end.
1212 ;; Otherwise, go to the end of the next function...
1219 ;; ... or eob.
1223 "Value of `end-of-defun-function' for `js-mode'."
1234 ;; look for function backward. if we're inside it, go to that
1235 ;; function's end. otherwise, search for the next function's end and
1236 ;; go there
1240 ;; if we're doing nested functions, see whether we're in the
1241 ;; prologue. If we are, go to the end of the function; otherwise,
1242 ;; call js--end-of-defun-nested to do the real work
1263 t
1265 nil))))
1268 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1279 pos
1283 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1293 pos
1296 ;; Like (up-list -1), but only considers lists that end nearby"
1299 ;; Look at a very small region so our computation time doesn't
1300 ;; explode in pathological cases.
1305 "Return non-nil iff point is in a function parameter list."
1316 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1338 ;;; Font Lock
1340 "Helper function for building `js--font-lock-keywords'.
1341 Create a byte-compiled function for matching a concatenation of
1342 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1353 "Move forward over a JavaScript destructuring spec.
1354 If FUNC is supplied, call it with no arguments before every
1355 variable name in the spec. Return true iff this was actually a
1356 spec. FUNC must preserve the match data."
1368 t)
1373 t))))
1376 t))
1390 t))
1395 t)))))
1398 t))))
1401 "Font-lock matcher for variable names in a variable declaration.
1402 This is a cc-mode-style matcher that *always* fails, from the
1403 point of view of font-lock. It applies highlighting directly with
1404 `font-lock-apply-highlight'."
1416 t))
1438 ;; Conditions to handle
1442 ;; Matcher always "fails"
1443 nil)
1446 `(
1447 ;; This goes before keywords-2 so it gets used preferentially
1448 ;; instead of the keywords in keywords-2. Don't use override
1449 ;; because that will override syntactic fontification too, which
1450 ;; will fontify commented-out directives as if they weren't
1451 ;; commented out.
1454 ,@js--font-lock-keywords-2
1459 ;; Highlights class being declared, in parts
1463 nil
1466 ;; Highlights parent class, in parts, if available
1483 ;; Highlights parent class
1487 ;; Dojo needs its own matcher to override the string highlighting
1489 'dojo
1496 ;; Match Dojo base classes. Of course Mojo has to be different
1497 ;; from everything else under the sun...
1499 'dojo
1508 ;; continued Dojo base-class list
1510 'dojo
1521 ;; variable declarations
1526 ;; class instantiation
1531 ;; instanceof
1536 ;; formal parameters
1540 js--name-start-re)
1546 ;; continued formal parameter list
1560 "Return whether point is inside the given pitem's header or body."
1570 "Parse the JavaScript program state at point.
1571 Return a list of `js--pitem' instances that apply to point, most
1572 specific first. In the worst case, the current toplevel instance
1573 will be returned."
1582 ;; Loop until we either hit a pitem at BOB or pitem ends after
1583 ;; point (or at point if we're at eob)
1590 pstate))))
1593 "Return the JavaScript syntactic context corresponding to PSTATE."
1596 type)
1602 "Return the JavaScript syntactic context at point.
1603 When called interactively, also display a message with that
1604 context."
1612 syntactic-context))
1615 "Font lock function used by `js-mode'.
1616 This performs fontification according to `js--class-styles'."
1624 js-enabled-frameworks)
1627 decl-re
1630 and return t)
1631 return t
1636 js--font-lock-keywords-2
1637 js--font-lock-keywords-3)
1642 ;; A /.../ regexp.
1648 ;; Javascript allows immediate regular expression objects, written /.../.
1653 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1654 ;; FIXME: Allow regexps after infix ops like + ...
1655 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1656 ;; We can probably just add +, -, !, <, >, %, ^, ~, |, &, ?, : at which
1657 ;; point I think only * and / would be missing which could also be added,
1658 ;; but need care to avoid affecting the // and */ comment markers.
1663 ;; If the / is at the beginning of line, we have to check
1664 ;; the end of the previous text.
1675 ;;; Indentation
1690 "Return non-nil if point is on a JavaScript operator, other than a comma."
1700 "Return non-nil if the current line continues an expression."
1717 Otherwise, return nil. A braceless do-while statement spanning
1718 several lines requires that the start of the loop is indented to
1719 the same column as the current line."
1741 "Helper function for `js--proper-indentation'.
1742 Return the proper indentation of the current line if it starts
1743 the body of a control statement without braces; otherwise, return
1744 nil."
1768 "Return the proper indentation for the current line."
1778 ;; A single closing paren/bracket should be indented at the
1779 ;; same level as the opening statement. Same goes for
1780 ;; "case" and "default".
1794 js-expr-indent-offset))
1801 ;; If there is something following the opening
1802 ;; paren/bracket, everything else should be indented at
1803 ;; the same level.
1814 "Indent the current line as JavaScript."
1824 ;;; Filling
1828 ;; FIXME: Such redefinitions are bad style. We should try and use some other
1829 ;; way to get the same result.
1833 ad-do-it))
1838 ad-do-it))
1843 ad-do-it))
1846 "Fill the paragraph with `c-fill-paragraph'."
1852 ;;; Type database and Imenu
1854 ;; We maintain a cache of semantic information, i.e., the classes and
1855 ;; functions we've encountered so far. In order to avoid having to
1856 ;; re-parse the buffer on every change, we cache the parse state at
1857 ;; each interesting point in the buffer. Each parse state is a
1858 ;; modified copy of the previous one, or in the case of the first
1859 ;; parse state, the empty state.
1860 ;;
1861 ;; The parse state itself is just a stack of js--pitem
1862 ;; instances. It starts off containing one element that is never
1863 ;; closed, that is initially js--initial-pitem.
1864 ;;
1872 name
1874 type
1878 "Helper function for `js--splice-into-items'.
1879 Return a new item that is the result of merging CHILD into
1880 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1881 that we haven't consumed yet."
1886 ;; If the item we're merging into isn't a class, make it into one
1892 ;; Use the child's class-style if it's available
1894 js--dummy-class-style
1899 ;; Now we can merge either a function or a class into a class
1903 ;; if we have more name-parts to go before we get to the
1904 ;; bottom of the class hierarchy, call the merger
1905 ;; recursively
1911 ;; Not merging a class, but something else, so just prepend
1912 ;; it
1916 ;; Otherwise, merge the new child's items into those
1917 ;; of the new class
1923 "Last part of the name of PITEM, as a string or symbol."
1927 name)))
1930 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1931 If a class doesn't exist in the tree, create it. Return
1932 the new items list. NAME-PARTS is a list of strings given
1933 the broken-down class name of the item to insert."
1937 new-items last-new-item new-cons)
1940 name-parts
1946 ;; If top-name isn't found in items, then we build a copy of items
1947 ;; and throw it away. But that's okay, since most of the time, we
1948 ;; *will* find an instance.
1952 ;; Okay, we found an entry with the right name. Splice
1953 ;; the merged item into the list...
1956 name-parts)
1963 ;; ...and terminate the loop
1964 nil)
1967 ;; Otherwise, copy the current cons and move onto the
1968 ;; text. This is tricky; we keep track of the tail of
1969 ;; the list that begins with new-items in
1970 ;; last-new-item.
1977 ;; Go to the next cell in items
1981 ;; Yay! We stopped because we found something, not because
1982 ;; we ran out of items to search. Just return the new
1983 ;; list.
1986 new-items)
1988 ;; We didn't find anything. If the child is a class and we don't
1989 ;; have any classes to drill down into, just push that class;
1990 ;; otherwise, make a fake class and carry on.
1993 ;; We have name-parts left to process. Make a fake
1994 ;; class for this particular part...
1996 ;; ...and recursively digest the rest of the name
1999 :type js--dummy-class-style
2002 ;; Otherwise, this is the only name we have, so stick
2003 ;; the item on the front of the list
2004 child)
2005 items))))
2008 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2013 t))
2015 ;; This trick works because we know (based on our defstructs) that
2016 ;; the child list is always the first element, and so the second
2017 ;; element and beyond can be shared when we make our "copy".
2024 ;; Use slow path because we need class lookup
2030 ;; Use slow path because we need class merging. We know
2031 ;; name is a list here because down in
2032 ;; `js--ensure-cache', we made sure to only add
2033 ;; class entries with lists for :name
2038 ;; Fast path
2044 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2047 location))
2050 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2067 imenu-items))
2072 unknown-ctr))
2075 imenu-items))
2084 imenu-items))))
2088 imenu-items))
2091 "Return an imenu index for the current buffer."
2103 ;; Make sure everything is closed
2111 ;; Convert the new-finalized state into what imenu expects
2114 unknown-ctr))))))
2116 ;; Silence the compiler.
2127 symbols)
2128 else
2139 "Return a hash table of all JavaScript symbols.
2140 This searches all existing `js-mode' buffers. Each key is the
2141 name of a symbol (possibly disambiguated with <N>, where N > 1),
2142 and each value is a marker giving the location of that symbol."
2144 with imenu-use-markers = t
2145 for buffer being the buffers
2150 finally return symbols))
2156 "Helper function for `js-find-symbol'.
2157 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2158 one from `js--get-all-known-symbols', using prompt PROMPT and
2159 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2160 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2161 marker."
2167 prompt
2169 collect key)
2186 "Read a JavaScript symbol and jump to it.
2187 With a prefix argument, restrict symbols to those from the
2188 current buffer. Pushes a mark onto the tag ring just like
2189 `find-tag'."
2200 symbols "Jump to: "
2208 ;;; MozRepl integration
2218 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2219 On timeout, return nil. On success, return t with match data
2220 set. If START is non-nil, look for output starting from START.
2221 Otherwise, use the current value of `process-mark'."
2233 'js-moz-bad-rpc
2237 ;; Integer, mirrors the value we see in JS
2240 ;; Process to which this thing belongs
2261 ; */" Make Emacs happy
2262 "(function(repl) {
2263 repl.defineInteractor('js', {
2264 onStart: function onStart(repl) {
2265 if(!repl._jsObjects) {
2266 repl._jsObjects = {};
2267 repl._jsLastID = 0;
2268 repl._jsGC = this._jsGC;
2269 }
2270 this._input = '';
2271 },
2273 _jsGC: function _jsGC(ids_in_use) {
2274 var objects = this._jsObjects;
2275 var keys = [];
2276 var num_freed = 0;
2278 for(var pn in objects) {
2279 keys.push(Number(pn));
2280 }
2282 keys.sort(function(x, y) x - y);
2283 ids_in_use.sort(function(x, y) x - y);
2284 var i = 0;
2285 var j = 0;
2287 while(i < ids_in_use.length && j < keys.length) {
2288 var id = ids_in_use[i++];
2289 while(j < keys.length && keys[j] !== id) {
2290 var k_id = keys[j++];
2291 delete objects[k_id];
2292 ++num_freed;
2293 }
2294 ++j;
2295 }
2297 while(j < keys.length) {
2298 var k_id = keys[j++];
2299 delete objects[k_id];
2300 ++num_freed;
2301 }
2303 return num_freed;
2304 },
2306 _mkArray: function _mkArray() {
2307 var result = [];
2308 for(var i = 0; i < arguments.length; ++i) {
2309 result.push(arguments[i]);
2310 }
2311 return result;
2312 },
2314 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2315 if(typeof parts === 'string') {
2316 parts = [ parts ];
2317 }
2319 var obj = parts[0];
2320 var start = 1;
2322 if(typeof obj === 'string') {
2323 obj = window;
2324 start = 0;
2325 } else if(parts.length < 2) {
2326 throw new Error('expected at least 2 arguments');
2327 }
2329 for(var i = start; i < parts.length - 1; ++i) {
2330 obj = obj[parts[i]];
2331 }
2333 return [obj, parts[parts.length - 1]];
2334 },
2336 _getProp: function _getProp(/*...*/) {
2337 if(arguments.length === 0) {
2338 throw new Error('no arguments supplied to getprop');
2339 }
2341 if(arguments.length === 1 &&
2342 (typeof arguments[0]) !== 'string')
2343 {
2344 return arguments[0];
2345 }
2347 var [obj, propname] = this._parsePropDescriptor(arguments);
2348 return obj[propname];
2349 },
2351 _putProp: function _putProp(properties, value) {
2352 var [obj, propname] = this._parsePropDescriptor(properties);
2353 obj[propname] = value;
2354 },
2356 _delProp: function _delProp(propname) {
2357 var [obj, propname] = this._parsePropDescriptor(arguments);
2358 delete obj[propname];
2359 },
2361 _typeOf: function _typeOf(thing) {
2362 return typeof thing;
2363 },
2365 _callNew: function(constructor) {
2366 if(typeof constructor === 'string')
2367 {
2368 constructor = window[constructor];
2369 } else if(constructor.length === 1 &&
2370 typeof constructor[0] !== 'string')
2371 {
2372 constructor = constructor[0];
2373 } else {
2374 var [obj,propname] = this._parsePropDescriptor(constructor);
2375 constructor = obj[propname];
2376 }
2378 /* Hacky, but should be robust */
2379 var s = 'new constructor(';
2380 for(var i = 1; i < arguments.length; ++i) {
2381 if(i != 1) {
2382 s += ',';
2383 }
2385 s += 'arguments[' + i + ']';
2386 }
2388 s += ')';
2389 return eval(s);
2390 },
2392 _callEval: function(thisobj, js) {
2393 return eval.call(thisobj, js);
2394 },
2396 getPrompt: function getPrompt(repl) {
2397 return 'EVAL>'
2398 },
2400 _lookupObject: function _lookupObject(repl, id) {
2401 if(typeof id === 'string') {
2402 switch(id) {
2403 case 'global':
2404 return window;
2405 case 'nil':
2406 return null;
2407 case 't':
2408 return true;
2409 case 'false':
2410 return false;
2411 case 'undefined':
2412 return undefined;
2413 case 'repl':
2414 return repl;
2415 case 'interactor':
2416 return this;
2417 case 'NaN':
2418 return NaN;
2419 case 'Infinity':
2420 return Infinity;
2421 case '-Infinity':
2422 return -Infinity;
2423 default:
2424 throw new Error('No object with special id:' + id);
2425 }
2426 }
2428 var ret = repl._jsObjects[id];
2429 if(ret === undefined) {
2430 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2431 }
2432 return ret;
2433 },
2435 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2436 if(typeof value !== 'object' && typeof value !== 'function') {
2437 throw new Error('_findOrAllocateObject called on non-object('
2438 + typeof(value) + '): '
2439 + value)
2440 }
2442 for(var id in repl._jsObjects) {
2443 id = Number(id);
2444 var obj = repl._jsObjects[id];
2445 if(obj === value) {
2446 return id;
2447 }
2448 }
2450 var id = ++repl._jsLastID;
2451 repl._jsObjects[id] = value;
2452 return id;
2453 },
2455 _fixupList: function _fixupList(repl, list) {
2456 for(var i = 0; i < list.length; ++i) {
2457 if(list[i] instanceof Array) {
2458 this._fixupList(repl, list[i]);
2459 } else if(typeof list[i] === 'object') {
2460 var obj = list[i];
2461 if(obj.funcall) {
2462 var parts = obj.funcall;
2463 this._fixupList(repl, parts);
2464 var [thisobj, func] = this._parseFunc(parts[0]);
2465 list[i] = func.apply(thisobj, parts.slice(1));
2466 } else if(obj.objid) {
2467 list[i] = this._lookupObject(repl, obj.objid);
2468 } else {
2469 throw new Error('Unknown object type: ' + obj.toSource());
2470 }
2471 }
2472 }
2473 },
2475 _parseFunc: function(func) {
2476 var thisobj = null;
2478 if(typeof func === 'string') {
2479 func = window[func];
2480 } else if(func instanceof Array) {
2481 if(func.length === 1 && typeof func[0] !== 'string') {
2482 func = func[0];
2483 } else {
2484 [thisobj, func] = this._parsePropDescriptor(func);
2485 func = thisobj[func];
2486 }
2487 }
2489 return [thisobj,func];
2490 },
2492 _encodeReturn: function(value, array_as_mv) {
2493 var ret;
2495 if(value === null) {
2496 ret = ['special', 'null'];
2497 } else if(value === true) {
2498 ret = ['special', 'true'];
2499 } else if(value === false) {
2500 ret = ['special', 'false'];
2501 } else if(value === undefined) {
2502 ret = ['special', 'undefined'];
2503 } else if(typeof value === 'number') {
2504 if(isNaN(value)) {
2505 ret = ['special', 'NaN'];
2506 } else if(value === Infinity) {
2507 ret = ['special', 'Infinity'];
2508 } else if(value === -Infinity) {
2509 ret = ['special', '-Infinity'];
2510 } else {
2511 ret = ['atom', value];
2512 }
2513 } else if(typeof value === 'string') {
2514 ret = ['atom', value];
2515 } else if(array_as_mv && value instanceof Array) {
2516 ret = ['array', value.map(this._encodeReturn, this)];
2517 } else {
2518 ret = ['objid', this._findOrAllocateObject(repl, value)];
2519 }
2521 return ret;
2522 },
2524 _handleInputLine: function _handleInputLine(repl, line) {
2525 var ret;
2526 var array_as_mv = false;
2528 try {
2529 if(line[0] === '*') {
2530 array_as_mv = true;
2531 line = line.substring(1);
2532 }
2533 var parts = eval(line);
2534 this._fixupList(repl, parts);
2535 var [thisobj, func] = this._parseFunc(parts[0]);
2536 ret = this._encodeReturn(
2537 func.apply(thisobj, parts.slice(1)),
2538 array_as_mv);
2539 } catch(x) {
2540 ret = ['error', x.toString() ];
2541 }
2543 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2544 repl.print(JSON.encode(ret));
2545 repl._prompt();
2546 },
2548 handleInput: function handleInput(repl, chunk) {
2549 this._input += chunk;
2550 var match, line;
2552 line = match[0];
2555 repl.popInteractor();
2556 repl._prompt();
2557 return;
2558 }
2560 this._input = this._input.substring(line.length);
2561 this._handleInputLine(repl, line);
2562 }
2563 }
2564 });
2565 })
2571 "Marshall the given value for JS.
2572 Strings and numbers are JSON-encoded. Lists (including nil) are
2573 made into JavaScript array literals and their contents encoded
2574 with `js--js-encode-value'."
2601 js--js-repl-prompt-regexp js-js-timeout
2603 ;; start matching against the beginning of the line in
2604 ;; order to catch a prompt that's only partially arrived
2612 ;; Do some initialization the first time we see a process
2618 ;; Send interactor definition
2624 js-js-timeout))
2626 ;; Sanity check
2632 ;; If js--js-repl-depth > 0, we *should* be seeing an
2633 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2634 ;; up with us.
2637 ;; Otherwise, tell Mozilla to enter the interactor mode
2643 js-js-timeout))
2657 js-js-timeout))))
2667 "Convert immediate js< and js! references to deferred ones."
2691 function))
2693 else
2694 collect item)))
2709 "Run FORMS with the Mozilla repl set up for js commands.
2710 Inside the lexical scope of `with-js', `js?', `js!',
2711 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2712 `js-create-instance', and `js-qi' are defined."
2723 function)
2731 function)
2763 props)
2765 ))
2771 "Whether to listify any Array returned by a Mozilla function.
2778 (`array
2780 (`objid
2782 js--js-references)
2787 js--js-references)))
2793 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2794 If function is a string, look it up as a property on the global
2795 object and use the global object for `this'.
2796 If FUNCTION is a list with one element, use that element as the
2797 function with the global object for `this', except that if that
2798 single element is a string, look it up on the global object.
2799 If FUNCTION is a list with more than one argument, use the list
2800 up to the last value as a property descriptor and the last
2801 argument as a function."
2808 ;; Actual funcall
2815 js-js-timeout)
2818 ;; Read the result
2825 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2826 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2829 constructor arguments))
2835 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2838 arguments)))
2847 "Tell the repl about any objects we don't reference anymore.
2848 With argument, run even if no intervening GC has happened."
2859 ;; Don't bother running unless we've had an intervening
2860 ;; garbage collection; without a gc, nothing is deleted
2861 ;; from the weak hash table, so it's pointless telling
2862 ;; MozRepl about that references we still hold
2865 ;; Are we looking at a normal prompt? Make sure not to
2866 ;; interrupt the user if he's doing something
2874 of js--js-references
2875 collect x))
2882 num)))
2887 "Evaluate the JavaScript in JS and return JSON-decoded result."
2895 result)))
2898 "Enumerate all JavaScript contexts available.
2899 Each context is a list:
2900 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2901 (TITLE URL WINDOW) for windows
2903 All tabs of a given window are grouped together. The most recent
2904 window is first. Within each window, the tabs are returned
2905 left-to-right."
2910 "@mozilla.org/appshell/window-mediator;1"
2932 window)
2939 "browsers"
2940 x
2941 "contentDocument"
2945 "browsers"
2946 x
2947 "contentWindow"
2948 "location"
2951 "browsers"
2952 x)
2955 "tabContainer"
2956 "childNodes"
2958 x)
2960 gbrowser))))))
2965 "Read a Mozilla tab with prompt PROMPT.
2966 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2967 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2968 browser, respectively."
2970 ;; Prime IDO
2977 selected-tab prev-hitab)
2979 ;; Disambiguate names
2982 for tab in tabs
3000 ;; Hack to reduce the number of
3001 ;; round-trips to mozilla
3004 ;; Highlighting tab
3007 "style"
3009 cmds)
3011 ;; Highlight window proper
3014 "style"
3016 cmds)
3018 ;; Select tab, when appropriate
3022 cmds)))
3024 ;; Highlighting whole window
3028 "style"
3031 cmds)))
3034 ;; Unhighlighting tab
3037 cmds)
3039 cmds))
3041 ;; Unhighlighting window
3046 cmds)))
3052 ()
3058 ()
3059 ;; Fiddle with the match list a bit: if our first match
3060 ;; is a tabbrowser window, rotate the match list until
3061 ;; the active tab comes up
3067 "document"
3068 "documentElement"
3073 "gBrowser"
3076 for match in ido-matches
3081 and return t)))
3091 prompt
3093 nil t nil
3110 "Helper function for `js-eval-defun'.
3111 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3112 strings making up the class name and NAME is the name of the
3113 function part."
3132 "The current JavaScript context.
3133 This is a cons like the one returned from `js--read-tab'.
3137 "(function(func_info,func) {
3138 func_info.unshift('window');
3139 var obj = window;
3140 for(var i = 1; i < func_info.length - 1; ++i) {
3141 var next = obj[func_info[i]];
3142 if(typeof next !== 'object' && typeof next !== 'function') {
3143 next = obj.prototype && obj.prototype[func_info[i]];
3144 if(typeof next !== 'object' && typeof next !== 'function') {
3145 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3146 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3147 return;
3148 }
3150 func_info.splice(i+1, 0, 'prototype');
3151 ++i;
3152 }
3153 }
3155 obj[func_info[i]] = func;
3156 alert('Successfully updated '+func_info.join('.'));
3160 "Set the JavaScript context to CONTEXT.
3161 When called interactively, prompt for CONTEXT."
3166 "Return a valid JavaScript context.
3167 If one hasn't been set, or if it's stale, prompt for a new one."
3177 js--js-context))
3192 file)))
3205 "Update a Mozilla tab using the JavaScript defun at point."
3208 ;; This function works by generating a temporary file that contains
3209 ;; the function we'd like to insert. We then use the elisp-js bridge
3210 ;; to command mozilla to load this file by inserting a script tag
3211 ;; into the document we set. This way, debuggers and such will have
3212 ;; a way to find the source of the just-inserted function.
3213 ;;
3214 ;; We delete the temporary file if there's an error, but otherwise
3215 ;; we add an unload event listener on the Mozilla side to delete the
3216 ;; file.
3247 ;; (Re)register a Mozilla resource URL to point to the
3248 ;; temporary directory
3266 ;; Give Mozilla responsibility for deleting this file
3271 ;; Regular content
3275 ;; Chrome
3297 ))
3299 ;; temp-name is set to nil on success
3303 ;;; Main Function
3305 ;;;###autoload
3307 "Major mode for editing JavaScript."
3320 ;; Comments
3325 ;; Parse cache
3328 ;; Frameworks
3331 ;; Imenu
3335 ;; for filling, pretend we're cc-mode
3337 c-paragraph-start "$"
3338 c-paragraph-separate "$"
3339 c-block-comment-prefix "* "
3340 c-line-comment-starter "//"
3350 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3351 ;; we call it instead? (Bug#6071)
3361 ;; Important to fontify the whole buffer syntactically! If we don't,
3362 ;; then we might have regular expression literals that aren't marked
3363 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3364 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3365 ;; When we attempt to find the error and scroll to the portion of
3366 ;; the buffer containing the problem, JIT-lock will apply the
3367 ;; correct syntax to the regular expression literal and the problem
3368 ;; will mysteriously disappear.
3369 ;; FIXME: We should actually do this fontification lazily by adding
3370 ;; calls to syntax-propertize wherever it's really needed.
3373 ;;;###autoload
3382 ;; js.el ends here