| blob | 346a77b5810620b54ffae7cb2d448b1b1d9f64ee |
1 ;;; js.el --- Major mode for editing JavaScript
3 ;; Copyright (C) 2008, 2009, 2010, 2011 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
243 for style in js--class-styles
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 subseqnce 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'."
431 "Number of additional spaces for indenting continued expressions.
432 The value must be no less than minus `js-indent-level'."
437 "Number of additional spaces for indenting expressions in parentheses.
438 The value must be no less than minus `js-indent-level'."
444 "Number of additional spaces for indenting expressions in square braces.
445 The value must be no less than minus `js-indent-level'."
451 "Number of additional spaces for indenting expressions in curly braces.
452 The value must be no less than minus `js-indent-level'."
458 "Whether to automatically indent when typing punctuation characters.
459 If non-nil, the characters {}();,: also indent the current line
460 in Javascript mode."
465 "Treat nested functions as top-level functions in `js-mode'.
466 This applies to function movement, marking, and so on."
471 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
476 "Frameworks recognized by `js-mode'.
477 To improve performance, you may turn off some frameworks you
478 seldom use, either globally or on a per-buffer basis."
481 js--available-frameworks))
486 "Whether `js-mode' should display tabs while selecting them.
487 This is useful only if the windowing system has a good mechanism
488 for preventing Firefox from stealing the keyboard focus."
493 "~/.emacs.d/js/js"
494 "Temporary directory used by `js-mode' to communicate with Mozilla.
495 This directory must be readable and writable by both Mozilla and Emacs."
500 "Reply timeout for executing commands in Mozilla via `js-mode'.
501 The value is given in seconds. Increase this value if you are
502 getting timeout messages."
506 ;;; KeyMap
525 keymap)
529 "Run the command bound to KEY, and indent if necessary.
530 Indentation does not take place if point is in a string or
531 comment."
536 js-auto-indent-flag)
543 ;;; Syntax table and parsing
549 table)
580 "Helper function for `js--update-quick-match-re'.
581 If LIST contains any element that is not nil, return its non-nil
582 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
583 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
584 nil. If any element in LIST is itself a list, flatten that
585 element."
591 "Internal function used by `js-mode' for caching buffer constructs.
592 This updates `js--quick-match-re', based on the current set of
593 enabled frameworks."
598 ;; #define mumble
607 ;; var mumble = THING (
628 ;; mumble.prototypeTHING
636 ;; mumble.prototype = {
643 "Move over the next value of PROPNAME in the buffer.
644 If found, return that value and leave point after the character
645 having that value; otherwise, return nil and leave point at EOB."
656 next-value))
659 "Move over the previous value of PROPNAME in the buffer.
660 If found, return that value and leave point just before the
661 character that has that value, otherwise return nil and leave
662 point at BOB."
675 prev-value)))
688 "Helper function for `js--re-search-forward'."
690 str-terminator
719 "Search forward, ignoring strings, cpp macros, and comments.
720 This function invokes `re-search-forward', but treats the buffer
721 as if strings, cpp macros, and comments have been removed.
723 If invoked while inside a macro, it treats the contents of the
724 macro as normal text."
741 "Auxiliary function for `js--re-search-backward'."
743 str-terminator
774 "Search backward, ignoring strings, preprocessor macros, and comments.
776 This function invokes `re-search-backward' but treats the buffer
777 as if strings, preprocessor macros, and comments have been
778 removed.
780 If invoked while inside a macro, treat the macro as normal text."
784 "Move forward over a whole JavaScript expression.
785 This function doesn't move over expressions continued across
786 lines."
788 ;; non-continued case; simplistic, but good enough?
801 "Move forward over a JavaScript function declaration.
802 This puts point at the 'function' keyword.
804 If this is a syntactically-correct non-expression function,
805 return the name of the function, or t if the name could not be
806 determined. Otherwise, return nil."
819 name)))))
822 "Return the start of the JavaScript function prologue containing POS.
823 A function prologue is everything from start of the definition up
824 to and including the opening brace. POS defaults to point.
825 If POS is not in a function prologue, return nil."
852 "Helper function for `js-beginning-of-defun'.
853 Go to previous defun-beginning and return the parse state for it,
854 or nil if we went all the way back to bob and don't find
855 anything."
863 "Helper function for `js--beginning-of-defun-nested'.
864 If PSTATE represents a non-empty top-level defun, return the
865 top-most pitem. Otherwise, return nil."
868 with func-pitem
875 "Helper function for `js--beginning-of-defun'.
876 Return the pitem of the function we went to the beginning of."
878 ;; Look for the smallest function that encloses point...
883 and return pitem)
885 ;; ...and if that isn't found, look for the previous top-level
886 ;; defun
888 while pstate
891 and return it)))
894 "Helper function for `js-beginning-of-defun'."
900 "Value of `beginning-of-defun-function' for `js-mode'."
916 ;; If we're just past the end of a function, the user probably wants
917 ;; to go to the beginning of *that* function
931 "Flush the `js-mode' syntax cache after position BEG.
932 BEG defaults to `point-min', meaning to flush the entire cache."
938 ;; `(message ,@arguments)
939 )
948 ;; open-items must contain at least two items for this to
949 ;; work, but because we push a dummy item to start with,
950 ;; that assumption holds.
953 open-items)
956 "Helper function for `js--ensure-cache'.
957 Update parsing information up to point, referring to parse,
958 prev-parse-point, goal-point, and open-items bound lexically in
959 the body of `js--ensure-cache'."
966 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
967 ;; the given depth -- i.e., make sure we're deeper than the target
968 ;; depth.
972 prev-parse-point goal-point
974 nil parse))
976 ;; (let ((overlay (make-overlay prev-parse-point (point))))
977 ;; (overlay-put overlay 'face '(:background "red"))
978 ;; (unwind-protect
979 ;; (progn
980 ;; (js--debug "parsed: %S" parse)
981 ;; (sit-for 1))
982 ;; (delete-overlay overlay)))
998 "Split a JavaScript name into its dot-separated parts.
999 This also removes any prototype parts from the split name
1011 "Guess the name of the JavaScript function at POSITION.
1013 Return the name of the function, or nil if the name could not be
1014 guessed.
1016 This function clobbers match data. If we find the preamble
1017 begins earlier than expected while guessing the function name,
1018 set `js--guess-function-name-start' to that position; otherwise,
1019 set that variable to nil."
1036 ;; Clear any endings that occur after point
1043 ;; Remove any cache properties after this point
1048 "Ensures brace cache is valid up to the character before LIMIT.
1049 LIMIT defaults to point."
1055 orig-match-start
1056 orig-match-end
1057 orig-depth
1058 parse
1059 prev-parse-point
1060 name
1061 case-fold-search
1062 filtered-class-styles
1063 new-item
1064 goal-point
1065 end-prop)
1067 ;; Figure out which class styles we need to look for
1071 js-enabled-frameworks)
1072 collect style))
1078 ;; Find last known good position
1094 ;; Make a placeholder for the top-level definition
1110 ;; Each of these conditions should return non-nil if
1111 ;; we should add a new item and leave point at the end
1112 ;; of the new item's header (h-end in the
1113 ;; js--pitem diagram). This point is the one
1114 ;; after the last character we need to unambiguously
1115 ;; detect this construct. If one of these evaluates to
1116 ;; nil, the location of the point is ignored.
1118 ;; In comment or string
1121 ;; Regular function declaration
1130 js--guess-function-name-start))
1137 :paren-depth orig-depth
1138 :h-begin orig-match-start
1141 name
1144 ;; Macro
1147 ;; Macros often contain unbalanced parentheses.
1148 ;; Make sure that h-end is at the textual end of
1149 ;; the macro no matter what the parenthesis say.
1155 :h-begin orig-match-start
1159 ;; "Prototype function" declaration
1166 :paren-depth orig-depth
1167 :h-begin orig-match-start
1173 ;; Class definition
1176 for class-style in filtered-class-styles
1182 and return
1184 :paren-depth orig-depth
1185 :h-begin orig-match-start
1186 :type class-style
1201 )))))
1204 "Helper function for `js-end-of-defun'."
1209 return t
1213 "Helper function for `js-end-of-defun'."
1222 found)
1225 ;; We're already inside a function; just go to its end.
1228 ;; Otherwise, go to the end of the next function...
1235 ;; ... or eob.
1239 "Value of `end-of-defun-function' for `js-mode'."
1250 ;; look for function backward. if we're inside it, go to that
1251 ;; function's end. otherwise, search for the next function's end and
1252 ;; go there
1256 ;; if we're doing nested functions, see whether we're in the
1257 ;; prologue. If we are, go to the end of the function; otherwise,
1258 ;; call js--end-of-defun-nested to do the real work
1279 t
1281 nil))))
1284 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1295 pos
1299 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1309 pos
1312 ;; Like (up-list -1), but only considers lists that end nearby"
1315 ;; Look at a very small region so our compuation time doesn't
1316 ;; explode in pathological cases.
1321 "Return non-nil iff point is in a function parameter list."
1332 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1354 ;;; Font Lock
1356 "Helper function for building `js--font-lock-keywords'.
1357 Create a byte-compiled function for matching a concatenation of
1358 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1369 "Move forward over a JavaScript destructuring spec.
1370 If FUNC is supplied, call it with no arguments before every
1371 variable name in the spec. Return true iff this was actually a
1372 spec. FUNC must preserve the match data."
1384 t)
1389 t))))
1392 t))
1406 t))
1411 t)))))
1414 t))))
1417 "Font-lock matcher for variable names in a variable declaration.
1418 This is a cc-mode-style matcher that *always* fails, from the
1419 point of view of font-lock. It applies highlighting directly with
1420 `font-lock-apply-highlight'."
1432 t))
1454 ;; Conditions to handle
1458 ;; Matcher always "fails"
1459 nil)
1462 `(
1463 ;; This goes before keywords-2 so it gets used preferentially
1464 ;; instead of the keywords in keywords-2. Don't use override
1465 ;; because that will override syntactic fontification too, which
1466 ;; will fontify commented-out directives as if they weren't
1467 ;; commented out.
1470 ,@js--font-lock-keywords-2
1475 ;; Highlights class being declared, in parts
1479 nil
1482 ;; Highlights parent class, in parts, if available
1499 ;; Highlights parent class
1503 ;; Dojo needs its own matcher to override the string highlighting
1505 'dojo
1512 ;; Match Dojo base classes. Of course Mojo has to be different
1513 ;; from everything else under the sun...
1515 'dojo
1524 ;; continued Dojo base-class list
1526 'dojo
1537 ;; variable declarations
1542 ;; class instantiation
1547 ;; instanceof
1552 ;; formal parameters
1556 js--name-start-re)
1562 ;; continued formal parameter list
1576 "Return whether point is inside the given pitem's header or body."
1586 "Parse the JavaScript program state at point.
1587 Return a list of `js--pitem' instances that apply to point, most
1588 specific first. In the worst case, the current toplevel instance
1589 will be returned."
1599 ;; Loop until we either hit a pitem at BOB or pitem ends after
1600 ;; point (or at point if we're at eob)
1607 pstate))))
1610 "Return the JavaScript syntactic context corresponding to PSTATE."
1613 type)
1619 "Return the JavaScript syntactic context at point.
1620 When called interatively, also display a message with that
1621 context."
1629 syntactic-context))
1632 "Font lock function used by `js-mode'.
1633 This performs fontification according to `js--class-styles'."
1641 js-enabled-frameworks)
1644 decl-re
1647 and return t)
1648 return t
1653 js--font-lock-keywords-2
1654 js--font-lock-keywords-3)
1657 ;; XXX: Javascript can continue a regexp literal across lines so long
1658 ;; as the newline is escaped with \. Account for that in the regexp
1659 ;; below.
1663 "Regexp matching a JavaScript regular expression literal.
1664 Match groups 1 and 2 are the characters forming the beginning and
1669 ;; We want to match regular expressions only at the beginning of
1670 ;; expressions.
1673 ;;; Indentation
1688 "Return non-nil if point is on a JavaScript operator, other than a comma."
1698 "Return non-nil if the current line continues an expression."
1715 Otherwise, return nil. A braceless do-while statement spanning
1716 several lines requires that the start of the loop is indented to
1717 the same column as the current line."
1739 "Helper function for `js--proper-indentation'.
1740 Return the proper indentation of the current line if it starts
1741 the body of a control statement without braces; otherwise, return
1742 nil."
1766 "Return the proper indentation for the current line."
1776 ;; A single closing paren/bracket should be indented at the
1777 ;; same level as the opening statement. Same goes for
1778 ;; "case" and "default".
1792 js-expr-indent-offset))
1799 ;; If there is something following the opening
1800 ;; paren/bracket, everything else should be indented at
1801 ;; the same level.
1812 "Indent the current line as JavaScript."
1822 ;;; Filling
1825 "Fill the paragraph with `c-fill-paragraph'."
1839 ;;; Type database and Imenu
1841 ;; We maintain a cache of semantic information, i.e., the classes and
1842 ;; functions we've encountered so far. In order to avoid having to
1843 ;; re-parse the buffer on every change, we cache the parse state at
1844 ;; each interesting point in the buffer. Each parse state is a
1845 ;; modified copy of the previous one, or in the case of the first
1846 ;; parse state, the empty state.
1847 ;;
1848 ;; The parse state itself is just a stack of js--pitem
1849 ;; instances. It starts off containing one element that is never
1850 ;; closed, that is initially js--initial-pitem.
1851 ;;
1859 name
1861 type
1865 "Helper function for `js--splice-into-items'.
1866 Return a new item that is the result of merging CHILD into
1867 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1868 that we haven't consumed yet."
1873 ;; If the item we're merging into isn't a class, make it into one
1879 ;; Use the child's class-style if it's available
1881 js--dummy-class-style
1886 ;; Now we can merge either a function or a class into a class
1890 ;; if we have more name-parts to go before we get to the
1891 ;; bottom of the class hierarchy, call the merger
1892 ;; recursively
1898 ;; Not merging a class, but something else, so just prepend
1899 ;; it
1903 ;; Otherwise, merge the new child's items into those
1904 ;; of the new class
1910 "Last part of the name of PITEM, as a string or symbol."
1914 name)))
1917 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1918 If a class doesn't exist in the tree, create it. Return
1919 the new items list. NAME-PARTS is a list of strings given
1920 the broken-down class name of the item to insert."
1924 new-items last-new-item new-cons item)
1927 name-parts
1933 ;; If top-name isn't found in items, then we build a copy of items
1934 ;; and throw it away. But that's okay, since most of the time, we
1935 ;; *will* find an instance.
1939 ;; Okay, we found an entry with the right name. Splice
1940 ;; the merged item into the list...
1943 name-parts)
1950 ;; ...and terminate the loop
1951 nil)
1954 ;; Otherwise, copy the current cons and move onto the
1955 ;; text. This is tricky; we keep track of the tail of
1956 ;; the list that begins with new-items in
1957 ;; last-new-item.
1964 ;; Go to the next cell in items
1968 ;; Yay! We stopped because we found something, not because
1969 ;; we ran out of items to search. Just return the new
1970 ;; list.
1973 new-items)
1975 ;; We didn't find anything. If the child is a class and we don't
1976 ;; have any classes to drill down into, just push that class;
1977 ;; otherwise, make a fake class and carry on.
1980 ;; We have name-parts left to process. Make a fake
1981 ;; class for this particular part...
1983 ;; ...and recursively digest the rest of the name
1986 :type js--dummy-class-style
1989 ;; Otherwise, this is the only name we have, so stick
1990 ;; the item on the front of the list
1991 child)
1992 items))))
1995 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2000 t))
2002 ;; This trick works because we know (based on our defstructs) that
2003 ;; the child list is always the first element, and so the second
2004 ;; element and beyond can be shared when we make our "copy".
2011 ;; Use slow path because we need class lookup
2017 ;; Use slow path because we need class merging. We know
2018 ;; name is a list here because down in
2019 ;; `js--ensure-cache', we made sure to only add
2020 ;; class entries with lists for :name
2025 ;; Fast path
2031 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2034 location))
2037 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2054 imenu-items))
2059 unknown-ctr))
2062 imenu-items))
2071 imenu-items))))
2075 imenu-items))
2078 "Return an imenu index for the current buffer."
2090 ;; Make sure everything is closed
2098 ;; Convert the new-finalized state into what imenu expects
2101 unknown-ctr))))))
2103 ;; Silence the compiler.
2114 symbols)
2115 else
2126 "Return a hash table of all JavaScript symbols.
2127 This searches all existing `js-mode' buffers. Each key is the
2128 name of a symbol (possibly disambiguated with <N>, where N > 1),
2129 and each value is a marker giving the location of that symbol."
2131 with imenu-use-markers = t
2132 for buffer being the buffers
2137 finally return symbols))
2143 "Helper function for `js-find-symbol'.
2144 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2145 one from `js--get-all-known-symbols', using prompt PROMPT and
2146 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2147 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2148 marker."
2154 prompt
2156 collect key)
2173 "Read a JavaScript symbol and jump to it.
2174 With a prefix argument, restrict symbols to those from the
2175 current buffer. Pushes a mark onto the tag ring just like
2176 `find-tag'."
2187 symbols "Jump to: "
2195 ;;; MozRepl integration
2205 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2206 On timeout, return nil. On success, return t with match data
2207 set. If START is non-nil, look for output starting from START.
2208 Otherwise, use the current value of `process-mark'."
2220 'js-moz-bad-rpc
2224 ;; Integer, mirrors the value we see in JS
2227 ;; Process to which this thing belongs
2248 ; */" Make Emacs happy
2249 "(function(repl) {
2250 repl.defineInteractor('js', {
2251 onStart: function onStart(repl) {
2252 if(!repl._jsObjects) {
2253 repl._jsObjects = {};
2254 repl._jsLastID = 0;
2255 repl._jsGC = this._jsGC;
2256 }
2257 this._input = '';
2258 },
2260 _jsGC: function _jsGC(ids_in_use) {
2261 var objects = this._jsObjects;
2262 var keys = [];
2263 var num_freed = 0;
2265 for(var pn in objects) {
2266 keys.push(Number(pn));
2267 }
2269 keys.sort(function(x, y) x - y);
2270 ids_in_use.sort(function(x, y) x - y);
2271 var i = 0;
2272 var j = 0;
2274 while(i < ids_in_use.length && j < keys.length) {
2275 var id = ids_in_use[i++];
2276 while(j < keys.length && keys[j] !== id) {
2277 var k_id = keys[j++];
2278 delete objects[k_id];
2279 ++num_freed;
2280 }
2281 ++j;
2282 }
2284 while(j < keys.length) {
2285 var k_id = keys[j++];
2286 delete objects[k_id];
2287 ++num_freed;
2288 }
2290 return num_freed;
2291 },
2293 _mkArray: function _mkArray() {
2294 var result = [];
2295 for(var i = 0; i < arguments.length; ++i) {
2296 result.push(arguments[i]);
2297 }
2298 return result;
2299 },
2301 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2302 if(typeof parts === 'string') {
2303 parts = [ parts ];
2304 }
2306 var obj = parts[0];
2307 var start = 1;
2309 if(typeof obj === 'string') {
2310 obj = window;
2311 start = 0;
2312 } else if(parts.length < 2) {
2313 throw new Error('expected at least 2 arguments');
2314 }
2316 for(var i = start; i < parts.length - 1; ++i) {
2317 obj = obj[parts[i]];
2318 }
2320 return [obj, parts[parts.length - 1]];
2321 },
2323 _getProp: function _getProp(/*...*/) {
2324 if(arguments.length === 0) {
2325 throw new Error('no arguments supplied to getprop');
2326 }
2328 if(arguments.length === 1 &&
2329 (typeof arguments[0]) !== 'string')
2330 {
2331 return arguments[0];
2332 }
2334 var [obj, propname] = this._parsePropDescriptor(arguments);
2335 return obj[propname];
2336 },
2338 _putProp: function _putProp(properties, value) {
2339 var [obj, propname] = this._parsePropDescriptor(properties);
2340 obj[propname] = value;
2341 },
2343 _delProp: function _delProp(propname) {
2344 var [obj, propname] = this._parsePropDescriptor(arguments);
2345 delete obj[propname];
2346 },
2348 _typeOf: function _typeOf(thing) {
2349 return typeof thing;
2350 },
2352 _callNew: function(constructor) {
2353 if(typeof constructor === 'string')
2354 {
2355 constructor = window[constructor];
2356 } else if(constructor.length === 1 &&
2357 typeof constructor[0] !== 'string')
2358 {
2359 constructor = constructor[0];
2360 } else {
2361 var [obj,propname] = this._parsePropDescriptor(constructor);
2362 constructor = obj[propname];
2363 }
2365 /* Hacky, but should be robust */
2366 var s = 'new constructor(';
2367 for(var i = 1; i < arguments.length; ++i) {
2368 if(i != 1) {
2369 s += ',';
2370 }
2372 s += 'arguments[' + i + ']';
2373 }
2375 s += ')';
2376 return eval(s);
2377 },
2379 _callEval: function(thisobj, js) {
2380 return eval.call(thisobj, js);
2381 },
2383 getPrompt: function getPrompt(repl) {
2384 return 'EVAL>'
2385 },
2387 _lookupObject: function _lookupObject(repl, id) {
2388 if(typeof id === 'string') {
2389 switch(id) {
2390 case 'global':
2391 return window;
2392 case 'nil':
2393 return null;
2394 case 't':
2395 return true;
2396 case 'false':
2397 return false;
2398 case 'undefined':
2399 return undefined;
2400 case 'repl':
2401 return repl;
2402 case 'interactor':
2403 return this;
2404 case 'NaN':
2405 return NaN;
2406 case 'Infinity':
2407 return Infinity;
2408 case '-Infinity':
2409 return -Infinity;
2410 default:
2411 throw new Error('No object with special id:' + id);
2412 }
2413 }
2415 var ret = repl._jsObjects[id];
2416 if(ret === undefined) {
2417 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2418 }
2419 return ret;
2420 },
2422 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2423 if(typeof value !== 'object' && typeof value !== 'function') {
2424 throw new Error('_findOrAllocateObject called on non-object('
2425 + typeof(value) + '): '
2426 + value)
2427 }
2429 for(var id in repl._jsObjects) {
2430 id = Number(id);
2431 var obj = repl._jsObjects[id];
2432 if(obj === value) {
2433 return id;
2434 }
2435 }
2437 var id = ++repl._jsLastID;
2438 repl._jsObjects[id] = value;
2439 return id;
2440 },
2442 _fixupList: function _fixupList(repl, list) {
2443 for(var i = 0; i < list.length; ++i) {
2444 if(list[i] instanceof Array) {
2445 this._fixupList(repl, list[i]);
2446 } else if(typeof list[i] === 'object') {
2447 var obj = list[i];
2448 if(obj.funcall) {
2449 var parts = obj.funcall;
2450 this._fixupList(repl, parts);
2451 var [thisobj, func] = this._parseFunc(parts[0]);
2452 list[i] = func.apply(thisobj, parts.slice(1));
2453 } else if(obj.objid) {
2454 list[i] = this._lookupObject(repl, obj.objid);
2455 } else {
2456 throw new Error('Unknown object type: ' + obj.toSource());
2457 }
2458 }
2459 }
2460 },
2462 _parseFunc: function(func) {
2463 var thisobj = null;
2465 if(typeof func === 'string') {
2466 func = window[func];
2467 } else if(func instanceof Array) {
2468 if(func.length === 1 && typeof func[0] !== 'string') {
2469 func = func[0];
2470 } else {
2471 [thisobj, func] = this._parsePropDescriptor(func);
2472 func = thisobj[func];
2473 }
2474 }
2476 return [thisobj,func];
2477 },
2479 _encodeReturn: function(value, array_as_mv) {
2480 var ret;
2482 if(value === null) {
2483 ret = ['special', 'null'];
2484 } else if(value === true) {
2485 ret = ['special', 'true'];
2486 } else if(value === false) {
2487 ret = ['special', 'false'];
2488 } else if(value === undefined) {
2489 ret = ['special', 'undefined'];
2490 } else if(typeof value === 'number') {
2491 if(isNaN(value)) {
2492 ret = ['special', 'NaN'];
2493 } else if(value === Infinity) {
2494 ret = ['special', 'Infinity'];
2495 } else if(value === -Infinity) {
2496 ret = ['special', '-Infinity'];
2497 } else {
2498 ret = ['atom', value];
2499 }
2500 } else if(typeof value === 'string') {
2501 ret = ['atom', value];
2502 } else if(array_as_mv && value instanceof Array) {
2503 ret = ['array', value.map(this._encodeReturn, this)];
2504 } else {
2505 ret = ['objid', this._findOrAllocateObject(repl, value)];
2506 }
2508 return ret;
2509 },
2511 _handleInputLine: function _handleInputLine(repl, line) {
2512 var ret;
2513 var array_as_mv = false;
2515 try {
2516 if(line[0] === '*') {
2517 array_as_mv = true;
2518 line = line.substring(1);
2519 }
2520 var parts = eval(line);
2521 this._fixupList(repl, parts);
2522 var [thisobj, func] = this._parseFunc(parts[0]);
2523 ret = this._encodeReturn(
2524 func.apply(thisobj, parts.slice(1)),
2525 array_as_mv);
2526 } catch(x) {
2527 ret = ['error', x.toString() ];
2528 }
2530 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2531 repl.print(JSON.encode(ret));
2532 repl._prompt();
2533 },
2535 handleInput: function handleInput(repl, chunk) {
2536 this._input += chunk;
2537 var match, line;
2539 line = match[0];
2542 repl.popInteractor();
2543 repl._prompt();
2544 return;
2545 }
2547 this._input = this._input.substring(line.length);
2548 this._handleInputLine(repl, line);
2549 }
2550 }
2551 });
2552 })
2558 "Marshall the given value for JS.
2559 Strings and numbers are JSON-encoded. Lists (including nil) are
2560 made into JavaScript array literals and their contents encoded
2561 with `js--js-encode-value'."
2588 js--js-repl-prompt-regexp js-js-timeout
2590 ;; start matching against the beginning of the line in
2591 ;; order to catch a prompt that's only partially arrived
2599 ;; Do some initialization the first time we see a process
2605 ;; Send interactor definition
2611 js-js-timeout))
2613 ;; Sanity check
2619 ;; If js--js-repl-depth > 0, we *should* be seeing an
2620 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2621 ;; up with us.
2624 ;; Otherwise, tell Mozilla to enter the interactor mode
2630 js-js-timeout))
2644 js-js-timeout))))
2654 "Convert immediate js< and js! references to deferred ones."
2678 function))
2680 else
2681 collect item)))
2696 "Run FORMS with the Mozilla repl set up for js commands.
2697 Inside the lexical scope of `with-js', `js?', `js!',
2698 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2699 `js-create-instance', and `js-qi' are defined."
2710 function)
2718 function)
2750 props)
2752 ))
2758 "Whether to listify any Array returned by a Mozilla function.
2769 js--js-references)
2774 js--js-references)))
2779 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2780 If function is a string, look it up as a property on the global
2781 object and use the global object for `this'.
2782 If FUNCTION is a list with one element, use that element as the
2783 function with the global object for `this', except that if that
2784 single element is a string, look it up on the global object.
2785 If FUNCTION is a list with more than one argument, use the list
2786 up to the last value as a property descriptor and the last
2787 argument as a function."
2794 ;; Actual funcall
2801 js-js-timeout)
2804 ;; Read the result
2811 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2812 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2815 constructor arguments))
2821 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2824 arguments)))
2833 "Tell the repl about any objects we don't reference anymore.
2834 With argument, run even if no intervening GC has happened."
2845 ;; Don't bother running unless we've had an intervening
2846 ;; garbage collection; without a gc, nothing is deleted
2847 ;; from the weak hash table, so it's pointless telling
2848 ;; MozRepl about that references we still hold
2851 ;; Are we looking at a normal prompt? Make sure not to
2852 ;; interrupt the user if he's doing something
2860 of js--js-references
2861 collect x))
2868 num)))
2873 "Evaluate the JavaScript in JS and return JSON-decoded result."
2881 result)))
2884 "Enumerate all JavaScript contexts available.
2885 Each context is a list:
2886 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2887 (TITLE URL WINDOW) for windows
2889 All tabs of a given window are grouped together. The most recent
2890 window is first. Within each window, the tabs are returned
2891 left-to-right."
2896 "@mozilla.org/appshell/window-mediator;1"
2918 window)
2925 "browsers"
2926 x
2927 "contentDocument"
2931 "browsers"
2932 x
2933 "contentWindow"
2934 "location"
2937 "browsers"
2938 x)
2941 "tabContainer"
2942 "childNodes"
2944 x)
2946 gbrowser))))))
2951 "Read a Mozilla tab with prompt PROMPT.
2952 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2953 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2954 browser, respectively."
2956 ;; Prime IDO
2963 selected-tab prev-hitab)
2965 ;; Disambiguate names
2967 for tab in tabs
2983 ;; Hack to reduce the number of
2984 ;; round-trips to mozilla
2987 ;; Highlighting tab
2990 "style"
2992 cmds)
2994 ;; Highlight window proper
2997 "style"
2999 cmds)
3001 ;; Select tab, when appropriate
3005 cmds)))
3007 ;; Hilighting whole window
3011 "style"
3014 cmds)))
3017 ;; Unhighlighting tab
3020 cmds)
3022 cmds))
3024 ;; Unhighlighting window
3029 cmds)))
3035 ()
3041 ()
3042 ;; Fiddle with the match list a bit: if our first match
3043 ;; is a tabbrowser window, rotate the match list until
3044 ;; the active tab comes up
3050 "document"
3051 "documentElement"
3056 "gBrowser"
3060 for match in ido-matches
3064 and return t)))
3074 prompt
3076 nil t nil
3094 "Helper function for `js-eval-defun'.
3095 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3096 strings making up the class name and NAME is the name of the
3097 function part."
3116 "The current JavaScript context.
3117 This is a cons like the one returned from `js--read-tab'.
3121 "(function(func_info,func) {
3122 func_info.unshift('window');
3123 var obj = window;
3124 for(var i = 1; i < func_info.length - 1; ++i) {
3125 var next = obj[func_info[i]];
3126 if(typeof next !== 'object' && typeof next !== 'function') {
3127 next = obj.prototype && obj.prototype[func_info[i]];
3128 if(typeof next !== 'object' && typeof next !== 'function') {
3129 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3130 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3131 return;
3132 }
3134 func_info.splice(i+1, 0, 'prototype');
3135 ++i;
3136 }
3137 }
3139 obj[func_info[i]] = func;
3140 alert('Successfully updated '+func_info.join('.'));
3144 "Set the JavaScript context to CONTEXT.
3145 When called interactively, prompt for CONTEXT."
3150 "Return a valid JavaScript context.
3151 If one hasn't been set, or if it's stale, prompt for a new one."
3160 js--js-context))
3174 file)))
3187 "Update a Mozilla tab using the JavaScript defun at point."
3190 ;; This function works by generating a temporary file that contains
3191 ;; the function we'd like to insert. We then use the elisp-js bridge
3192 ;; to command mozilla to load this file by inserting a script tag
3193 ;; into the document we set. This way, debuggers and such will have
3194 ;; a way to find the source of the just-inserted function.
3195 ;;
3196 ;; We delete the temporary file if there's an error, but otherwise
3197 ;; we add an unload event listener on the Mozilla side to delete the
3198 ;; file.
3229 ;; (Re)register a Mozilla resource URL to point to the
3230 ;; temporary directory
3248 ;; Give Mozilla responsibility for deleting this file
3253 ;; Regular content
3257 ;; Chrome
3279 ))
3281 ;; temp-name is set to nil on success
3285 ;;; Main Function
3287 ;;;###autoload
3289 "Major mode for editing JavaScript."
3302 js-syntax-propertize-function)
3309 ;; Comments
3315 ;; Parse cache
3318 ;; Frameworks
3321 ;; Imenu
3326 ;; for filling, pretend we're cc-mode
3328 c-paragraph-start "$"
3329 c-paragraph-separate "$"
3330 c-block-comment-prefix "* "
3331 c-line-comment-starter "//"
3336 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3337 ;; we call it instead? (Bug#6071)
3348 ;; Important to fontify the whole buffer syntactically! If we don't,
3349 ;; then we might have regular expression literals that aren't marked
3350 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3351 ;; etc. and and produce maddening "unbalanced parenthesis" errors.
3352 ;; When we attempt to find the error and scroll to the portion of
3353 ;; the buffer containing the problem, JIT-lock will apply the
3354 ;; correct syntax to the regular expresion literal and the problem
3355 ;; will mysteriously disappear.
3356 ;; FIXME: We should actually do this fontification lazily by adding
3357 ;; calls to syntax-propertize wherever it's really needed.
3360 ;;;###autoload
3369 ;; js.el ends here