| blob | 6bd8fbc2442894a2a8e278e0fe40a14be64fcb4d |
1 ;;; js.el --- Major mode for editing JavaScript
3 ;; Copyright (C) 2008, 2009, 2010 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, oop, 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:
70 ;;; Constants
92 "Regexp matching the prefix of a cpp directive.
93 This includes the directive name, or nil in languages without
94 preprocessor support. The first submatch surrounds the directive
101 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
110 ;; var NewClass = BaseClass.extend(
118 ;; var NewClass = Class.create()
134 ;; var NewClass = Class.create({
141 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
142 ;; matched with dedicated font-lock matchers
170 :prototype t
176 :prototype t
192 :prototype t
198 :prototype t
209 :prototype t
223 "List of JavaScript class definition styles.
225 A class definition style is a plist with the following keys:
227 :name is a human-readable name of the class type
229 :class-decl is a regular expression giving the start of the
230 class. Its first group must match the name of its class. If there
231 is a parent class, the second group should match, and it should be
232 the name of the class.
234 If :prototype is present and non-nil, the parser will merge
235 declarations for this constructs with others at the same lexical
236 level that have the same name. Otherwise, multiple definitions
237 will create multiple top-level entries. Don't use :prototype
238 unnecessarily: it has an associated cost in performance.
240 If :strip-prototype is present and non-nil, then if the class
241 name as matched contains
246 for style in js--class-styles
249 collect framework into available-frameworks
250 finally return available-frameworks)
256 "Regexp matching the start of a JavaScript function header.
262 "Regexp matching the start of a function entry in an associative array.
274 "Regexp matching a CPP macro definition, up to the opening parenthesis.
324 ;; js--pitem is the basic building block of the lexical
325 ;; database. When one refers to a real part of the buffer, the region
326 ;; of text to which it refers is split into a conceptual header and
327 ;; body. Consider the (very short) block described by a hypothetical
328 ;; js--pitem:
329 ;;
330 ;; function foo(a,b,c) { return 42; }
331 ;; ^ ^ ^
332 ;; | | |
333 ;; +- h-begin +- h-end +- b-end
334 ;;
335 ;; (Remember that these are buffer positions, and therefore point
336 ;; between characters, not at them. An arrow drawn to a character
337 ;; indicates the corresponding position is between that character and
338 ;; the one immediately preceding it.)
339 ;;
340 ;; The header is the region of text [h-begin, h-end], and is
341 ;; the text needed to unambiguously recognize the start of the
342 ;; construct. If the entire header is not present, the construct is
343 ;; not recognized at all. No other pitems may be nested inside the
344 ;; header.
345 ;;
346 ;; The body is the region [h-end, b-end]. It may contain nested
347 ;; js--pitem instances. The body of a pitem may be empty: in
348 ;; that case, b-end is equal to header-end.
349 ;;
350 ;; The three points obey the following relationship:
351 ;;
352 ;; h-begin < h-end <= b-end
353 ;;
354 ;; We put a text property in the buffer on the character *before*
355 ;; h-end, and if we see it, on the character *before* b-end.
356 ;;
357 ;; The text property for h-end, js--pstate, is actually a list
358 ;; of all js--pitem instances open after the marked character.
359 ;;
360 ;; The text property for b-end, js--pend, is simply the
361 ;; js--pitem that ends after the marked character. (Because
362 ;; pitems always end when the paren-depth drops below a critical
363 ;; value, and because we can only drop one level per character, only
364 ;; one pitem may end at a given character.)
365 ;;
366 ;; In the structure below, we only store h-begin and (sometimes)
367 ;; b-end. We can trivially and quickly find h-end by going to h-begin
368 ;; and searching for an js--pstate text property. Since no other
369 ;; js--pitem instances can be nested inside the header of a
370 ;; pitem, the location after the character with this text property
371 ;; must be h-end.
372 ;;
373 ;; js--pitem instances are never modified (with the exception
374 ;; of the b-end field). Instead, modified copies are added at subseqnce parse points.
375 ;; (The exception for b-end and its caveats is described below.)
376 ;;
379 ;; IMPORTANT: Do not alter the position of fields within the list.
380 ;; Various bits of code depend on their positions, particularly
381 ;; anything that manipulates the list of children.
383 ;; List of children inside this pitem's body
386 ;; When we reach this paren depth after h-end, the pitem ends
389 ;; Symbol or class-style plist if this is a class
392 ;; See above
395 ;; List of strings giving the parts of the name of this pitem (e.g.,
396 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
399 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
400 ;; this pitem: when we copy-and-modify pitem instances, we share
401 ;; their tail structures, so all the copies actually have the same
402 ;; terminating cons cell. We modify that shared cons cell directly.
403 ;;
404 ;; The field value is either a number (buffer location) or nil if
405 ;; unknown.
406 ;;
407 ;; If the field's value is greater than `js--cache-end', the
408 ;; value is stale and must be treated as if it were nil. Conversely,
409 ;; if this field is nil, it is guaranteed that this pitem is open up
410 ;; to at least `js--cache-end'. (This property is handy when
411 ;; computing whether we're inside a given pitem.)
412 ;;
415 ;; The pitem we start parsing with.
418 :paren-depth most-negative-fixnum
421 ;;; User Customization
424 "Customization variables for JavaScript mode."
429 "Number of spaces for each indentation step in `js-mode'."
434 "Number of additional spaces used for indentation of continued expressions.
435 The value must be no less than minus `js-indent-level'."
440 "Whether to automatically indent when typing punctuation characters.
441 If non-nil, the characters {}();,: also indent the current line
442 in Javascript mode."
447 "Treat nested functions as top-level functions in `js-mode'.
448 This applies to function movement, marking, and so on."
453 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
458 "Frameworks recognized by `js-mode'.
459 To improve performance, you may turn off some frameworks you
460 seldom use, either globally or on a per-buffer basis."
463 js--available-frameworks))
468 "Whether `js-mode' should display tabs while selecting them.
469 This is useful only if the windowing system has a good mechanism
470 for preventing Firefox from stealing the keyboard focus."
475 "~/.emacs.d/js/js"
476 "Temporary directory used by `js-mode' to communicate with Mozilla.
477 This directory must be readable and writable by both Mozilla and
478 Emacs."
483 "Reply timeout for executing commands in Mozilla via `js-mode'.
484 The value is given in seconds. Increase this value if you are
485 getting timeout messages."
489 ;;; KeyMap
508 keymap)
512 "Run the command bound to KEY, and indent if necessary.
513 Indentation does not take place if point is in a string or
514 comment."
519 js-auto-indent-flag)
526 ;;; Syntax table and parsing
532 table)
563 "Helper function for `js--update-quick-match-re'.
564 If LIST contains any element that is not nil, return its non-nil
565 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
566 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
567 nil. If any element in LIST is itself a list, flatten that
568 element."
574 "Internal function used by `js-mode' for caching buffer constructs.
575 This updates `js--quick-match-re', based on the current set of
576 enabled frameworks."
581 ;; #define mumble
590 ;; var mumble = THING (
611 ;; mumble.prototypeTHING
619 ;; mumble.prototype = {
626 "Move over the next value of PROPNAME in the buffer.
627 If found, return that value and leave point after the character
628 having that value; otherwise, return nil and leave point at EOB."
639 next-value))
642 "Move over the previous value of PROPNAME in the buffer.
643 If found, return that value and leave point just before the
644 character that has that value, otherwise return nil and leave
645 point at BOB."
658 prev-value)))
671 "Helper function for `js--re-search-forward'."
673 str-terminator
702 "Search forward, ignoring strings, cpp macros, and comments.
703 This function invokes `re-search-forward', but treats the buffer
704 as if strings, cpp macros, and comments have been removed.
706 If invoked while inside a macro, it treats the contents of the
707 macro as normal text."
725 "Auxiliary function for `js--re-search-backward'."
727 str-terminator
758 "Search backward, ignoring strings, preprocessor macros, and comments.
760 This function invokes `re-search-backward' but treats the buffer
761 as if strings, preprocessor macros, and comments have been
762 removed.
764 If invoked while inside a macro, treat the macro as normal text."
781 "Move forward over a whole JavaScript expression.
782 This function doesn't move over expressions continued across
783 lines."
785 ;; non-continued case; simplistic, but good enough?
798 "Move forward over a JavaScript function declaration.
799 This puts point at the 'function' keyword.
801 If this is a syntactically-correct non-expression function,
802 return the name of the function, or t if the name could not be
803 determined. Otherwise, return nil."
816 name)))))
819 "Return the start of the JavaScript function prologue containing POS.
820 A function prologue is everything from start of the definition up
821 to and including the opening brace. POS defaults to point.
822 If POS is not in a function prologue, return nil."
849 "Helper function for `js-beginning-of-defun'.
850 Go to previous defun-beginning and return the parse state for it,
851 or nil if we went all the way back to bob and don't find
852 anything."
860 "Helper function for `js--beginning-of-defun-nested'.
861 If PSTATE represents a non-empty top-level defun, return the
862 top-most pitem. Otherwise, return nil."
865 with func-pitem
872 "Helper function for `js--beginning-of-defun'.
873 Return the pitem of the function we went to the beginning of."
875 ;; Look for the smallest function that encloses point...
880 and return pitem)
882 ;; ...and if that isn't found, look for the previous top-level
883 ;; defun
885 while pstate
888 and return it)))
891 "Helper function for `js-beginning-of-defun'."
897 "Value of `beginning-of-defun-function' for `js-mode'."
913 ;; If we're just past the end of a function, the user probably wants
914 ;; to go to the beginning of *that* function
928 "Flush the `js-mode' syntax cache after position BEG.
929 BEG defaults to `point-min', meaning to flush the entire cache."
935 ;; `(message ,@arguments)
936 )
945 ;; open-items must contain at least two items for this to
946 ;; work, but because we push a dummy item to start with,
947 ;; that assumption holds.
950 open-items)
953 "Helper function for `js--ensure-cache'.
954 Update parsing information up to point, referring to parse,
955 prev-parse-point, goal-point, and open-items bound lexically in
956 the body of `js--ensure-cache'."
963 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
964 ;; the given depth -- i.e., make sure we're deeper than the target
965 ;; depth.
969 prev-parse-point goal-point
971 nil parse))
973 ;; (let ((overlay (make-overlay prev-parse-point (point))))
974 ;; (overlay-put overlay 'face '(:background "red"))
975 ;; (unwind-protect
976 ;; (progn
977 ;; (js--debug "parsed: %S" parse)
978 ;; (sit-for 1))
979 ;; (delete-overlay overlay)))
995 "Split a JavaScript name into its dot-separated parts.
996 This also removes any prototype parts from the split name
1008 "Guess the name of the JavaScript function at POSITION.
1010 Return the name of the function, or nil if the name could not be
1011 guessed.
1013 This function clobbers match data. If we find the preamble
1014 begins earlier than expected while guessing the function name,
1015 set `js--guess-function-name-start' to that position; otherwise,
1016 set that variable to nil."
1033 ;; Clear any endings that occur after point
1040 ;; Remove any cache properties after this point
1045 "Ensures brace cache is valid up to the character before LIMIT.
1046 LIMIT defaults to point."
1052 orig-match-start
1053 orig-match-end
1054 orig-depth
1055 parse
1056 prev-parse-point
1057 name
1058 case-fold-search
1059 filtered-class-styles
1060 new-item
1061 goal-point
1062 end-prop)
1064 ;; Figure out which class styles we need to look for
1068 js-enabled-frameworks)
1069 collect style))
1075 ;; Find last known good position
1091 ;; Make a placeholder for the top-level definition
1107 ;; Each of these conditions should return non-nil if
1108 ;; we should add a new item and leave point at the end
1109 ;; of the new item's header (h-end in the
1110 ;; js--pitem diagram). This point is the one
1111 ;; after the last character we need to unambiguously
1112 ;; detect this construct. If one of these evaluates to
1113 ;; nil, the location of the point is ignored.
1115 ;; In comment or string
1118 ;; Regular function declaration
1127 js--guess-function-name-start))
1134 :paren-depth orig-depth
1135 :h-begin orig-match-start
1138 name
1141 ;; Macro
1144 ;; Macros often contain unbalanced parentheses.
1145 ;; Make sure that h-end is at the textual end of
1146 ;; the macro no matter what the parenthesis say.
1152 :h-begin orig-match-start
1156 ;; "Prototype function" declaration
1163 :paren-depth orig-depth
1164 :h-begin orig-match-start
1170 ;; Class definition
1173 for class-style in filtered-class-styles
1179 and return
1181 :paren-depth orig-depth
1182 :h-begin orig-match-start
1183 :type class-style
1198 )))))
1201 "Helper function for `js-end-of-defun'."
1206 return t
1210 "Helper function for `js-end-of-defun'."
1219 found)
1222 ;; We're already inside a function; just go to its end.
1225 ;; Otherwise, go to the end of the next function...
1232 ;; ... or eob.
1236 "Value of `end-of-defun-function' for `js-mode'."
1247 ;; look for function backward. if we're inside it, go to that
1248 ;; function's end. otherwise, search for the next function's end and
1249 ;; go there
1253 ;; if we're doing nested functions, see whether we're in the
1254 ;; prologue. If we are, go to the end of the function; otherwise,
1255 ;; call js--end-of-defun-nested to do the real work
1276 t
1278 nil))))
1281 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1292 pos
1296 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1306 pos
1309 ;; Like (up-list -1), but only considers lists that end nearby"
1312 ;; Look at a very small region so our compuation time doesn't
1313 ;; explode in pathological cases.
1318 "Return non-nil iff point is in a function parameter list."
1329 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1351 ;;; Font Lock
1353 "Helper function for building `js--font-lock-keywords'.
1354 Create a byte-compiled function for matching a concatenation of
1355 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1366 "Move forward over a JavaScript destructuring spec.
1367 If FUNC is supplied, call it with no arguments before every
1368 variable name in the spec. Return true iff this was actually a
1369 spec. FUNC must preserve the match data."
1381 t)
1386 t))))
1389 t))
1403 t))
1408 t)))))
1411 t))))
1414 "Font-lock matcher for variable names in a variable declaration.
1415 This is a cc-mode-style matcher that *always* fails, from the
1416 point of view of font-lock. It applies highlighting directly with
1417 `font-lock-apply-highlight'."
1429 t))
1451 ;; Conditions to handle
1455 ;; Matcher always "fails"
1456 nil)
1459 `(
1460 ;; This goes before keywords-2 so it gets used preferentially
1461 ;; instead of the keywords in keywords-2. Don't use override
1462 ;; because that will override syntactic fontification too, which
1463 ;; will fontify commented-out directives as if they weren't
1464 ;; commented out.
1467 ,@js--font-lock-keywords-2
1472 ;; Highlights class being declared, in parts
1476 nil
1479 ;; Highlights parent class, in parts, if available
1496 ;; Highlights parent class
1500 ;; Dojo needs its own matcher to override the string highlighting
1502 'dojo
1509 ;; Match Dojo base classes. Of course Mojo has to be different
1510 ;; from everything else under the sun...
1512 'dojo
1521 ;; continued Dojo base-class list
1523 'dojo
1534 ;; variable declarations
1539 ;; class instantiation
1544 ;; instanceof
1549 ;; formal parameters
1553 js--name-start-re)
1559 ;; continued formal parameter list
1573 "Return whether point is inside the given pitem's header or body."
1583 "Parse the JavaScript program state at point.
1584 Return a list of `js--pitem' instances that apply to point, most
1585 specific first. In the worst case, the current toplevel instance
1586 will be returned."
1596 ;; Loop until we either hit a pitem at BOB or pitem ends after
1597 ;; point (or at point if we're at eob)
1604 pstate))))
1607 "Return the JavaScript syntactic context corresponding to PSTATE."
1610 type)
1616 "Return the JavaScript syntactic context at point.
1617 When called interatively, also display a message with that
1618 context."
1626 syntactic-context))
1629 "Font lock function used by `js-mode'.
1630 This performs fontification according to `js--class-styles'."
1638 js-enabled-frameworks)
1641 decl-re
1644 and return t)
1645 return t
1650 js--font-lock-keywords-2
1651 js--font-lock-keywords-3)
1654 ;; XXX: Javascript can continue a regexp literal across lines so long
1655 ;; as the newline is escaped with \. Account for that in the regexp
1656 ;; below.
1659 "Regexp matching a JavaScript regular expression literal.
1660 Match groups 1 and 2 are the characters forming the beginning and
1663 ;; we want to match regular expressions only at the beginning of
1664 ;; expressions
1667 "Syntactic font lock keywords matching regexps in JavaScript.
1670 ;;; Indentation
1685 "Return non-nil if point is on a JavaScript operator, other than a comma."
1695 "Return non-nil if the current line continues an expression."
1712 Otherwise, return nil. A braceless do-while statement spanning
1713 several lines requires that the start of the loop is indented to
1714 the same column as the current line."
1736 "Helper function for `js--proper-indentation'.
1737 Return the proper indentation of the current line if it starts
1738 the body of a control statement without braces; otherwise, return
1739 nil."
1763 "Return the proper indentation for the current line."
1786 js-expr-indent-offset))
1799 "Indent the current line as JavaScript."
1809 ;;; Filling
1812 "Fill the paragraph with `c-fill-paragraph'."
1826 ;;; Type database and Imenu
1828 ;; We maintain a cache of semantic information, i.e., the classes and
1829 ;; functions we've encountered so far. In order to avoid having to
1830 ;; re-parse the buffer on every change, we cache the parse state at
1831 ;; each interesting point in the buffer. Each parse state is a
1832 ;; modified copy of the previous one, or in the case of the first
1833 ;; parse state, the empty state.
1834 ;;
1835 ;; The parse state itself is just a stack of js--pitem
1836 ;; instances. It starts off containing one element that is never
1837 ;; closed, that is initially js--initial-pitem.
1838 ;;
1846 name
1848 type
1852 "Helper function for `js--splice-into-items'.
1853 Return a new item that is the result of merging CHILD into
1854 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1855 that we haven't consumed yet."
1860 ;; If the item we're merging into isn't a class, make it into one
1866 ;; Use the child's class-style if it's available
1868 js--dummy-class-style
1873 ;; Now we can merge either a function or a class into a class
1877 ;; if we have more name-parts to go before we get to the
1878 ;; bottom of the class hierarchy, call the merger
1879 ;; recursively
1885 ;; Not merging a class, but something else, so just prepend
1886 ;; it
1890 ;; Otherwise, merge the new child's items into those
1891 ;; of the new class
1897 "Last part of the name of PITEM, as a string or symbol."
1901 name)))
1904 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1905 If a class doesn't exist in the tree, create it. Return
1906 the new items list. NAME-PARTS is a list of strings given
1907 the broken-down class name of the item to insert."
1911 new-items last-new-item new-cons item)
1914 name-parts
1920 ;; If top-name isn't found in items, then we build a copy of items
1921 ;; and throw it away. But that's okay, since most of the time, we
1922 ;; *will* find an instance.
1926 ;; Okay, we found an entry with the right name. Splice
1927 ;; the merged item into the list...
1930 name-parts)
1937 ;; ...and terminate the loop
1938 nil)
1941 ;; Otherwise, copy the current cons and move onto the
1942 ;; text. This is tricky; we keep track of the tail of
1943 ;; the list that begins with new-items in
1944 ;; last-new-item.
1951 ;; Go to the next cell in items
1955 ;; Yay! We stopped because we found something, not because
1956 ;; we ran out of items to search. Just return the new
1957 ;; list.
1960 new-items)
1962 ;; We didn't find anything. If the child is a class and we don't
1963 ;; have any classes to drill down into, just push that class;
1964 ;; otherwise, make a fake class and carry on.
1967 ;; We have name-parts left to process. Make a fake
1968 ;; class for this particular part...
1970 ;; ...and recursively digest the rest of the name
1973 :type js--dummy-class-style
1976 ;; Otherwise, this is the only name we have, so stick
1977 ;; the item on the front of the list
1978 child)
1979 items))))
1982 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
1987 t))
1989 ;; This trick works because we know (based on our defstructs) that
1990 ;; the child list is always the first element, and so the second
1991 ;; element and beyond can be shared when we make our "copy".
1998 ;; Use slow path because we need class lookup
2004 ;; Use slow path because we need class merging. We know
2005 ;; name is a list here because down in
2006 ;; `js--ensure-cache', we made sure to only add
2007 ;; class entries with lists for :name
2012 ;; Fast path
2018 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2021 location))
2024 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2041 imenu-items))
2046 unknown-ctr))
2049 imenu-items))
2058 imenu-items))))
2062 imenu-items))
2065 "Return an imenu index for the current buffer."
2077 ;; Make sure everything is closed
2085 ;; Convert the new-finalized state into what imenu expects
2088 unknown-ctr))))))
2090 ;; Silence the compiler.
2101 symbols)
2102 else
2113 "Return a hash table of all JavaScript symbols.
2114 This searches all existing `js-mode' buffers. Each key is the
2115 name of a symbol (possibly disambiguated with <N>, where N > 1),
2116 and each value is a marker giving the location of that symbol."
2118 with imenu-use-markers = t
2119 for buffer being the buffers
2124 finally return symbols))
2130 "Helper function for `js-find-symbol'.
2131 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2132 one from `js--get-all-known-symbols', using prompt PROMPT and
2133 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2134 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2135 marker."
2141 prompt
2143 collect key)
2158 "Read a JavaScript symbol and jump to it.
2159 With a prefix argument, restrict symbols to those from the
2160 current buffer. Pushes a mark onto the tag ring just like
2161 `find-tag'."
2171 symbols "Jump to: "
2179 ;;; MozRepl integration
2189 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2190 On timeout, return nil. On success, return t with match data
2191 set. If START is non-nil, look for output starting from START.
2192 Otherwise, use the current value of `process-mark'."
2204 'js-moz-bad-rpc
2208 ;; Integer, mirrors the value we see in JS
2211 ;; Process to which this thing belongs
2232 ; */" Make Emacs happy
2233 "(function(repl) {
2234 repl.defineInteractor('js', {
2235 onStart: function onStart(repl) {
2236 if(!repl._jsObjects) {
2237 repl._jsObjects = {};
2238 repl._jsLastID = 0;
2239 repl._jsGC = this._jsGC;
2240 }
2241 this._input = '';
2242 },
2244 _jsGC: function _jsGC(ids_in_use) {
2245 var objects = this._jsObjects;
2246 var keys = [];
2247 var num_freed = 0;
2249 for(var pn in objects) {
2250 keys.push(Number(pn));
2251 }
2253 keys.sort(function(x, y) x - y);
2254 ids_in_use.sort(function(x, y) x - y);
2255 var i = 0;
2256 var j = 0;
2258 while(i < ids_in_use.length && j < keys.length) {
2259 var id = ids_in_use[i++];
2260 while(j < keys.length && keys[j] !== id) {
2261 var k_id = keys[j++];
2262 delete objects[k_id];
2263 ++num_freed;
2264 }
2265 ++j;
2266 }
2268 while(j < keys.length) {
2269 var k_id = keys[j++];
2270 delete objects[k_id];
2271 ++num_freed;
2272 }
2274 return num_freed;
2275 },
2277 _mkArray: function _mkArray() {
2278 var result = [];
2279 for(var i = 0; i < arguments.length; ++i) {
2280 result.push(arguments[i]);
2281 }
2282 return result;
2283 },
2285 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2286 if(typeof parts === 'string') {
2287 parts = [ parts ];
2288 }
2290 var obj = parts[0];
2291 var start = 1;
2293 if(typeof obj === 'string') {
2294 obj = window;
2295 start = 0;
2296 } else if(parts.length < 2) {
2297 throw new Error('expected at least 2 arguments');
2298 }
2300 for(var i = start; i < parts.length - 1; ++i) {
2301 obj = obj[parts[i]];
2302 }
2304 return [obj, parts[parts.length - 1]];
2305 },
2307 _getProp: function _getProp(/*...*/) {
2308 if(arguments.length === 0) {
2309 throw new Error('no arguments supplied to getprop');
2310 }
2312 if(arguments.length === 1 &&
2313 (typeof arguments[0]) !== 'string')
2314 {
2315 return arguments[0];
2316 }
2318 var [obj, propname] = this._parsePropDescriptor(arguments);
2319 return obj[propname];
2320 },
2322 _putProp: function _putProp(properties, value) {
2323 var [obj, propname] = this._parsePropDescriptor(properties);
2324 obj[propname] = value;
2325 },
2327 _delProp: function _delProp(propname) {
2328 var [obj, propname] = this._parsePropDescriptor(arguments);
2329 delete obj[propname];
2330 },
2332 _typeOf: function _typeOf(thing) {
2333 return typeof thing;
2334 },
2336 _callNew: function(constructor) {
2337 if(typeof constructor === 'string')
2338 {
2339 constructor = window[constructor];
2340 } else if(constructor.length === 1 &&
2341 typeof constructor[0] !== 'string')
2342 {
2343 constructor = constructor[0];
2344 } else {
2345 var [obj,propname] = this._parsePropDescriptor(constructor);
2346 constructor = obj[propname];
2347 }
2349 /* Hacky, but should be robust */
2350 var s = 'new constructor(';
2351 for(var i = 1; i < arguments.length; ++i) {
2352 if(i != 1) {
2353 s += ',';
2354 }
2356 s += 'arguments[' + i + ']';
2357 }
2359 s += ')';
2360 return eval(s);
2361 },
2363 _callEval: function(thisobj, js) {
2364 return eval.call(thisobj, js);
2365 },
2367 getPrompt: function getPrompt(repl) {
2368 return 'EVAL>'
2369 },
2371 _lookupObject: function _lookupObject(repl, id) {
2372 if(typeof id === 'string') {
2373 switch(id) {
2374 case 'global':
2375 return window;
2376 case 'nil':
2377 return null;
2378 case 't':
2379 return true;
2380 case 'false':
2381 return false;
2382 case 'undefined':
2383 return undefined;
2384 case 'repl':
2385 return repl;
2386 case 'interactor':
2387 return this;
2388 case 'NaN':
2389 return NaN;
2390 case 'Infinity':
2391 return Infinity;
2392 case '-Infinity':
2393 return -Infinity;
2394 default:
2395 throw new Error('No object with special id:' + id);
2396 }
2397 }
2399 var ret = repl._jsObjects[id];
2400 if(ret === undefined) {
2401 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2402 }
2403 return ret;
2404 },
2406 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2407 if(typeof value !== 'object' && typeof value !== 'function') {
2408 throw new Error('_findOrAllocateObject called on non-object('
2409 + typeof(value) + '): '
2410 + value)
2411 }
2413 for(var id in repl._jsObjects) {
2414 id = Number(id);
2415 var obj = repl._jsObjects[id];
2416 if(obj === value) {
2417 return id;
2418 }
2419 }
2421 var id = ++repl._jsLastID;
2422 repl._jsObjects[id] = value;
2423 return id;
2424 },
2426 _fixupList: function _fixupList(repl, list) {
2427 for(var i = 0; i < list.length; ++i) {
2428 if(list[i] instanceof Array) {
2429 this._fixupList(repl, list[i]);
2430 } else if(typeof list[i] === 'object') {
2431 var obj = list[i];
2432 if(obj.funcall) {
2433 var parts = obj.funcall;
2434 this._fixupList(repl, parts);
2435 var [thisobj, func] = this._parseFunc(parts[0]);
2436 list[i] = func.apply(thisobj, parts.slice(1));
2437 } else if(obj.objid) {
2438 list[i] = this._lookupObject(repl, obj.objid);
2439 } else {
2440 throw new Error('Unknown object type: ' + obj.toSource());
2441 }
2442 }
2443 }
2444 },
2446 _parseFunc: function(func) {
2447 var thisobj = null;
2449 if(typeof func === 'string') {
2450 func = window[func];
2451 } else if(func instanceof Array) {
2452 if(func.length === 1 && typeof func[0] !== 'string') {
2453 func = func[0];
2454 } else {
2455 [thisobj, func] = this._parsePropDescriptor(func);
2456 func = thisobj[func];
2457 }
2458 }
2460 return [thisobj,func];
2461 },
2463 _encodeReturn: function(value, array_as_mv) {
2464 var ret;
2466 if(value === null) {
2467 ret = ['special', 'null'];
2468 } else if(value === true) {
2469 ret = ['special', 'true'];
2470 } else if(value === false) {
2471 ret = ['special', 'false'];
2472 } else if(value === undefined) {
2473 ret = ['special', 'undefined'];
2474 } else if(typeof value === 'number') {
2475 if(isNaN(value)) {
2476 ret = ['special', 'NaN'];
2477 } else if(value === Infinity) {
2478 ret = ['special', 'Infinity'];
2479 } else if(value === -Infinity) {
2480 ret = ['special', '-Infinity'];
2481 } else {
2482 ret = ['atom', value];
2483 }
2484 } else if(typeof value === 'string') {
2485 ret = ['atom', value];
2486 } else if(array_as_mv && value instanceof Array) {
2487 ret = ['array', value.map(this._encodeReturn, this)];
2488 } else {
2489 ret = ['objid', this._findOrAllocateObject(repl, value)];
2490 }
2492 return ret;
2493 },
2495 _handleInputLine: function _handleInputLine(repl, line) {
2496 var ret;
2497 var array_as_mv = false;
2499 try {
2500 if(line[0] === '*') {
2501 array_as_mv = true;
2502 line = line.substring(1);
2503 }
2504 var parts = eval(line);
2505 this._fixupList(repl, parts);
2506 var [thisobj, func] = this._parseFunc(parts[0]);
2507 ret = this._encodeReturn(
2508 func.apply(thisobj, parts.slice(1)),
2509 array_as_mv);
2510 } catch(x) {
2511 ret = ['error', x.toString() ];
2512 }
2514 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2515 repl.print(JSON.encode(ret));
2516 repl._prompt();
2517 },
2519 handleInput: function handleInput(repl, chunk) {
2520 this._input += chunk;
2521 var match, line;
2523 line = match[0];
2526 repl.popInteractor();
2527 repl._prompt();
2528 return;
2529 }
2531 this._input = this._input.substring(line.length);
2532 this._handleInputLine(repl, line);
2533 }
2534 }
2535 });
2536 })
2542 "Marshall the given value for JS.
2543 Strings and numbers are JSON-encoded. Lists (including nil) are
2544 made into JavaScript array literals and their contents encoded
2545 with `js--js-encode-value'."
2572 js--js-repl-prompt-regexp js-js-timeout
2574 ;; start matching against the beginning of the line in
2575 ;; order to catch a prompt that's only partially arrived
2583 ;; Do some initialization the first time we see a process
2589 ;; Send interactor definition
2595 js-js-timeout))
2597 ;; Sanity check
2603 ;; If js--js-repl-depth > 0, we *should* be seeing an
2604 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2605 ;; up with us.
2608 ;; Otherwise, tell Mozilla to enter the interactor mode
2614 js-js-timeout))
2628 js-js-timeout))))
2638 "Convert immediate js< and js! references to deferred ones."
2662 function))
2664 else
2665 collect item)))
2680 "Run FORMS with the Mozilla repl set up for js commands.
2681 Inside the lexical scope of `with-js', `js?', `js!',
2682 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2683 `js-create-instance', and `js-qi' are defined."
2694 function)
2702 function)
2734 props)
2736 ))
2742 "Whether to listify any Array returned by a Mozilla function.
2753 js--js-references)
2758 js--js-references)))
2763 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2764 If function is a string, look it up as a property on the global
2765 object and use the global object for `this'.
2766 If FUNCTION is a list with one element, use that element as the
2767 function with the global object for `this', except that if that
2768 single element is a string, look it up on the global object.
2769 If FUNCTION is a list with more than one argument, use the list
2770 up to the last value as a property descriptor and the last
2771 argument as a function."
2778 ;; Actual funcall
2785 js-js-timeout)
2788 ;; Read the result
2795 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2796 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2799 constructor arguments))
2805 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2808 arguments)))
2817 "Tell the repl about any objects we don't reference anymore.
2818 With argument, run even if no intervening GC has happened."
2829 ;; Don't bother running unless we've had an intervening
2830 ;; garbage collection; without a gc, nothing is deleted
2831 ;; from the weak hash table, so it's pointless telling
2832 ;; MozRepl about that references we still hold
2835 ;; Are we looking at a normal prompt? Make sure not to
2836 ;; interrupt the user if he's doing something
2844 of js--js-references
2845 collect x))
2852 num)))
2857 "Evaluate the JavaScript in JS and return JSON-decoded result."
2865 result)))
2868 "Enumerate all JavaScript contexts available.
2869 Each context is a list:
2870 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2871 (TITLE URL WINDOW) for windows
2873 All tabs of a given window are grouped together. The most recent
2874 window is first. Within each window, the tabs are returned
2875 left-to-right."
2880 "@mozilla.org/appshell/window-mediator;1"
2902 window)
2909 "browsers"
2910 x
2911 "contentDocument"
2915 "browsers"
2916 x
2917 "contentWindow"
2918 "location"
2921 "browsers"
2922 x)
2925 "tabContainer"
2926 "childNodes"
2928 x)
2930 gbrowser))))))
2935 "Read a Mozilla tab with prompt PROMPT.
2936 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2937 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2938 browser, respectively."
2940 ;; Prime IDO
2947 selected-tab prev-hitab)
2949 ;; Disambiguate names
2951 for tab in tabs
2967 ;; Hack to reduce the number of
2968 ;; round-trips to mozilla
2971 ;; Highlighting tab
2974 "style"
2976 cmds)
2978 ;; Highlight window proper
2981 "style"
2983 cmds)
2985 ;; Select tab, when appropriate
2989 cmds)))
2991 ;; Hilighting whole window
2995 "style"
2998 cmds)))
3001 ;; Unhighlighting tab
3004 cmds)
3006 cmds))
3008 ;; Unhighlighting window
3013 cmds)))
3019 ()
3025 ()
3026 ;; Fiddle with the match list a bit: if our first match
3027 ;; is a tabbrowser window, rotate the match list until
3028 ;; the active tab comes up
3034 "document"
3035 "documentElement"
3040 "gBrowser"
3044 for match in ido-matches
3048 and return t)))
3058 prompt
3060 nil t nil
3078 "Helper function for `js-eval-defun'.
3079 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3080 strings making up the class name and NAME is the name of the
3081 function part."
3100 "The current JavaScript context.
3101 This is a cons like the one returned from `js--read-tab'.
3105 "(function(func_info,func) {
3106 func_info.unshift('window');
3107 var obj = window;
3108 for(var i = 1; i < func_info.length - 1; ++i) {
3109 var next = obj[func_info[i]];
3110 if(typeof next !== 'object' && typeof next !== 'function') {
3111 next = obj.prototype && obj.prototype[func_info[i]];
3112 if(typeof next !== 'object' && typeof next !== 'function') {
3113 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3114 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3115 return;
3116 }
3118 func_info.splice(i+1, 0, 'prototype');
3119 ++i;
3120 }
3121 }
3123 obj[func_info[i]] = func;
3124 alert('Successfully updated '+func_info.join('.'));
3128 "Set the JavaScript context to CONTEXT.
3129 When called interactively, prompt for CONTEXT."
3134 "Return a valid JavaScript context.
3135 If one hasn't been set, or if it's stale, prompt for a new one."
3144 js--js-context))
3158 file)))
3171 "Update a Mozilla tab using the JavaScript defun at point."
3174 ;; This function works by generating a temporary file that contains
3175 ;; the function we'd like to insert. We then use the elisp-js bridge
3176 ;; to command mozilla to load this file by inserting a script tag
3177 ;; into the document we set. This way, debuggers and such will have
3178 ;; a way to find the source of the just-inserted function.
3179 ;;
3180 ;; We delete the temporary file if there's an error, but otherwise
3181 ;; we add an unload event listener on the Mozilla side to delete the
3182 ;; file.
3213 ;; (Re)register a Mozilla resource URL to point to the
3214 ;; temporary directory
3232 ;; Give Mozilla responsibility for deleting this file
3237 ;; Regular content
3241 ;; Chrome
3263 ))
3265 ;; temp-name is set to nil on success
3269 ;;; Main Function
3271 ;;;###autoload
3273 "Major mode for editing JavaScript.
3275 Key bindings:
3280 :syntax-table js-mode-syntax-table
3291 nil nil nil nil
3293 . js-font-lock-syntactic-keywords)))
3300 ;; Comments
3306 ;; Parse cache
3309 ;; Frameworks
3312 ;; Imenu
3320 ;; for filling, pretend we're cc-mode
3322 c-paragraph-start "$"
3323 c-paragraph-separate "$"
3324 c-block-comment-prefix "* "
3325 c-line-comment-starter "//"
3330 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3331 ;; we call it instead? (Bug#6071)
3342 ;; Important to fontify the whole buffer syntactically! If we don't,
3343 ;; then we might have regular expression literals that aren't marked
3344 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3345 ;; etc. and and produce maddening "unbalanced parenthesis" errors.
3346 ;; When we attempt to find the error and scroll to the portion of
3347 ;; the buffer containing the problem, JIT-lock will apply the
3348 ;; correct syntax to the regular expresion literal and the problem
3349 ;; will mysteriously disappear.
3355 ;;;###autoload
3364 ;; arch-tag: 1a0d0409-e87f-4fc7-a58c-3731c66ddaac
3365 ;; js.el ends here