| blob | 8c8d0553cfa72cade6405e1ff3eb865862baeabf |
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 "Treat nested functions as top-level functions in `js-mode'.
441 This applies to function movement, marking, and so on."
446 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
451 "Frameworks recognized by `js-mode'.
452 To improve performance, you may turn off some frameworks you
453 seldom use, either globally or on a per-buffer basis."
456 js--available-frameworks))
461 "Whether `js-mode' should display tabs while selecting them.
462 This is useful only if the windowing system has a good mechanism
463 for preventing Firefox from stealing the keyboard focus."
468 "~/.emacs.d/js/js"
469 "Temporary directory used by `js-mode' to communicate with Mozilla.
470 This directory must be readable and writable by both Mozilla and
471 Emacs."
476 "Reply timeout for executing commands in Mozilla via `js-mode'.
477 The value is given in seconds. Increase this value if you are
478 getting timeout messages."
482 ;;; KeyMap
498 keymap)
501 ;;; Syntax table and parsing
507 table)
538 "Helper function for `js--update-quick-match-re'.
539 If LIST contains any element that is not nil, return its non-nil
540 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
541 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
542 nil. If any element in LIST is itself a list, flatten that
543 element."
549 "Internal function used by `js-mode' for caching buffer constructs.
550 This updates `js--quick-match-re', based on the current set of
551 enabled frameworks."
556 ;; #define mumble
565 ;; var mumble = THING (
586 ;; mumble.prototypeTHING
594 ;; mumble.prototype = {
601 "Move over the next value of PROPNAME in the buffer.
602 If found, return that value and leave point after the character
603 having that value; otherwise, return nil and leave point at EOB."
614 next-value))
617 "Move over the previous value of PROPNAME in the buffer.
618 If found, return that value and leave point just before the
619 character that has that value, otherwise return nil and leave
620 point at BOB."
633 prev-value)))
646 "Helper function for `js--re-search-forward'."
648 str-terminator
677 "Search forward, ignoring strings, cpp macros, and comments.
678 This function invokes `re-search-forward', but treats the buffer
679 as if strings, cpp macros, and comments have been removed.
681 If invoked while inside a macro, it treats the contents of the
682 macro as normal text."
700 "Auxiliary function for `js--re-search-backward'."
702 str-terminator
733 "Search backward, ignoring strings, preprocessor macros, and comments.
735 This function invokes `re-search-backward' but treats the buffer
736 as if strings, preprocessor macros, and comments have been
737 removed.
739 If invoked while inside a macro, treat the macro as normal text."
756 "Move forward over a whole JavaScript expression.
757 This function doesn't move over expressions continued across
758 lines."
760 ;; non-continued case; simplistic, but good enough?
773 "Move forward over a JavaScript function declaration.
774 This puts point at the 'function' keyword.
776 If this is a syntactically-correct non-expression function,
777 return the name of the function, or t if the name could not be
778 determined. Otherwise, return nil."
791 name)))))
794 "Return the start of the JavaScript function prologue containing POS.
795 A function prologue is everything from start of the definition up
796 to and including the opening brace. POS defaults to point.
797 If POS is not in a function prologue, return nil."
824 "Helper function for `js-beginning-of-defun'.
825 Go to previous defun-beginning and return the parse state for it,
826 or nil if we went all the way back to bob and don't find
827 anything."
835 "Helper function for `js--beginning-of-defun-nested'.
836 If PSTATE represents a non-empty top-level defun, return the
837 top-most pitem. Otherwise, return nil."
840 with func-pitem
847 "Helper function for `js--beginning-of-defun'.
848 Return the pitem of the function we went to the beginning of."
850 ;; Look for the smallest function that encloses point...
855 and return pitem)
857 ;; ...and if that isn't found, look for the previous top-level
858 ;; defun
860 while pstate
863 and return it)))
866 "Helper function for `js-beginning-of-defun'."
872 "Value of `beginning-of-defun-function' for `js-mode'."
888 ;; If we're just past the end of a function, the user probably wants
889 ;; to go to the beginning of *that* function
903 "Flush the `js-mode' syntax cache after position BEG.
904 BEG defaults to `point-min', meaning to flush the entire cache."
910 ;; `(message ,@arguments)
911 )
920 ;; open-items must contain at least two items for this to
921 ;; work, but because we push a dummy item to start with,
922 ;; that assumption holds.
925 open-items)
928 "Helper function for `js--ensure-cache'.
929 Update parsing information up to point, referring to parse,
930 prev-parse-point, goal-point, and open-items bound lexically in
931 the body of `js--ensure-cache'."
938 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
939 ;; the given depth -- i.e., make sure we're deeper than the target
940 ;; depth.
944 prev-parse-point goal-point
946 nil parse))
948 ;; (let ((overlay (make-overlay prev-parse-point (point))))
949 ;; (overlay-put overlay 'face '(:background "red"))
950 ;; (unwind-protect
951 ;; (progn
952 ;; (js--debug "parsed: %S" parse)
953 ;; (sit-for 1))
954 ;; (delete-overlay overlay)))
970 "Split a JavaScript name into its dot-separated parts.
971 This also removes any prototype parts from the split name
983 "Guess the name of the JavaScript function at POSITION.
985 Return the name of the function, or nil if the name could not be
986 guessed.
988 This function clobbers match data. If we find the preamble
989 begins earlier than expected while guessing the function name,
990 set `js--guess-function-name-start' to that position; otherwise,
991 set that variable to nil."
1008 ;; Clear any endings that occur after point
1015 ;; Remove any cache properties after this point
1020 "Ensures brace cache is valid up to the character before LIMIT.
1021 LIMIT defaults to point."
1027 orig-match-start
1028 orig-match-end
1029 orig-depth
1030 parse
1031 prev-parse-point
1032 name
1033 case-fold-search
1034 filtered-class-styles
1035 new-item
1036 goal-point
1037 end-prop)
1039 ;; Figure out which class styles we need to look for
1043 js-enabled-frameworks)
1044 collect style))
1050 ;; Find last known good position
1066 ;; Make a placeholder for the top-level definition
1082 ;; Each of these conditions should return non-nil if
1083 ;; we should add a new item and leave point at the end
1084 ;; of the new item's header (h-end in the
1085 ;; js--pitem diagram). This point is the one
1086 ;; after the last character we need to unambiguously
1087 ;; detect this construct. If one of these evaluates to
1088 ;; nil, the location of the point is ignored.
1090 ;; In comment or string
1093 ;; Regular function declaration
1102 js--guess-function-name-start))
1109 :paren-depth orig-depth
1110 :h-begin orig-match-start
1113 name
1116 ;; Macro
1119 ;; Macros often contain unbalanced parentheses.
1120 ;; Make sure that h-end is at the textual end of
1121 ;; the macro no matter what the parenthesis say.
1127 :h-begin orig-match-start
1131 ;; "Prototype function" declaration
1138 :paren-depth orig-depth
1139 :h-begin orig-match-start
1145 ;; Class definition
1148 for class-style in filtered-class-styles
1154 and return
1156 :paren-depth orig-depth
1157 :h-begin orig-match-start
1158 :type class-style
1173 )))))
1176 "Helper function for `js-end-of-defun'."
1181 return t
1185 "Helper function for `js-end-of-defun'."
1194 found)
1197 ;; We're already inside a function; just go to its end.
1200 ;; Otherwise, go to the end of the next function...
1207 ;; ... or eob.
1211 "Value of `end-of-defun-function' for `js-mode'."
1222 ;; look for function backward. if we're inside it, go to that
1223 ;; function's end. otherwise, search for the next function's end and
1224 ;; go there
1228 ;; if we're doing nested functions, see whether we're in the
1229 ;; prologue. If we are, go to the end of the function; otherwise,
1230 ;; call js--end-of-defun-nested to do the real work
1251 t
1253 nil))))
1256 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1267 pos
1271 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1281 pos
1284 ;; Like (up-list -1), but only considers lists that end nearby"
1287 ;; Look at a very small region so our compuation time doesn't
1288 ;; explode in pathological cases.
1293 "Return non-nil iff point is in a function parameter list."
1304 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1326 ;;; Font Lock
1328 "Helper function for building `js--font-lock-keywords'.
1329 Create a byte-compiled function for matching a concatenation of
1330 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1341 "Move forward over a JavaScript destructuring spec.
1342 If FUNC is supplied, call it with no arguments before every
1343 variable name in the spec. Return true iff this was actually a
1344 spec. FUNC must preserve the match data."
1356 t)
1361 t))))
1364 t))
1378 t))
1383 t)))))
1386 t))))
1389 "Font-lock matcher for variable names in a variable declaration.
1390 This is a cc-mode-style matcher that *always* fails, from the
1391 point of view of font-lock. It applies highlighting directly with
1392 `font-lock-apply-highlight'."
1404 t))
1426 ;; Conditions to handle
1430 ;; Matcher always "fails"
1431 nil)
1434 `(
1435 ;; This goes before keywords-2 so it gets used preferentially
1436 ;; instead of the keywords in keywords-2. Don't use override
1437 ;; because that will override syntactic fontification too, which
1438 ;; will fontify commented-out directives as if they weren't
1439 ;; commented out.
1442 ,@js--font-lock-keywords-2
1447 ;; Highlights class being declared, in parts
1451 nil
1454 ;; Highlights parent class, in parts, if available
1471 ;; Highlights parent class
1475 ;; Dojo needs its own matcher to override the string highlighting
1477 'dojo
1484 ;; Match Dojo base classes. Of course Mojo has to be different
1485 ;; from everything else under the sun...
1487 'dojo
1496 ;; continued Dojo base-class list
1498 'dojo
1509 ;; variable declarations
1514 ;; class instantiation
1519 ;; instanceof
1524 ;; formal parameters
1528 js--name-start-re)
1534 ;; continued formal parameter list
1548 "Return whether point is inside the given pitem's header or body."
1558 "Parse the JavaScript program state at point.
1559 Return a list of `js--pitem' instances that apply to point, most
1560 specific first. In the worst case, the current toplevel instance
1561 will be returned."
1571 ;; Loop until we either hit a pitem at BOB or pitem ends after
1572 ;; point (or at point if we're at eob)
1579 pstate))))
1582 "Return the JavaScript syntactic context corresponding to PSTATE."
1585 type)
1591 "Return the JavaScript syntactic context at point.
1592 When called interatively, also display a message with that
1593 context."
1601 syntactic-context))
1604 "Font lock function used by `js-mode'.
1605 This performs fontification according to `js--class-styles'."
1613 js-enabled-frameworks)
1616 decl-re
1619 and return t)
1620 return t
1625 js--font-lock-keywords-2
1626 js--font-lock-keywords-3)
1629 ;; XXX: Javascript can continue a regexp literal across lines so long
1630 ;; as the newline is escaped with \. Account for that in the regexp
1631 ;; below.
1634 "Regexp matching a JavaScript regular expression literal.
1635 Match groups 1 and 2 are the characters forming the beginning and
1638 ;; we want to match regular expressions only at the beginning of
1639 ;; expressions
1642 "Syntactic font lock keywords matching regexps in JavaScript.
1645 ;;; Indentation
1660 "Return non-nil if point is on a JavaScript operator, other than a comma."
1670 "Return non-nil if the current line continues an expression."
1687 Otherwise, return nil. A braceless do-while statement spanning
1688 several lines requires that the start of the loop is indented to
1689 the same column as the current line."
1711 "Helper function for `js--proper-indentation'.
1712 Return the proper indentation of the current line if it starts
1713 the body of a control statement without braces; otherwise, return
1714 nil."
1738 "Return the proper indentation for the current line."
1761 js-expr-indent-offset))
1774 "Indent the current line as JavaScript."
1784 ;;; Filling
1787 "Fill the paragraph with `c-fill-paragraph'."
1801 ;;; Type database and Imenu
1803 ;; We maintain a cache of semantic information, i.e., the classes and
1804 ;; functions we've encountered so far. In order to avoid having to
1805 ;; re-parse the buffer on every change, we cache the parse state at
1806 ;; each interesting point in the buffer. Each parse state is a
1807 ;; modified copy of the previous one, or in the case of the first
1808 ;; parse state, the empty state.
1809 ;;
1810 ;; The parse state itself is just a stack of js--pitem
1811 ;; instances. It starts off containing one element that is never
1812 ;; closed, that is initially js--initial-pitem.
1813 ;;
1821 name
1823 type
1827 "Helper function for `js--splice-into-items'.
1828 Return a new item that is the result of merging CHILD into
1829 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1830 that we haven't consumed yet."
1835 ;; If the item we're merging into isn't a class, make it into one
1841 ;; Use the child's class-style if it's available
1843 js--dummy-class-style
1848 ;; Now we can merge either a function or a class into a class
1852 ;; if we have more name-parts to go before we get to the
1853 ;; bottom of the class hierarchy, call the merger
1854 ;; recursively
1860 ;; Not merging a class, but something else, so just prepend
1861 ;; it
1865 ;; Otherwise, merge the new child's items into those
1866 ;; of the new class
1872 "Last part of the name of PITEM, as a string or symbol."
1876 name)))
1879 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1880 If a class doesn't exist in the tree, create it. Return
1881 the new items list. NAME-PARTS is a list of strings given
1882 the broken-down class name of the item to insert."
1886 new-items last-new-item new-cons item)
1889 name-parts
1895 ;; If top-name isn't found in items, then we build a copy of items
1896 ;; and throw it away. But that's okay, since most of the time, we
1897 ;; *will* find an instance.
1901 ;; Okay, we found an entry with the right name. Splice
1902 ;; the merged item into the list...
1905 name-parts)
1912 ;; ...and terminate the loop
1913 nil)
1916 ;; Otherwise, copy the current cons and move onto the
1917 ;; text. This is tricky; we keep track of the tail of
1918 ;; the list that begins with new-items in
1919 ;; last-new-item.
1926 ;; Go to the next cell in items
1930 ;; Yay! We stopped because we found something, not because
1931 ;; we ran out of items to search. Just return the new
1932 ;; list.
1935 new-items)
1937 ;; We didn't find anything. If the child is a class and we don't
1938 ;; have any classes to drill down into, just push that class;
1939 ;; otherwise, make a fake class and carry on.
1942 ;; We have name-parts left to process. Make a fake
1943 ;; class for this particular part...
1945 ;; ...and recursively digest the rest of the name
1948 :type js--dummy-class-style
1951 ;; Otherwise, this is the only name we have, so stick
1952 ;; the item on the front of the list
1953 child)
1954 items))))
1957 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
1962 t))
1964 ;; This trick works because we know (based on our defstructs) that
1965 ;; the child list is always the first element, and so the second
1966 ;; element and beyond can be shared when we make our "copy".
1973 ;; Use slow path because we need class lookup
1979 ;; Use slow path because we need class merging. We know
1980 ;; name is a list here because down in
1981 ;; `js--ensure-cache', we made sure to only add
1982 ;; class entries with lists for :name
1987 ;; Fast path
1993 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
1996 location))
1999 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2016 imenu-items))
2021 unknown-ctr))
2024 imenu-items))
2033 imenu-items))))
2037 imenu-items))
2040 "Return an imenu index for the current buffer."
2052 ;; Make sure everything is closed
2060 ;; Convert the new-finalized state into what imenu expects
2063 unknown-ctr))))))
2065 ;; Silence the compiler.
2076 symbols)
2077 else
2088 "Return a hash table of all JavaScript symbols.
2089 This searches all existing `js-mode' buffers. Each key is the
2090 name of a symbol (possibly disambiguated with <N>, where N > 1),
2091 and each value is a marker giving the location of that symbol."
2093 with imenu-use-markers = t
2094 for buffer being the buffers
2099 finally return symbols))
2105 "Helper function for `js-find-symbol'.
2106 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2107 one from `js--get-all-known-symbols', using prompt PROMPT and
2108 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2109 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2110 marker."
2116 prompt
2118 collect key)
2133 "Read a JavaScript symbol and jump to it.
2134 With a prefix argument, restrict symbols to those from the
2135 current buffer. Pushes a mark onto the tag ring just like
2136 `find-tag'."
2146 symbols "Jump to: "
2154 ;;; MozRepl integration
2164 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2165 On timeout, return nil. On success, return t with match data
2166 set. If START is non-nil, look for output starting from START.
2167 Otherwise, use the current value of `process-mark'."
2179 'js-moz-bad-rpc
2183 ;; Integer, mirrors the value we see in JS
2186 ;; Process to which this thing belongs
2207 ; */" Make Emacs happy
2208 "(function(repl) {
2209 repl.defineInteractor('js', {
2210 onStart: function onStart(repl) {
2211 if(!repl._jsObjects) {
2212 repl._jsObjects = {};
2213 repl._jsLastID = 0;
2214 repl._jsGC = this._jsGC;
2215 }
2216 this._input = '';
2217 },
2219 _jsGC: function _jsGC(ids_in_use) {
2220 var objects = this._jsObjects;
2221 var keys = [];
2222 var num_freed = 0;
2224 for(var pn in objects) {
2225 keys.push(Number(pn));
2226 }
2228 keys.sort(function(x, y) x - y);
2229 ids_in_use.sort(function(x, y) x - y);
2230 var i = 0;
2231 var j = 0;
2233 while(i < ids_in_use.length && j < keys.length) {
2234 var id = ids_in_use[i++];
2235 while(j < keys.length && keys[j] !== id) {
2236 var k_id = keys[j++];
2237 delete objects[k_id];
2238 ++num_freed;
2239 }
2240 ++j;
2241 }
2243 while(j < keys.length) {
2244 var k_id = keys[j++];
2245 delete objects[k_id];
2246 ++num_freed;
2247 }
2249 return num_freed;
2250 },
2252 _mkArray: function _mkArray() {
2253 var result = [];
2254 for(var i = 0; i < arguments.length; ++i) {
2255 result.push(arguments[i]);
2256 }
2257 return result;
2258 },
2260 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2261 if(typeof parts === 'string') {
2262 parts = [ parts ];
2263 }
2265 var obj = parts[0];
2266 var start = 1;
2268 if(typeof obj === 'string') {
2269 obj = window;
2270 start = 0;
2271 } else if(parts.length < 2) {
2272 throw new Error('expected at least 2 arguments');
2273 }
2275 for(var i = start; i < parts.length - 1; ++i) {
2276 obj = obj[parts[i]];
2277 }
2279 return [obj, parts[parts.length - 1]];
2280 },
2282 _getProp: function _getProp(/*...*/) {
2283 if(arguments.length === 0) {
2284 throw new Error('no arguments supplied to getprop');
2285 }
2287 if(arguments.length === 1 &&
2288 (typeof arguments[0]) !== 'string')
2289 {
2290 return arguments[0];
2291 }
2293 var [obj, propname] = this._parsePropDescriptor(arguments);
2294 return obj[propname];
2295 },
2297 _putProp: function _putProp(properties, value) {
2298 var [obj, propname] = this._parsePropDescriptor(properties);
2299 obj[propname] = value;
2300 },
2302 _delProp: function _delProp(propname) {
2303 var [obj, propname] = this._parsePropDescriptor(arguments);
2304 delete obj[propname];
2305 },
2307 _typeOf: function _typeOf(thing) {
2308 return typeof thing;
2309 },
2311 _callNew: function(constructor) {
2312 if(typeof constructor === 'string')
2313 {
2314 constructor = window[constructor];
2315 } else if(constructor.length === 1 &&
2316 typeof constructor[0] !== 'string')
2317 {
2318 constructor = constructor[0];
2319 } else {
2320 var [obj,propname] = this._parsePropDescriptor(constructor);
2321 constructor = obj[propname];
2322 }
2324 /* Hacky, but should be robust */
2325 var s = 'new constructor(';
2326 for(var i = 1; i < arguments.length; ++i) {
2327 if(i != 1) {
2328 s += ',';
2329 }
2331 s += 'arguments[' + i + ']';
2332 }
2334 s += ')';
2335 return eval(s);
2336 },
2338 _callEval: function(thisobj, js) {
2339 return eval.call(thisobj, js);
2340 },
2342 getPrompt: function getPrompt(repl) {
2343 return 'EVAL>'
2344 },
2346 _lookupObject: function _lookupObject(repl, id) {
2347 if(typeof id === 'string') {
2348 switch(id) {
2349 case 'global':
2350 return window;
2351 case 'nil':
2352 return null;
2353 case 't':
2354 return true;
2355 case 'false':
2356 return false;
2357 case 'undefined':
2358 return undefined;
2359 case 'repl':
2360 return repl;
2361 case 'interactor':
2362 return this;
2363 case 'NaN':
2364 return NaN;
2365 case 'Infinity':
2366 return Infinity;
2367 case '-Infinity':
2368 return -Infinity;
2369 default:
2370 throw new Error('No object with special id:' + id);
2371 }
2372 }
2374 var ret = repl._jsObjects[id];
2375 if(ret === undefined) {
2376 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2377 }
2378 return ret;
2379 },
2381 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2382 if(typeof value !== 'object' && typeof value !== 'function') {
2383 throw new Error('_findOrAllocateObject called on non-object('
2384 + typeof(value) + '): '
2385 + value)
2386 }
2388 for(var id in repl._jsObjects) {
2389 id = Number(id);
2390 var obj = repl._jsObjects[id];
2391 if(obj === value) {
2392 return id;
2393 }
2394 }
2396 var id = ++repl._jsLastID;
2397 repl._jsObjects[id] = value;
2398 return id;
2399 },
2401 _fixupList: function _fixupList(repl, list) {
2402 for(var i = 0; i < list.length; ++i) {
2403 if(list[i] instanceof Array) {
2404 this._fixupList(repl, list[i]);
2405 } else if(typeof list[i] === 'object') {
2406 var obj = list[i];
2407 if(obj.funcall) {
2408 var parts = obj.funcall;
2409 this._fixupList(repl, parts);
2410 var [thisobj, func] = this._parseFunc(parts[0]);
2411 list[i] = func.apply(thisobj, parts.slice(1));
2412 } else if(obj.objid) {
2413 list[i] = this._lookupObject(repl, obj.objid);
2414 } else {
2415 throw new Error('Unknown object type: ' + obj.toSource());
2416 }
2417 }
2418 }
2419 },
2421 _parseFunc: function(func) {
2422 var thisobj = null;
2424 if(typeof func === 'string') {
2425 func = window[func];
2426 } else if(func instanceof Array) {
2427 if(func.length === 1 && typeof func[0] !== 'string') {
2428 func = func[0];
2429 } else {
2430 [thisobj, func] = this._parsePropDescriptor(func);
2431 func = thisobj[func];
2432 }
2433 }
2435 return [thisobj,func];
2436 },
2438 _encodeReturn: function(value, array_as_mv) {
2439 var ret;
2441 if(value === null) {
2442 ret = ['special', 'null'];
2443 } else if(value === true) {
2444 ret = ['special', 'true'];
2445 } else if(value === false) {
2446 ret = ['special', 'false'];
2447 } else if(value === undefined) {
2448 ret = ['special', 'undefined'];
2449 } else if(typeof value === 'number') {
2450 if(isNaN(value)) {
2451 ret = ['special', 'NaN'];
2452 } else if(value === Infinity) {
2453 ret = ['special', 'Infinity'];
2454 } else if(value === -Infinity) {
2455 ret = ['special', '-Infinity'];
2456 } else {
2457 ret = ['atom', value];
2458 }
2459 } else if(typeof value === 'string') {
2460 ret = ['atom', value];
2461 } else if(array_as_mv && value instanceof Array) {
2462 ret = ['array', value.map(this._encodeReturn, this)];
2463 } else {
2464 ret = ['objid', this._findOrAllocateObject(repl, value)];
2465 }
2467 return ret;
2468 },
2470 _handleInputLine: function _handleInputLine(repl, line) {
2471 var ret;
2472 var array_as_mv = false;
2474 try {
2475 if(line[0] === '*') {
2476 array_as_mv = true;
2477 line = line.substring(1);
2478 }
2479 var parts = eval(line);
2480 this._fixupList(repl, parts);
2481 var [thisobj, func] = this._parseFunc(parts[0]);
2482 ret = this._encodeReturn(
2483 func.apply(thisobj, parts.slice(1)),
2484 array_as_mv);
2485 } catch(x) {
2486 ret = ['error', x.toString() ];
2487 }
2489 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2490 repl.print(JSON.encode(ret));
2491 repl._prompt();
2492 },
2494 handleInput: function handleInput(repl, chunk) {
2495 this._input += chunk;
2496 var match, line;
2498 line = match[0];
2501 repl.popInteractor();
2502 repl._prompt();
2503 return;
2504 }
2506 this._input = this._input.substring(line.length);
2507 this._handleInputLine(repl, line);
2508 }
2509 }
2510 });
2511 })
2517 "Marshall the given value for JS.
2518 Strings and numbers are JSON-encoded. Lists (including nil) are
2519 made into JavaScript array literals and their contents encoded
2520 with `js--js-encode-value'."
2547 js--js-repl-prompt-regexp js-js-timeout
2549 ;; start matching against the beginning of the line in
2550 ;; order to catch a prompt that's only partially arrived
2558 ;; Do some initialization the first time we see a process
2564 ;; Send interactor definition
2570 js-js-timeout))
2572 ;; Sanity check
2578 ;; If js--js-repl-depth > 0, we *should* be seeing an
2579 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2580 ;; up with us.
2583 ;; Otherwise, tell Mozilla to enter the interactor mode
2589 js-js-timeout))
2603 js-js-timeout))))
2613 "Convert immediate js< and js! references to deferred ones."
2637 function))
2639 else
2640 collect item)))
2655 "Run FORMS with the Mozilla repl set up for js commands.
2656 Inside the lexical scope of `with-js', `js?', `js!',
2657 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2658 `js-create-instance', and `js-qi' are defined."
2669 function)
2677 function)
2709 props)
2711 ))
2717 "Whether to listify any Array returned by a Mozilla function.
2728 js--js-references)
2733 js--js-references)))
2738 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2739 If function is a string, look it up as a property on the global
2740 object and use the global object for `this'.
2741 If FUNCTION is a list with one element, use that element as the
2742 function with the global object for `this', except that if that
2743 single element is a string, look it up on the global object.
2744 If FUNCTION is a list with more than one argument, use the list
2745 up to the last value as a property descriptor and the last
2746 argument as a function."
2753 ;; Actual funcall
2760 js-js-timeout)
2763 ;; Read the result
2770 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2771 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2774 constructor arguments))
2780 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2783 arguments)))
2792 "Tell the repl about any objects we don't reference anymore.
2793 With argument, run even if no intervening GC has happened."
2804 ;; Don't bother running unless we've had an intervening
2805 ;; garbage collection; without a gc, nothing is deleted
2806 ;; from the weak hash table, so it's pointless telling
2807 ;; MozRepl about that references we still hold
2810 ;; Are we looking at a normal prompt? Make sure not to
2811 ;; interrupt the user if he's doing something
2819 of js--js-references
2820 collect x))
2827 num)))
2832 "Evaluate the JavaScript in JS and return JSON-decoded result."
2840 result)))
2843 "Enumerate all JavaScript contexts available.
2844 Each context is a list:
2845 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2846 (TITLE URL WINDOW) for windows
2848 All tabs of a given window are grouped together. The most recent
2849 window is first. Within each window, the tabs are returned
2850 left-to-right."
2855 "@mozilla.org/appshell/window-mediator;1"
2877 window)
2884 "browsers"
2885 x
2886 "contentDocument"
2890 "browsers"
2891 x
2892 "contentWindow"
2893 "location"
2896 "browsers"
2897 x)
2900 "tabContainer"
2901 "childNodes"
2903 x)
2905 gbrowser))))))
2910 "Read a Mozilla tab with prompt PROMPT.
2911 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2912 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2913 browser, respectively."
2915 ;; Prime IDO
2922 selected-tab prev-hitab)
2924 ;; Disambiguate names
2926 for tab in tabs
2942 ;; Hack to reduce the number of
2943 ;; round-trips to mozilla
2946 ;; Highlighting tab
2949 "style"
2951 cmds)
2953 ;; Highlight window proper
2956 "style"
2958 cmds)
2960 ;; Select tab, when appropriate
2964 cmds)))
2966 ;; Hilighting whole window
2970 "style"
2973 cmds)))
2976 ;; Unhighlighting tab
2979 cmds)
2981 cmds))
2983 ;; Unhighlighting window
2988 cmds)))
2994 ()
3000 ()
3001 ;; Fiddle with the match list a bit: if our first match
3002 ;; is a tabbrowser window, rotate the match list until
3003 ;; the active tab comes up
3009 "document"
3010 "documentElement"
3015 "gBrowser"
3019 for match in ido-matches
3023 and return t)))
3033 prompt
3035 nil t nil
3053 "Helper function for `js-eval-defun'.
3054 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3055 strings making up the class name and NAME is the name of the
3056 function part."
3075 "The current JavaScript context.
3076 This is a cons like the one returned from `js--read-tab'.
3080 "(function(func_info,func) {
3081 func_info.unshift('window');
3082 var obj = window;
3083 for(var i = 1; i < func_info.length - 1; ++i) {
3084 var next = obj[func_info[i]];
3085 if(typeof next !== 'object' && typeof next !== 'function') {
3086 next = obj.prototype && obj.prototype[func_info[i]];
3087 if(typeof next !== 'object' && typeof next !== 'function') {
3088 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3089 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3090 return;
3091 }
3093 func_info.splice(i+1, 0, 'prototype');
3094 ++i;
3095 }
3096 }
3098 obj[func_info[i]] = func;
3099 alert('Successfully updated '+func_info.join('.'));
3103 "Set the JavaScript context to CONTEXT.
3104 When called interactively, prompt for CONTEXT."
3109 "Return a valid JavaScript context.
3110 If one hasn't been set, or if it's stale, prompt for a new one."
3119 js--js-context))
3133 file)))
3146 "Update a Mozilla tab using the JavaScript defun at point."
3149 ;; This function works by generating a temporary file that contains
3150 ;; the function we'd like to insert. We then use the elisp-js bridge
3151 ;; to command mozilla to load this file by inserting a script tag
3152 ;; into the document we set. This way, debuggers and such will have
3153 ;; a way to find the source of the just-inserted function.
3154 ;;
3155 ;; We delete the temporary file if there's an error, but otherwise
3156 ;; we add an unload event listener on the Mozilla side to delete the
3157 ;; file.
3188 ;; (Re)register a Mozilla resource URL to point to the
3189 ;; temporary directory
3207 ;; Give Mozilla responsibility for deleting this file
3212 ;; Regular content
3216 ;; Chrome
3238 ))
3240 ;; temp-name is set to nil on success
3244 ;;; Main Function
3246 ;;;###autoload
3248 "Major mode for editing JavaScript.
3250 Key bindings:
3255 :syntax-table js-mode-syntax-table
3266 nil nil nil nil
3268 . js-font-lock-syntactic-keywords)))
3275 ;; Comments
3281 ;; Parse cache
3284 ;; Frameworks
3287 ;; Imenu
3295 ;; for filling, pretend we're cc-mode
3297 c-paragraph-start "$"
3298 c-paragraph-separate "$"
3299 c-block-comment-prefix "* "
3300 c-line-comment-starter "//"
3310 ;; Important to fontify the whole buffer syntactically! If we don't,
3311 ;; then we might have regular expression literals that aren't marked
3312 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3313 ;; etc. and and produce maddening "unbalanced parenthesis" errors.
3314 ;; When we attempt to find the error and scroll to the portion of
3315 ;; the buffer containing the problem, JIT-lock will apply the
3316 ;; correct syntax to the regular expresion literal and the problem
3317 ;; will mysteriously disappear.
3323 ;;;###autoload
3332 ;; arch-tag: 1a0d0409-e87f-4fc7-a58c-3731c66ddaac
3333 ;; js.el ends here