| blob | 60ed14afbaca6e34921db8df26a7106750f84b2c |
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 Emacs."
482 "Reply timeout for executing commands in Mozilla via `js-mode'.
483 The value is given in seconds. Increase this value if you are
484 getting timeout messages."
488 ;;; KeyMap
507 keymap)
511 "Run the command bound to KEY, and indent if necessary.
512 Indentation does not take place if point is in a string or
513 comment."
518 js-auto-indent-flag)
525 ;;; Syntax table and parsing
531 table)
562 "Helper function for `js--update-quick-match-re'.
563 If LIST contains any element that is not nil, return its non-nil
564 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
565 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
566 nil. If any element in LIST is itself a list, flatten that
567 element."
573 "Internal function used by `js-mode' for caching buffer constructs.
574 This updates `js--quick-match-re', based on the current set of
575 enabled frameworks."
580 ;; #define mumble
589 ;; var mumble = THING (
610 ;; mumble.prototypeTHING
618 ;; mumble.prototype = {
625 "Move over the next value of PROPNAME in the buffer.
626 If found, return that value and leave point after the character
627 having that value; otherwise, return nil and leave point at EOB."
638 next-value))
641 "Move over the previous value of PROPNAME in the buffer.
642 If found, return that value and leave point just before the
643 character that has that value, otherwise return nil and leave
644 point at BOB."
657 prev-value)))
670 "Helper function for `js--re-search-forward'."
672 str-terminator
701 "Search forward, ignoring strings, cpp macros, and comments.
702 This function invokes `re-search-forward', but treats the buffer
703 as if strings, cpp macros, and comments have been removed.
705 If invoked while inside a macro, it treats the contents of the
706 macro as normal text."
724 "Auxiliary function for `js--re-search-backward'."
726 str-terminator
757 "Search backward, ignoring strings, preprocessor macros, and comments.
759 This function invokes `re-search-backward' but treats the buffer
760 as if strings, preprocessor macros, and comments have been
761 removed.
763 If invoked while inside a macro, treat the macro as normal text."
780 "Move forward over a whole JavaScript expression.
781 This function doesn't move over expressions continued across
782 lines."
784 ;; non-continued case; simplistic, but good enough?
797 "Move forward over a JavaScript function declaration.
798 This puts point at the 'function' keyword.
800 If this is a syntactically-correct non-expression function,
801 return the name of the function, or t if the name could not be
802 determined. Otherwise, return nil."
815 name)))))
818 "Return the start of the JavaScript function prologue containing POS.
819 A function prologue is everything from start of the definition up
820 to and including the opening brace. POS defaults to point.
821 If POS is not in a function prologue, return nil."
848 "Helper function for `js-beginning-of-defun'.
849 Go to previous defun-beginning and return the parse state for it,
850 or nil if we went all the way back to bob and don't find
851 anything."
859 "Helper function for `js--beginning-of-defun-nested'.
860 If PSTATE represents a non-empty top-level defun, return the
861 top-most pitem. Otherwise, return nil."
864 with func-pitem
871 "Helper function for `js--beginning-of-defun'.
872 Return the pitem of the function we went to the beginning of."
874 ;; Look for the smallest function that encloses point...
879 and return pitem)
881 ;; ...and if that isn't found, look for the previous top-level
882 ;; defun
884 while pstate
887 and return it)))
890 "Helper function for `js-beginning-of-defun'."
896 "Value of `beginning-of-defun-function' for `js-mode'."
912 ;; If we're just past the end of a function, the user probably wants
913 ;; to go to the beginning of *that* function
927 "Flush the `js-mode' syntax cache after position BEG.
928 BEG defaults to `point-min', meaning to flush the entire cache."
934 ;; `(message ,@arguments)
935 )
944 ;; open-items must contain at least two items for this to
945 ;; work, but because we push a dummy item to start with,
946 ;; that assumption holds.
949 open-items)
952 "Helper function for `js--ensure-cache'.
953 Update parsing information up to point, referring to parse,
954 prev-parse-point, goal-point, and open-items bound lexically in
955 the body of `js--ensure-cache'."
962 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
963 ;; the given depth -- i.e., make sure we're deeper than the target
964 ;; depth.
968 prev-parse-point goal-point
970 nil parse))
972 ;; (let ((overlay (make-overlay prev-parse-point (point))))
973 ;; (overlay-put overlay 'face '(:background "red"))
974 ;; (unwind-protect
975 ;; (progn
976 ;; (js--debug "parsed: %S" parse)
977 ;; (sit-for 1))
978 ;; (delete-overlay overlay)))
994 "Split a JavaScript name into its dot-separated parts.
995 This also removes any prototype parts from the split name
1007 "Guess the name of the JavaScript function at POSITION.
1009 Return the name of the function, or nil if the name could not be
1010 guessed.
1012 This function clobbers match data. If we find the preamble
1013 begins earlier than expected while guessing the function name,
1014 set `js--guess-function-name-start' to that position; otherwise,
1015 set that variable to nil."
1032 ;; Clear any endings that occur after point
1039 ;; Remove any cache properties after this point
1044 "Ensures brace cache is valid up to the character before LIMIT.
1045 LIMIT defaults to point."
1051 orig-match-start
1052 orig-match-end
1053 orig-depth
1054 parse
1055 prev-parse-point
1056 name
1057 case-fold-search
1058 filtered-class-styles
1059 new-item
1060 goal-point
1061 end-prop)
1063 ;; Figure out which class styles we need to look for
1067 js-enabled-frameworks)
1068 collect style))
1074 ;; Find last known good position
1090 ;; Make a placeholder for the top-level definition
1106 ;; Each of these conditions should return non-nil if
1107 ;; we should add a new item and leave point at the end
1108 ;; of the new item's header (h-end in the
1109 ;; js--pitem diagram). This point is the one
1110 ;; after the last character we need to unambiguously
1111 ;; detect this construct. If one of these evaluates to
1112 ;; nil, the location of the point is ignored.
1114 ;; In comment or string
1117 ;; Regular function declaration
1126 js--guess-function-name-start))
1133 :paren-depth orig-depth
1134 :h-begin orig-match-start
1137 name
1140 ;; Macro
1143 ;; Macros often contain unbalanced parentheses.
1144 ;; Make sure that h-end is at the textual end of
1145 ;; the macro no matter what the parenthesis say.
1151 :h-begin orig-match-start
1155 ;; "Prototype function" declaration
1162 :paren-depth orig-depth
1163 :h-begin orig-match-start
1169 ;; Class definition
1172 for class-style in filtered-class-styles
1178 and return
1180 :paren-depth orig-depth
1181 :h-begin orig-match-start
1182 :type class-style
1197 )))))
1200 "Helper function for `js-end-of-defun'."
1205 return t
1209 "Helper function for `js-end-of-defun'."
1218 found)
1221 ;; We're already inside a function; just go to its end.
1224 ;; Otherwise, go to the end of the next function...
1231 ;; ... or eob.
1235 "Value of `end-of-defun-function' for `js-mode'."
1246 ;; look for function backward. if we're inside it, go to that
1247 ;; function's end. otherwise, search for the next function's end and
1248 ;; go there
1252 ;; if we're doing nested functions, see whether we're in the
1253 ;; prologue. If we are, go to the end of the function; otherwise,
1254 ;; call js--end-of-defun-nested to do the real work
1275 t
1277 nil))))
1280 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1291 pos
1295 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1305 pos
1308 ;; Like (up-list -1), but only considers lists that end nearby"
1311 ;; Look at a very small region so our compuation time doesn't
1312 ;; explode in pathological cases.
1317 "Return non-nil iff point is in a function parameter list."
1328 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1350 ;;; Font Lock
1352 "Helper function for building `js--font-lock-keywords'.
1353 Create a byte-compiled function for matching a concatenation of
1354 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1365 "Move forward over a JavaScript destructuring spec.
1366 If FUNC is supplied, call it with no arguments before every
1367 variable name in the spec. Return true iff this was actually a
1368 spec. FUNC must preserve the match data."
1380 t)
1385 t))))
1388 t))
1402 t))
1407 t)))))
1410 t))))
1413 "Font-lock matcher for variable names in a variable declaration.
1414 This is a cc-mode-style matcher that *always* fails, from the
1415 point of view of font-lock. It applies highlighting directly with
1416 `font-lock-apply-highlight'."
1428 t))
1450 ;; Conditions to handle
1454 ;; Matcher always "fails"
1455 nil)
1458 `(
1459 ;; This goes before keywords-2 so it gets used preferentially
1460 ;; instead of the keywords in keywords-2. Don't use override
1461 ;; because that will override syntactic fontification too, which
1462 ;; will fontify commented-out directives as if they weren't
1463 ;; commented out.
1466 ,@js--font-lock-keywords-2
1471 ;; Highlights class being declared, in parts
1475 nil
1478 ;; Highlights parent class, in parts, if available
1495 ;; Highlights parent class
1499 ;; Dojo needs its own matcher to override the string highlighting
1501 'dojo
1508 ;; Match Dojo base classes. Of course Mojo has to be different
1509 ;; from everything else under the sun...
1511 'dojo
1520 ;; continued Dojo base-class list
1522 'dojo
1533 ;; variable declarations
1538 ;; class instantiation
1543 ;; instanceof
1548 ;; formal parameters
1552 js--name-start-re)
1558 ;; continued formal parameter list
1572 "Return whether point is inside the given pitem's header or body."
1582 "Parse the JavaScript program state at point.
1583 Return a list of `js--pitem' instances that apply to point, most
1584 specific first. In the worst case, the current toplevel instance
1585 will be returned."
1595 ;; Loop until we either hit a pitem at BOB or pitem ends after
1596 ;; point (or at point if we're at eob)
1603 pstate))))
1606 "Return the JavaScript syntactic context corresponding to PSTATE."
1609 type)
1615 "Return the JavaScript syntactic context at point.
1616 When called interatively, also display a message with that
1617 context."
1625 syntactic-context))
1628 "Font lock function used by `js-mode'.
1629 This performs fontification according to `js--class-styles'."
1637 js-enabled-frameworks)
1640 decl-re
1643 and return t)
1644 return t
1649 js--font-lock-keywords-2
1650 js--font-lock-keywords-3)
1653 ;; XXX: Javascript can continue a regexp literal across lines so long
1654 ;; as the newline is escaped with \. Account for that in the regexp
1655 ;; below.
1658 "Regexp matching a JavaScript regular expression literal.
1659 Match groups 1 and 2 are the characters forming the beginning and
1662 ;; we want to match regular expressions only at the beginning of
1663 ;; expressions
1666 "Syntactic font lock keywords matching regexps in JavaScript.
1669 ;;; Indentation
1684 "Return non-nil if point is on a JavaScript operator, other than a comma."
1694 "Return non-nil if the current line continues an expression."
1711 Otherwise, return nil. A braceless do-while statement spanning
1712 several lines requires that the start of the loop is indented to
1713 the same column as the current line."
1735 "Helper function for `js--proper-indentation'.
1736 Return the proper indentation of the current line if it starts
1737 the body of a control statement without braces; otherwise, return
1738 nil."
1762 "Return the proper indentation for the current line."
1785 js-expr-indent-offset))
1798 "Indent the current line as JavaScript."
1808 ;;; Filling
1811 "Fill the paragraph with `c-fill-paragraph'."
1825 ;;; Type database and Imenu
1827 ;; We maintain a cache of semantic information, i.e., the classes and
1828 ;; functions we've encountered so far. In order to avoid having to
1829 ;; re-parse the buffer on every change, we cache the parse state at
1830 ;; each interesting point in the buffer. Each parse state is a
1831 ;; modified copy of the previous one, or in the case of the first
1832 ;; parse state, the empty state.
1833 ;;
1834 ;; The parse state itself is just a stack of js--pitem
1835 ;; instances. It starts off containing one element that is never
1836 ;; closed, that is initially js--initial-pitem.
1837 ;;
1845 name
1847 type
1851 "Helper function for `js--splice-into-items'.
1852 Return a new item that is the result of merging CHILD into
1853 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1854 that we haven't consumed yet."
1859 ;; If the item we're merging into isn't a class, make it into one
1865 ;; Use the child's class-style if it's available
1867 js--dummy-class-style
1872 ;; Now we can merge either a function or a class into a class
1876 ;; if we have more name-parts to go before we get to the
1877 ;; bottom of the class hierarchy, call the merger
1878 ;; recursively
1884 ;; Not merging a class, but something else, so just prepend
1885 ;; it
1889 ;; Otherwise, merge the new child's items into those
1890 ;; of the new class
1896 "Last part of the name of PITEM, as a string or symbol."
1900 name)))
1903 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1904 If a class doesn't exist in the tree, create it. Return
1905 the new items list. NAME-PARTS is a list of strings given
1906 the broken-down class name of the item to insert."
1910 new-items last-new-item new-cons item)
1913 name-parts
1919 ;; If top-name isn't found in items, then we build a copy of items
1920 ;; and throw it away. But that's okay, since most of the time, we
1921 ;; *will* find an instance.
1925 ;; Okay, we found an entry with the right name. Splice
1926 ;; the merged item into the list...
1929 name-parts)
1936 ;; ...and terminate the loop
1937 nil)
1940 ;; Otherwise, copy the current cons and move onto the
1941 ;; text. This is tricky; we keep track of the tail of
1942 ;; the list that begins with new-items in
1943 ;; last-new-item.
1950 ;; Go to the next cell in items
1954 ;; Yay! We stopped because we found something, not because
1955 ;; we ran out of items to search. Just return the new
1956 ;; list.
1959 new-items)
1961 ;; We didn't find anything. If the child is a class and we don't
1962 ;; have any classes to drill down into, just push that class;
1963 ;; otherwise, make a fake class and carry on.
1966 ;; We have name-parts left to process. Make a fake
1967 ;; class for this particular part...
1969 ;; ...and recursively digest the rest of the name
1972 :type js--dummy-class-style
1975 ;; Otherwise, this is the only name we have, so stick
1976 ;; the item on the front of the list
1977 child)
1978 items))))
1981 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
1986 t))
1988 ;; This trick works because we know (based on our defstructs) that
1989 ;; the child list is always the first element, and so the second
1990 ;; element and beyond can be shared when we make our "copy".
1997 ;; Use slow path because we need class lookup
2003 ;; Use slow path because we need class merging. We know
2004 ;; name is a list here because down in
2005 ;; `js--ensure-cache', we made sure to only add
2006 ;; class entries with lists for :name
2011 ;; Fast path
2017 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2020 location))
2023 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2040 imenu-items))
2045 unknown-ctr))
2048 imenu-items))
2057 imenu-items))))
2061 imenu-items))
2064 "Return an imenu index for the current buffer."
2076 ;; Make sure everything is closed
2084 ;; Convert the new-finalized state into what imenu expects
2087 unknown-ctr))))))
2089 ;; Silence the compiler.
2100 symbols)
2101 else
2112 "Return a hash table of all JavaScript symbols.
2113 This searches all existing `js-mode' buffers. Each key is the
2114 name of a symbol (possibly disambiguated with <N>, where N > 1),
2115 and each value is a marker giving the location of that symbol."
2117 with imenu-use-markers = t
2118 for buffer being the buffers
2123 finally return symbols))
2129 "Helper function for `js-find-symbol'.
2130 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2131 one from `js--get-all-known-symbols', using prompt PROMPT and
2132 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2133 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2134 marker."
2140 prompt
2142 collect key)
2157 "Read a JavaScript symbol and jump to it.
2158 With a prefix argument, restrict symbols to those from the
2159 current buffer. Pushes a mark onto the tag ring just like
2160 `find-tag'."
2170 symbols "Jump to: "
2178 ;;; MozRepl integration
2188 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2189 On timeout, return nil. On success, return t with match data
2190 set. If START is non-nil, look for output starting from START.
2191 Otherwise, use the current value of `process-mark'."
2203 'js-moz-bad-rpc
2207 ;; Integer, mirrors the value we see in JS
2210 ;; Process to which this thing belongs
2231 ; */" Make Emacs happy
2232 "(function(repl) {
2233 repl.defineInteractor('js', {
2234 onStart: function onStart(repl) {
2235 if(!repl._jsObjects) {
2236 repl._jsObjects = {};
2237 repl._jsLastID = 0;
2238 repl._jsGC = this._jsGC;
2239 }
2240 this._input = '';
2241 },
2243 _jsGC: function _jsGC(ids_in_use) {
2244 var objects = this._jsObjects;
2245 var keys = [];
2246 var num_freed = 0;
2248 for(var pn in objects) {
2249 keys.push(Number(pn));
2250 }
2252 keys.sort(function(x, y) x - y);
2253 ids_in_use.sort(function(x, y) x - y);
2254 var i = 0;
2255 var j = 0;
2257 while(i < ids_in_use.length && j < keys.length) {
2258 var id = ids_in_use[i++];
2259 while(j < keys.length && keys[j] !== id) {
2260 var k_id = keys[j++];
2261 delete objects[k_id];
2262 ++num_freed;
2263 }
2264 ++j;
2265 }
2267 while(j < keys.length) {
2268 var k_id = keys[j++];
2269 delete objects[k_id];
2270 ++num_freed;
2271 }
2273 return num_freed;
2274 },
2276 _mkArray: function _mkArray() {
2277 var result = [];
2278 for(var i = 0; i < arguments.length; ++i) {
2279 result.push(arguments[i]);
2280 }
2281 return result;
2282 },
2284 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2285 if(typeof parts === 'string') {
2286 parts = [ parts ];
2287 }
2289 var obj = parts[0];
2290 var start = 1;
2292 if(typeof obj === 'string') {
2293 obj = window;
2294 start = 0;
2295 } else if(parts.length < 2) {
2296 throw new Error('expected at least 2 arguments');
2297 }
2299 for(var i = start; i < parts.length - 1; ++i) {
2300 obj = obj[parts[i]];
2301 }
2303 return [obj, parts[parts.length - 1]];
2304 },
2306 _getProp: function _getProp(/*...*/) {
2307 if(arguments.length === 0) {
2308 throw new Error('no arguments supplied to getprop');
2309 }
2311 if(arguments.length === 1 &&
2312 (typeof arguments[0]) !== 'string')
2313 {
2314 return arguments[0];
2315 }
2317 var [obj, propname] = this._parsePropDescriptor(arguments);
2318 return obj[propname];
2319 },
2321 _putProp: function _putProp(properties, value) {
2322 var [obj, propname] = this._parsePropDescriptor(properties);
2323 obj[propname] = value;
2324 },
2326 _delProp: function _delProp(propname) {
2327 var [obj, propname] = this._parsePropDescriptor(arguments);
2328 delete obj[propname];
2329 },
2331 _typeOf: function _typeOf(thing) {
2332 return typeof thing;
2333 },
2335 _callNew: function(constructor) {
2336 if(typeof constructor === 'string')
2337 {
2338 constructor = window[constructor];
2339 } else if(constructor.length === 1 &&
2340 typeof constructor[0] !== 'string')
2341 {
2342 constructor = constructor[0];
2343 } else {
2344 var [obj,propname] = this._parsePropDescriptor(constructor);
2345 constructor = obj[propname];
2346 }
2348 /* Hacky, but should be robust */
2349 var s = 'new constructor(';
2350 for(var i = 1; i < arguments.length; ++i) {
2351 if(i != 1) {
2352 s += ',';
2353 }
2355 s += 'arguments[' + i + ']';
2356 }
2358 s += ')';
2359 return eval(s);
2360 },
2362 _callEval: function(thisobj, js) {
2363 return eval.call(thisobj, js);
2364 },
2366 getPrompt: function getPrompt(repl) {
2367 return 'EVAL>'
2368 },
2370 _lookupObject: function _lookupObject(repl, id) {
2371 if(typeof id === 'string') {
2372 switch(id) {
2373 case 'global':
2374 return window;
2375 case 'nil':
2376 return null;
2377 case 't':
2378 return true;
2379 case 'false':
2380 return false;
2381 case 'undefined':
2382 return undefined;
2383 case 'repl':
2384 return repl;
2385 case 'interactor':
2386 return this;
2387 case 'NaN':
2388 return NaN;
2389 case 'Infinity':
2390 return Infinity;
2391 case '-Infinity':
2392 return -Infinity;
2393 default:
2394 throw new Error('No object with special id:' + id);
2395 }
2396 }
2398 var ret = repl._jsObjects[id];
2399 if(ret === undefined) {
2400 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2401 }
2402 return ret;
2403 },
2405 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2406 if(typeof value !== 'object' && typeof value !== 'function') {
2407 throw new Error('_findOrAllocateObject called on non-object('
2408 + typeof(value) + '): '
2409 + value)
2410 }
2412 for(var id in repl._jsObjects) {
2413 id = Number(id);
2414 var obj = repl._jsObjects[id];
2415 if(obj === value) {
2416 return id;
2417 }
2418 }
2420 var id = ++repl._jsLastID;
2421 repl._jsObjects[id] = value;
2422 return id;
2423 },
2425 _fixupList: function _fixupList(repl, list) {
2426 for(var i = 0; i < list.length; ++i) {
2427 if(list[i] instanceof Array) {
2428 this._fixupList(repl, list[i]);
2429 } else if(typeof list[i] === 'object') {
2430 var obj = list[i];
2431 if(obj.funcall) {
2432 var parts = obj.funcall;
2433 this._fixupList(repl, parts);
2434 var [thisobj, func] = this._parseFunc(parts[0]);
2435 list[i] = func.apply(thisobj, parts.slice(1));
2436 } else if(obj.objid) {
2437 list[i] = this._lookupObject(repl, obj.objid);
2438 } else {
2439 throw new Error('Unknown object type: ' + obj.toSource());
2440 }
2441 }
2442 }
2443 },
2445 _parseFunc: function(func) {
2446 var thisobj = null;
2448 if(typeof func === 'string') {
2449 func = window[func];
2450 } else if(func instanceof Array) {
2451 if(func.length === 1 && typeof func[0] !== 'string') {
2452 func = func[0];
2453 } else {
2454 [thisobj, func] = this._parsePropDescriptor(func);
2455 func = thisobj[func];
2456 }
2457 }
2459 return [thisobj,func];
2460 },
2462 _encodeReturn: function(value, array_as_mv) {
2463 var ret;
2465 if(value === null) {
2466 ret = ['special', 'null'];
2467 } else if(value === true) {
2468 ret = ['special', 'true'];
2469 } else if(value === false) {
2470 ret = ['special', 'false'];
2471 } else if(value === undefined) {
2472 ret = ['special', 'undefined'];
2473 } else if(typeof value === 'number') {
2474 if(isNaN(value)) {
2475 ret = ['special', 'NaN'];
2476 } else if(value === Infinity) {
2477 ret = ['special', 'Infinity'];
2478 } else if(value === -Infinity) {
2479 ret = ['special', '-Infinity'];
2480 } else {
2481 ret = ['atom', value];
2482 }
2483 } else if(typeof value === 'string') {
2484 ret = ['atom', value];
2485 } else if(array_as_mv && value instanceof Array) {
2486 ret = ['array', value.map(this._encodeReturn, this)];
2487 } else {
2488 ret = ['objid', this._findOrAllocateObject(repl, value)];
2489 }
2491 return ret;
2492 },
2494 _handleInputLine: function _handleInputLine(repl, line) {
2495 var ret;
2496 var array_as_mv = false;
2498 try {
2499 if(line[0] === '*') {
2500 array_as_mv = true;
2501 line = line.substring(1);
2502 }
2503 var parts = eval(line);
2504 this._fixupList(repl, parts);
2505 var [thisobj, func] = this._parseFunc(parts[0]);
2506 ret = this._encodeReturn(
2507 func.apply(thisobj, parts.slice(1)),
2508 array_as_mv);
2509 } catch(x) {
2510 ret = ['error', x.toString() ];
2511 }
2513 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2514 repl.print(JSON.encode(ret));
2515 repl._prompt();
2516 },
2518 handleInput: function handleInput(repl, chunk) {
2519 this._input += chunk;
2520 var match, line;
2522 line = match[0];
2525 repl.popInteractor();
2526 repl._prompt();
2527 return;
2528 }
2530 this._input = this._input.substring(line.length);
2531 this._handleInputLine(repl, line);
2532 }
2533 }
2534 });
2535 })
2541 "Marshall the given value for JS.
2542 Strings and numbers are JSON-encoded. Lists (including nil) are
2543 made into JavaScript array literals and their contents encoded
2544 with `js--js-encode-value'."
2571 js--js-repl-prompt-regexp js-js-timeout
2573 ;; start matching against the beginning of the line in
2574 ;; order to catch a prompt that's only partially arrived
2582 ;; Do some initialization the first time we see a process
2588 ;; Send interactor definition
2594 js-js-timeout))
2596 ;; Sanity check
2602 ;; If js--js-repl-depth > 0, we *should* be seeing an
2603 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2604 ;; up with us.
2607 ;; Otherwise, tell Mozilla to enter the interactor mode
2613 js-js-timeout))
2627 js-js-timeout))))
2637 "Convert immediate js< and js! references to deferred ones."
2661 function))
2663 else
2664 collect item)))
2679 "Run FORMS with the Mozilla repl set up for js commands.
2680 Inside the lexical scope of `with-js', `js?', `js!',
2681 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2682 `js-create-instance', and `js-qi' are defined."
2693 function)
2701 function)
2733 props)
2735 ))
2741 "Whether to listify any Array returned by a Mozilla function.
2752 js--js-references)
2757 js--js-references)))
2762 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2763 If function is a string, look it up as a property on the global
2764 object and use the global object for `this'.
2765 If FUNCTION is a list with one element, use that element as the
2766 function with the global object for `this', except that if that
2767 single element is a string, look it up on the global object.
2768 If FUNCTION is a list with more than one argument, use the list
2769 up to the last value as a property descriptor and the last
2770 argument as a function."
2777 ;; Actual funcall
2784 js-js-timeout)
2787 ;; Read the result
2794 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2795 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2798 constructor arguments))
2804 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2807 arguments)))
2816 "Tell the repl about any objects we don't reference anymore.
2817 With argument, run even if no intervening GC has happened."
2828 ;; Don't bother running unless we've had an intervening
2829 ;; garbage collection; without a gc, nothing is deleted
2830 ;; from the weak hash table, so it's pointless telling
2831 ;; MozRepl about that references we still hold
2834 ;; Are we looking at a normal prompt? Make sure not to
2835 ;; interrupt the user if he's doing something
2843 of js--js-references
2844 collect x))
2851 num)))
2856 "Evaluate the JavaScript in JS and return JSON-decoded result."
2864 result)))
2867 "Enumerate all JavaScript contexts available.
2868 Each context is a list:
2869 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2870 (TITLE URL WINDOW) for windows
2872 All tabs of a given window are grouped together. The most recent
2873 window is first. Within each window, the tabs are returned
2874 left-to-right."
2879 "@mozilla.org/appshell/window-mediator;1"
2901 window)
2908 "browsers"
2909 x
2910 "contentDocument"
2914 "browsers"
2915 x
2916 "contentWindow"
2917 "location"
2920 "browsers"
2921 x)
2924 "tabContainer"
2925 "childNodes"
2927 x)
2929 gbrowser))))))
2934 "Read a Mozilla tab with prompt PROMPT.
2935 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2936 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2937 browser, respectively."
2939 ;; Prime IDO
2946 selected-tab prev-hitab)
2948 ;; Disambiguate names
2950 for tab in tabs
2966 ;; Hack to reduce the number of
2967 ;; round-trips to mozilla
2970 ;; Highlighting tab
2973 "style"
2975 cmds)
2977 ;; Highlight window proper
2980 "style"
2982 cmds)
2984 ;; Select tab, when appropriate
2988 cmds)))
2990 ;; Hilighting whole window
2994 "style"
2997 cmds)))
3000 ;; Unhighlighting tab
3003 cmds)
3005 cmds))
3007 ;; Unhighlighting window
3012 cmds)))
3018 ()
3024 ()
3025 ;; Fiddle with the match list a bit: if our first match
3026 ;; is a tabbrowser window, rotate the match list until
3027 ;; the active tab comes up
3033 "document"
3034 "documentElement"
3039 "gBrowser"
3043 for match in ido-matches
3047 and return t)))
3057 prompt
3059 nil t nil
3077 "Helper function for `js-eval-defun'.
3078 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3079 strings making up the class name and NAME is the name of the
3080 function part."
3099 "The current JavaScript context.
3100 This is a cons like the one returned from `js--read-tab'.
3104 "(function(func_info,func) {
3105 func_info.unshift('window');
3106 var obj = window;
3107 for(var i = 1; i < func_info.length - 1; ++i) {
3108 var next = obj[func_info[i]];
3109 if(typeof next !== 'object' && typeof next !== 'function') {
3110 next = obj.prototype && obj.prototype[func_info[i]];
3111 if(typeof next !== 'object' && typeof next !== 'function') {
3112 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3113 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3114 return;
3115 }
3117 func_info.splice(i+1, 0, 'prototype');
3118 ++i;
3119 }
3120 }
3122 obj[func_info[i]] = func;
3123 alert('Successfully updated '+func_info.join('.'));
3127 "Set the JavaScript context to CONTEXT.
3128 When called interactively, prompt for CONTEXT."
3133 "Return a valid JavaScript context.
3134 If one hasn't been set, or if it's stale, prompt for a new one."
3143 js--js-context))
3157 file)))
3170 "Update a Mozilla tab using the JavaScript defun at point."
3173 ;; This function works by generating a temporary file that contains
3174 ;; the function we'd like to insert. We then use the elisp-js bridge
3175 ;; to command mozilla to load this file by inserting a script tag
3176 ;; into the document we set. This way, debuggers and such will have
3177 ;; a way to find the source of the just-inserted function.
3178 ;;
3179 ;; We delete the temporary file if there's an error, but otherwise
3180 ;; we add an unload event listener on the Mozilla side to delete the
3181 ;; file.
3212 ;; (Re)register a Mozilla resource URL to point to the
3213 ;; temporary directory
3231 ;; Give Mozilla responsibility for deleting this file
3236 ;; Regular content
3240 ;; Chrome
3262 ))
3264 ;; temp-name is set to nil on success
3268 ;;; Main Function
3270 ;;;###autoload
3272 "Major mode for editing JavaScript.
3274 Key bindings:
3279 :syntax-table js-mode-syntax-table
3290 nil nil nil nil
3292 . js-font-lock-syntactic-keywords)))
3299 ;; Comments
3305 ;; Parse cache
3308 ;; Frameworks
3311 ;; Imenu
3319 ;; for filling, pretend we're cc-mode
3321 c-paragraph-start "$"
3322 c-paragraph-separate "$"
3323 c-block-comment-prefix "* "
3324 c-line-comment-starter "//"
3329 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3330 ;; we call it instead? (Bug#6071)
3341 ;; Important to fontify the whole buffer syntactically! If we don't,
3342 ;; then we might have regular expression literals that aren't marked
3343 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3344 ;; etc. and and produce maddening "unbalanced parenthesis" errors.
3345 ;; When we attempt to find the error and scroll to the portion of
3346 ;; the buffer containing the problem, JIT-lock will apply the
3347 ;; correct syntax to the regular expresion literal and the problem
3348 ;; will mysteriously disappear.
3354 ;;;###autoload
3363 ;; arch-tag: 1a0d0409-e87f-4fc7-a58c-3731c66ddaac
3364 ;; js.el ends here