| blob | 94a9c250fee77f8d6469b44a45fa61f88c5995a9 |
1 ;;; js.el --- Major mode for editing JavaScript
3 ;; Copyright (C) 2008-2011 Free Software Foundation, Inc.
5 ;; Author: Karl Landstrom <karl.landstrom@brgeight.se>
6 ;; Daniel Colascione <dan.colascione@gmail.com>
7 ;; Maintainer: Daniel Colascione <dan.colascione@gmail.com>
8 ;; Version: 9
9 ;; Date: 2009-07-25
10 ;; Keywords: languages, javascript
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;;; Commentary
29 ;; This is based on Karl Landstrom's barebones javascript-mode. This
30 ;; is much more robust and works with cc-mode's comment filling
31 ;; (mostly).
32 ;;
33 ;; The main features of this JavaScript mode are syntactic
34 ;; highlighting (enabled with `font-lock-mode' or
35 ;; `global-font-lock-mode'), automatic indentation and filling of
36 ;; comments, C preprocessor fontification, and MozRepl integration.
37 ;;
38 ;; General Remarks:
39 ;;
40 ;; XXX: This mode assumes that block comments are not nested inside block
41 ;; XXX: comments
42 ;;
43 ;; Exported names start with "js-"; private names start with
44 ;; "js--".
46 ;;; Code:
68 ;;; Constants
90 "Regexp matching the prefix of a cpp directive.
91 This includes the directive name, or nil in languages without
92 preprocessor support. The first submatch surrounds the directive
99 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
108 ;; var NewClass = BaseClass.extend(
116 ;; var NewClass = Class.create()
132 ;; var NewClass = Class.create({
139 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
140 ;; matched with dedicated font-lock matchers
168 :prototype t
174 :prototype t
190 :prototype t
196 :prototype t
207 :prototype t
221 "List of JavaScript class definition styles.
223 A class definition style is a plist with the following keys:
225 :name is a human-readable name of the class type
227 :class-decl is a regular expression giving the start of the
228 class. Its first group must match the name of its class. If there
229 is a parent class, the second group should match, and it should be
230 the name of the class.
232 If :prototype is present and non-nil, the parser will merge
233 declarations for this constructs with others at the same lexical
234 level that have the same name. Otherwise, multiple definitions
235 will create multiple top-level entries. Don't use :prototype
236 unnecessarily: it has an associated cost in performance.
238 If :strip-prototype is present and non-nil, then if the class
239 name as matched contains
244 for style in js--class-styles
247 collect framework into available-frameworks
248 finally return available-frameworks)
254 "Regexp matching the start of a JavaScript function header.
260 "Regexp matching the start of a function entry in an associative array.
272 "Regexp matching a CPP macro definition, up to the opening parenthesis.
322 ;; js--pitem is the basic building block of the lexical
323 ;; database. When one refers to a real part of the buffer, the region
324 ;; of text to which it refers is split into a conceptual header and
325 ;; body. Consider the (very short) block described by a hypothetical
326 ;; js--pitem:
327 ;;
328 ;; function foo(a,b,c) { return 42; }
329 ;; ^ ^ ^
330 ;; | | |
331 ;; +- h-begin +- h-end +- b-end
332 ;;
333 ;; (Remember that these are buffer positions, and therefore point
334 ;; between characters, not at them. An arrow drawn to a character
335 ;; indicates the corresponding position is between that character and
336 ;; the one immediately preceding it.)
337 ;;
338 ;; The header is the region of text [h-begin, h-end], and is
339 ;; the text needed to unambiguously recognize the start of the
340 ;; construct. If the entire header is not present, the construct is
341 ;; not recognized at all. No other pitems may be nested inside the
342 ;; header.
343 ;;
344 ;; The body is the region [h-end, b-end]. It may contain nested
345 ;; js--pitem instances. The body of a pitem may be empty: in
346 ;; that case, b-end is equal to header-end.
347 ;;
348 ;; The three points obey the following relationship:
349 ;;
350 ;; h-begin < h-end <= b-end
351 ;;
352 ;; We put a text property in the buffer on the character *before*
353 ;; h-end, and if we see it, on the character *before* b-end.
354 ;;
355 ;; The text property for h-end, js--pstate, is actually a list
356 ;; of all js--pitem instances open after the marked character.
357 ;;
358 ;; The text property for b-end, js--pend, is simply the
359 ;; js--pitem that ends after the marked character. (Because
360 ;; pitems always end when the paren-depth drops below a critical
361 ;; value, and because we can only drop one level per character, only
362 ;; one pitem may end at a given character.)
363 ;;
364 ;; In the structure below, we only store h-begin and (sometimes)
365 ;; b-end. We can trivially and quickly find h-end by going to h-begin
366 ;; and searching for an js--pstate text property. Since no other
367 ;; js--pitem instances can be nested inside the header of a
368 ;; pitem, the location after the character with this text property
369 ;; must be h-end.
370 ;;
371 ;; js--pitem instances are never modified (with the exception
372 ;; of the b-end field). Instead, modified copies are added at subseqnce parse points.
373 ;; (The exception for b-end and its caveats is described below.)
374 ;;
377 ;; IMPORTANT: Do not alter the position of fields within the list.
378 ;; Various bits of code depend on their positions, particularly
379 ;; anything that manipulates the list of children.
381 ;; List of children inside this pitem's body
384 ;; When we reach this paren depth after h-end, the pitem ends
387 ;; Symbol or class-style plist if this is a class
390 ;; See above
393 ;; List of strings giving the parts of the name of this pitem (e.g.,
394 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
397 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
398 ;; this pitem: when we copy-and-modify pitem instances, we share
399 ;; their tail structures, so all the copies actually have the same
400 ;; terminating cons cell. We modify that shared cons cell directly.
401 ;;
402 ;; The field value is either a number (buffer location) or nil if
403 ;; unknown.
404 ;;
405 ;; If the field's value is greater than `js--cache-end', the
406 ;; value is stale and must be treated as if it were nil. Conversely,
407 ;; if this field is nil, it is guaranteed that this pitem is open up
408 ;; to at least `js--cache-end'. (This property is handy when
409 ;; computing whether we're inside a given pitem.)
410 ;;
413 ;; The pitem we start parsing with.
416 :paren-depth most-negative-fixnum
419 ;;; User Customization
422 "Customization variables for JavaScript mode."
427 "Number of spaces for each indentation step in `js-mode'."
432 "Number of additional spaces for indenting continued expressions.
433 The value must be no less than minus `js-indent-level'."
438 "Number of additional spaces for indenting expressions in parentheses.
439 The value must be no less than minus `js-indent-level'."
445 "Number of additional spaces for indenting expressions in square braces.
446 The value must be no less than minus `js-indent-level'."
452 "Number of additional spaces for indenting expressions in curly braces.
453 The value must be no less than minus `js-indent-level'."
459 "Whether to automatically indent when typing punctuation characters.
460 If non-nil, the characters {}();,: also indent the current line
461 in Javascript mode."
466 "Treat nested functions as top-level functions in `js-mode'.
467 This applies to function movement, marking, and so on."
472 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
477 "Frameworks recognized by `js-mode'.
478 To improve performance, you may turn off some frameworks you
479 seldom use, either globally or on a per-buffer basis."
482 js--available-frameworks))
487 "Whether `js-mode' should display tabs while selecting them.
488 This is useful only if the windowing system has a good mechanism
489 for preventing Firefox from stealing the keyboard focus."
494 "~/.emacs.d/js/js"
495 "Temporary directory used by `js-mode' to communicate with Mozilla.
496 This directory must be readable and writable by both Mozilla and Emacs."
501 "Reply timeout for executing commands in Mozilla via `js-mode'.
502 The value is given in seconds. Increase this value if you are
503 getting timeout messages."
507 ;;; KeyMap
523 keymap)
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."
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."
767 "Move forward over a whole JavaScript expression.
768 This function doesn't move over expressions continued across
769 lines."
771 ;; non-continued case; simplistic, but good enough?
784 "Move forward over a JavaScript function declaration.
785 This puts point at the 'function' keyword.
787 If this is a syntactically-correct non-expression function,
788 return the name of the function, or t if the name could not be
789 determined. Otherwise, return nil."
802 name)))))
805 "Return the start of the JavaScript function prologue containing POS.
806 A function prologue is everything from start of the definition up
807 to and including the opening brace. POS defaults to point.
808 If POS is not in a function prologue, return nil."
835 "Helper function for `js-beginning-of-defun'.
836 Go to previous defun-beginning and return the parse state for it,
837 or nil if we went all the way back to bob and don't find
838 anything."
846 "Helper function for `js--beginning-of-defun-nested'.
847 If PSTATE represents a non-empty top-level defun, return the
848 top-most pitem. Otherwise, return nil."
851 with func-pitem
858 "Helper function for `js--beginning-of-defun'.
859 Return the pitem of the function we went to the beginning of."
861 ;; Look for the smallest function that encloses point...
866 and return pitem)
868 ;; ...and if that isn't found, look for the previous top-level
869 ;; defun
871 while pstate
874 and return it)))
877 "Helper function for `js-beginning-of-defun'."
883 "Value of `beginning-of-defun-function' for `js-mode'."
899 ;; If we're just past the end of a function, the user probably wants
900 ;; to go to the beginning of *that* function
914 "Flush the `js-mode' syntax cache after position BEG.
915 BEG defaults to `point-min', meaning to flush the entire cache."
921 ;; `(message ,@arguments)
922 )
931 ;; open-items must contain at least two items for this to
932 ;; work, but because we push a dummy item to start with,
933 ;; that assumption holds.
936 open-items)
939 "Helper function for `js--ensure-cache'.
940 Update parsing information up to point, referring to parse,
941 prev-parse-point, goal-point, and open-items bound lexically in
942 the body of `js--ensure-cache'."
949 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
950 ;; the given depth -- i.e., make sure we're deeper than the target
951 ;; depth.
955 prev-parse-point goal-point
957 nil parse))
959 ;; (let ((overlay (make-overlay prev-parse-point (point))))
960 ;; (overlay-put overlay 'face '(:background "red"))
961 ;; (unwind-protect
962 ;; (progn
963 ;; (js--debug "parsed: %S" parse)
964 ;; (sit-for 1))
965 ;; (delete-overlay overlay)))
981 "Split a JavaScript name into its dot-separated parts.
982 This also removes any prototype parts from the split name
994 "Guess the name of the JavaScript function at POSITION.
996 Return the name of the function, or nil if the name could not be
997 guessed.
999 This function clobbers match data. If we find the preamble
1000 begins earlier than expected while guessing the function name,
1001 set `js--guess-function-name-start' to that position; otherwise,
1002 set that variable to nil."
1019 ;; Clear any endings that occur after point
1026 ;; Remove any cache properties after this point
1031 "Ensures brace cache is valid up to the character before LIMIT.
1032 LIMIT defaults to point."
1038 orig-match-start
1039 orig-match-end
1040 orig-depth
1041 parse
1042 prev-parse-point
1043 name
1044 case-fold-search
1045 filtered-class-styles
1046 new-item
1047 goal-point
1048 end-prop)
1050 ;; Figure out which class styles we need to look for
1054 js-enabled-frameworks)
1055 collect style))
1061 ;; Find last known good position
1077 ;; Make a placeholder for the top-level definition
1093 ;; Each of these conditions should return non-nil if
1094 ;; we should add a new item and leave point at the end
1095 ;; of the new item's header (h-end in the
1096 ;; js--pitem diagram). This point is the one
1097 ;; after the last character we need to unambiguously
1098 ;; detect this construct. If one of these evaluates to
1099 ;; nil, the location of the point is ignored.
1101 ;; In comment or string
1104 ;; Regular function declaration
1113 js--guess-function-name-start))
1120 :paren-depth orig-depth
1121 :h-begin orig-match-start
1124 name
1127 ;; Macro
1130 ;; Macros often contain unbalanced parentheses.
1131 ;; Make sure that h-end is at the textual end of
1132 ;; the macro no matter what the parenthesis say.
1138 :h-begin orig-match-start
1142 ;; "Prototype function" declaration
1149 :paren-depth orig-depth
1150 :h-begin orig-match-start
1156 ;; Class definition
1159 for class-style in filtered-class-styles
1165 and return
1167 :paren-depth orig-depth
1168 :h-begin orig-match-start
1169 :type class-style
1184 )))))
1187 "Helper function for `js-end-of-defun'."
1192 return t
1196 "Helper function for `js-end-of-defun'."
1205 found)
1208 ;; We're already inside a function; just go to its end.
1211 ;; Otherwise, go to the end of the next function...
1218 ;; ... or eob.
1222 "Value of `end-of-defun-function' for `js-mode'."
1233 ;; look for function backward. if we're inside it, go to that
1234 ;; function's end. otherwise, search for the next function's end and
1235 ;; go there
1239 ;; if we're doing nested functions, see whether we're in the
1240 ;; prologue. If we are, go to the end of the function; otherwise,
1241 ;; call js--end-of-defun-nested to do the real work
1262 t
1264 nil))))
1267 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1278 pos
1282 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1292 pos
1295 ;; Like (up-list -1), but only considers lists that end nearby"
1298 ;; Look at a very small region so our computation time doesn't
1299 ;; explode in pathological cases.
1304 "Return non-nil iff point is in a function parameter list."
1315 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1337 ;;; Font Lock
1339 "Helper function for building `js--font-lock-keywords'.
1340 Create a byte-compiled function for matching a concatenation of
1341 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1352 "Move forward over a JavaScript destructuring spec.
1353 If FUNC is supplied, call it with no arguments before every
1354 variable name in the spec. Return true iff this was actually a
1355 spec. FUNC must preserve the match data."
1367 t)
1372 t))))
1375 t))
1389 t))
1394 t)))))
1397 t))))
1400 "Font-lock matcher for variable names in a variable declaration.
1401 This is a cc-mode-style matcher that *always* fails, from the
1402 point of view of font-lock. It applies highlighting directly with
1403 `font-lock-apply-highlight'."
1415 t))
1437 ;; Conditions to handle
1441 ;; Matcher always "fails"
1442 nil)
1445 `(
1446 ;; This goes before keywords-2 so it gets used preferentially
1447 ;; instead of the keywords in keywords-2. Don't use override
1448 ;; because that will override syntactic fontification too, which
1449 ;; will fontify commented-out directives as if they weren't
1450 ;; commented out.
1453 ,@js--font-lock-keywords-2
1458 ;; Highlights class being declared, in parts
1462 nil
1465 ;; Highlights parent class, in parts, if available
1482 ;; Highlights parent class
1486 ;; Dojo needs its own matcher to override the string highlighting
1488 'dojo
1495 ;; Match Dojo base classes. Of course Mojo has to be different
1496 ;; from everything else under the sun...
1498 'dojo
1507 ;; continued Dojo base-class list
1509 'dojo
1520 ;; variable declarations
1525 ;; class instantiation
1530 ;; instanceof
1535 ;; formal parameters
1539 js--name-start-re)
1545 ;; continued formal parameter list
1559 "Return whether point is inside the given pitem's header or body."
1569 "Parse the JavaScript program state at point.
1570 Return a list of `js--pitem' instances that apply to point, most
1571 specific first. In the worst case, the current toplevel instance
1572 will be returned."
1581 ;; Loop until we either hit a pitem at BOB or pitem ends after
1582 ;; point (or at point if we're at eob)
1589 pstate))))
1592 "Return the JavaScript syntactic context corresponding to PSTATE."
1595 type)
1601 "Return the JavaScript syntactic context at point.
1602 When called interactively, also display a message with that
1603 context."
1611 syntactic-context))
1614 "Font lock function used by `js-mode'.
1615 This performs fontification according to `js--class-styles'."
1623 js-enabled-frameworks)
1626 decl-re
1629 and return t)
1630 return t
1635 js--font-lock-keywords-2
1636 js--font-lock-keywords-3)
1641 ;; A /.../ regexp.
1647 ;; Javascript allows immediate regular expression objects, written /.../.
1652 ;; Distinguish /-division from /-regexp chars (and from /-comment-starter).
1657 ;; If the / is at the beginning of line, we have to check
1658 ;; the end of the previous text.
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."
1772 ;; A single closing paren/bracket should be indented at the
1773 ;; same level as the opening statement. Same goes for
1774 ;; "case" and "default".
1788 js-expr-indent-offset))
1795 ;; If there is something following the opening
1796 ;; paren/bracket, everything else should be indented at
1797 ;; the same level.
1808 "Indent the current line as JavaScript."
1818 ;;; Filling
1821 "Fill the paragraph with `c-fill-paragraph'."
1835 ;;; Type database and Imenu
1837 ;; We maintain a cache of semantic information, i.e., the classes and
1838 ;; functions we've encountered so far. In order to avoid having to
1839 ;; re-parse the buffer on every change, we cache the parse state at
1840 ;; each interesting point in the buffer. Each parse state is a
1841 ;; modified copy of the previous one, or in the case of the first
1842 ;; parse state, the empty state.
1843 ;;
1844 ;; The parse state itself is just a stack of js--pitem
1845 ;; instances. It starts off containing one element that is never
1846 ;; closed, that is initially js--initial-pitem.
1847 ;;
1855 name
1857 type
1861 "Helper function for `js--splice-into-items'.
1862 Return a new item that is the result of merging CHILD into
1863 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1864 that we haven't consumed yet."
1869 ;; If the item we're merging into isn't a class, make it into one
1875 ;; Use the child's class-style if it's available
1877 js--dummy-class-style
1882 ;; Now we can merge either a function or a class into a class
1886 ;; if we have more name-parts to go before we get to the
1887 ;; bottom of the class hierarchy, call the merger
1888 ;; recursively
1894 ;; Not merging a class, but something else, so just prepend
1895 ;; it
1899 ;; Otherwise, merge the new child's items into those
1900 ;; of the new class
1906 "Last part of the name of PITEM, as a string or symbol."
1910 name)))
1913 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1914 If a class doesn't exist in the tree, create it. Return
1915 the new items list. NAME-PARTS is a list of strings given
1916 the broken-down class name of the item to insert."
1920 new-items last-new-item new-cons)
1923 name-parts
1929 ;; If top-name isn't found in items, then we build a copy of items
1930 ;; and throw it away. But that's okay, since most of the time, we
1931 ;; *will* find an instance.
1935 ;; Okay, we found an entry with the right name. Splice
1936 ;; the merged item into the list...
1939 name-parts)
1946 ;; ...and terminate the loop
1947 nil)
1950 ;; Otherwise, copy the current cons and move onto the
1951 ;; text. This is tricky; we keep track of the tail of
1952 ;; the list that begins with new-items in
1953 ;; last-new-item.
1960 ;; Go to the next cell in items
1964 ;; Yay! We stopped because we found something, not because
1965 ;; we ran out of items to search. Just return the new
1966 ;; list.
1969 new-items)
1971 ;; We didn't find anything. If the child is a class and we don't
1972 ;; have any classes to drill down into, just push that class;
1973 ;; otherwise, make a fake class and carry on.
1976 ;; We have name-parts left to process. Make a fake
1977 ;; class for this particular part...
1979 ;; ...and recursively digest the rest of the name
1982 :type js--dummy-class-style
1985 ;; Otherwise, this is the only name we have, so stick
1986 ;; the item on the front of the list
1987 child)
1988 items))))
1991 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
1996 t))
1998 ;; This trick works because we know (based on our defstructs) that
1999 ;; the child list is always the first element, and so the second
2000 ;; element and beyond can be shared when we make our "copy".
2007 ;; Use slow path because we need class lookup
2013 ;; Use slow path because we need class merging. We know
2014 ;; name is a list here because down in
2015 ;; `js--ensure-cache', we made sure to only add
2016 ;; class entries with lists for :name
2021 ;; Fast path
2027 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2030 location))
2033 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2050 imenu-items))
2055 unknown-ctr))
2058 imenu-items))
2067 imenu-items))))
2071 imenu-items))
2074 "Return an imenu index for the current buffer."
2086 ;; Make sure everything is closed
2094 ;; Convert the new-finalized state into what imenu expects
2097 unknown-ctr))))))
2099 ;; Silence the compiler.
2110 symbols)
2111 else
2122 "Return a hash table of all JavaScript symbols.
2123 This searches all existing `js-mode' buffers. Each key is the
2124 name of a symbol (possibly disambiguated with <N>, where N > 1),
2125 and each value is a marker giving the location of that symbol."
2127 with imenu-use-markers = t
2128 for buffer being the buffers
2133 finally return symbols))
2139 "Helper function for `js-find-symbol'.
2140 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2141 one from `js--get-all-known-symbols', using prompt PROMPT and
2142 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2143 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2144 marker."
2150 prompt
2152 collect key)
2169 "Read a JavaScript symbol and jump to it.
2170 With a prefix argument, restrict symbols to those from the
2171 current buffer. Pushes a mark onto the tag ring just like
2172 `find-tag'."
2183 symbols "Jump to: "
2191 ;;; MozRepl integration
2201 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2202 On timeout, return nil. On success, return t with match data
2203 set. If START is non-nil, look for output starting from START.
2204 Otherwise, use the current value of `process-mark'."
2216 'js-moz-bad-rpc
2220 ;; Integer, mirrors the value we see in JS
2223 ;; Process to which this thing belongs
2244 ; */" Make Emacs happy
2245 "(function(repl) {
2246 repl.defineInteractor('js', {
2247 onStart: function onStart(repl) {
2248 if(!repl._jsObjects) {
2249 repl._jsObjects = {};
2250 repl._jsLastID = 0;
2251 repl._jsGC = this._jsGC;
2252 }
2253 this._input = '';
2254 },
2256 _jsGC: function _jsGC(ids_in_use) {
2257 var objects = this._jsObjects;
2258 var keys = [];
2259 var num_freed = 0;
2261 for(var pn in objects) {
2262 keys.push(Number(pn));
2263 }
2265 keys.sort(function(x, y) x - y);
2266 ids_in_use.sort(function(x, y) x - y);
2267 var i = 0;
2268 var j = 0;
2270 while(i < ids_in_use.length && j < keys.length) {
2271 var id = ids_in_use[i++];
2272 while(j < keys.length && keys[j] !== id) {
2273 var k_id = keys[j++];
2274 delete objects[k_id];
2275 ++num_freed;
2276 }
2277 ++j;
2278 }
2280 while(j < keys.length) {
2281 var k_id = keys[j++];
2282 delete objects[k_id];
2283 ++num_freed;
2284 }
2286 return num_freed;
2287 },
2289 _mkArray: function _mkArray() {
2290 var result = [];
2291 for(var i = 0; i < arguments.length; ++i) {
2292 result.push(arguments[i]);
2293 }
2294 return result;
2295 },
2297 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2298 if(typeof parts === 'string') {
2299 parts = [ parts ];
2300 }
2302 var obj = parts[0];
2303 var start = 1;
2305 if(typeof obj === 'string') {
2306 obj = window;
2307 start = 0;
2308 } else if(parts.length < 2) {
2309 throw new Error('expected at least 2 arguments');
2310 }
2312 for(var i = start; i < parts.length - 1; ++i) {
2313 obj = obj[parts[i]];
2314 }
2316 return [obj, parts[parts.length - 1]];
2317 },
2319 _getProp: function _getProp(/*...*/) {
2320 if(arguments.length === 0) {
2321 throw new Error('no arguments supplied to getprop');
2322 }
2324 if(arguments.length === 1 &&
2325 (typeof arguments[0]) !== 'string')
2326 {
2327 return arguments[0];
2328 }
2330 var [obj, propname] = this._parsePropDescriptor(arguments);
2331 return obj[propname];
2332 },
2334 _putProp: function _putProp(properties, value) {
2335 var [obj, propname] = this._parsePropDescriptor(properties);
2336 obj[propname] = value;
2337 },
2339 _delProp: function _delProp(propname) {
2340 var [obj, propname] = this._parsePropDescriptor(arguments);
2341 delete obj[propname];
2342 },
2344 _typeOf: function _typeOf(thing) {
2345 return typeof thing;
2346 },
2348 _callNew: function(constructor) {
2349 if(typeof constructor === 'string')
2350 {
2351 constructor = window[constructor];
2352 } else if(constructor.length === 1 &&
2353 typeof constructor[0] !== 'string')
2354 {
2355 constructor = constructor[0];
2356 } else {
2357 var [obj,propname] = this._parsePropDescriptor(constructor);
2358 constructor = obj[propname];
2359 }
2361 /* Hacky, but should be robust */
2362 var s = 'new constructor(';
2363 for(var i = 1; i < arguments.length; ++i) {
2364 if(i != 1) {
2365 s += ',';
2366 }
2368 s += 'arguments[' + i + ']';
2369 }
2371 s += ')';
2372 return eval(s);
2373 },
2375 _callEval: function(thisobj, js) {
2376 return eval.call(thisobj, js);
2377 },
2379 getPrompt: function getPrompt(repl) {
2380 return 'EVAL>'
2381 },
2383 _lookupObject: function _lookupObject(repl, id) {
2384 if(typeof id === 'string') {
2385 switch(id) {
2386 case 'global':
2387 return window;
2388 case 'nil':
2389 return null;
2390 case 't':
2391 return true;
2392 case 'false':
2393 return false;
2394 case 'undefined':
2395 return undefined;
2396 case 'repl':
2397 return repl;
2398 case 'interactor':
2399 return this;
2400 case 'NaN':
2401 return NaN;
2402 case 'Infinity':
2403 return Infinity;
2404 case '-Infinity':
2405 return -Infinity;
2406 default:
2407 throw new Error('No object with special id:' + id);
2408 }
2409 }
2411 var ret = repl._jsObjects[id];
2412 if(ret === undefined) {
2413 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2414 }
2415 return ret;
2416 },
2418 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2419 if(typeof value !== 'object' && typeof value !== 'function') {
2420 throw new Error('_findOrAllocateObject called on non-object('
2421 + typeof(value) + '): '
2422 + value)
2423 }
2425 for(var id in repl._jsObjects) {
2426 id = Number(id);
2427 var obj = repl._jsObjects[id];
2428 if(obj === value) {
2429 return id;
2430 }
2431 }
2433 var id = ++repl._jsLastID;
2434 repl._jsObjects[id] = value;
2435 return id;
2436 },
2438 _fixupList: function _fixupList(repl, list) {
2439 for(var i = 0; i < list.length; ++i) {
2440 if(list[i] instanceof Array) {
2441 this._fixupList(repl, list[i]);
2442 } else if(typeof list[i] === 'object') {
2443 var obj = list[i];
2444 if(obj.funcall) {
2445 var parts = obj.funcall;
2446 this._fixupList(repl, parts);
2447 var [thisobj, func] = this._parseFunc(parts[0]);
2448 list[i] = func.apply(thisobj, parts.slice(1));
2449 } else if(obj.objid) {
2450 list[i] = this._lookupObject(repl, obj.objid);
2451 } else {
2452 throw new Error('Unknown object type: ' + obj.toSource());
2453 }
2454 }
2455 }
2456 },
2458 _parseFunc: function(func) {
2459 var thisobj = null;
2461 if(typeof func === 'string') {
2462 func = window[func];
2463 } else if(func instanceof Array) {
2464 if(func.length === 1 && typeof func[0] !== 'string') {
2465 func = func[0];
2466 } else {
2467 [thisobj, func] = this._parsePropDescriptor(func);
2468 func = thisobj[func];
2469 }
2470 }
2472 return [thisobj,func];
2473 },
2475 _encodeReturn: function(value, array_as_mv) {
2476 var ret;
2478 if(value === null) {
2479 ret = ['special', 'null'];
2480 } else if(value === true) {
2481 ret = ['special', 'true'];
2482 } else if(value === false) {
2483 ret = ['special', 'false'];
2484 } else if(value === undefined) {
2485 ret = ['special', 'undefined'];
2486 } else if(typeof value === 'number') {
2487 if(isNaN(value)) {
2488 ret = ['special', 'NaN'];
2489 } else if(value === Infinity) {
2490 ret = ['special', 'Infinity'];
2491 } else if(value === -Infinity) {
2492 ret = ['special', '-Infinity'];
2493 } else {
2494 ret = ['atom', value];
2495 }
2496 } else if(typeof value === 'string') {
2497 ret = ['atom', value];
2498 } else if(array_as_mv && value instanceof Array) {
2499 ret = ['array', value.map(this._encodeReturn, this)];
2500 } else {
2501 ret = ['objid', this._findOrAllocateObject(repl, value)];
2502 }
2504 return ret;
2505 },
2507 _handleInputLine: function _handleInputLine(repl, line) {
2508 var ret;
2509 var array_as_mv = false;
2511 try {
2512 if(line[0] === '*') {
2513 array_as_mv = true;
2514 line = line.substring(1);
2515 }
2516 var parts = eval(line);
2517 this._fixupList(repl, parts);
2518 var [thisobj, func] = this._parseFunc(parts[0]);
2519 ret = this._encodeReturn(
2520 func.apply(thisobj, parts.slice(1)),
2521 array_as_mv);
2522 } catch(x) {
2523 ret = ['error', x.toString() ];
2524 }
2526 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2527 repl.print(JSON.encode(ret));
2528 repl._prompt();
2529 },
2531 handleInput: function handleInput(repl, chunk) {
2532 this._input += chunk;
2533 var match, line;
2535 line = match[0];
2538 repl.popInteractor();
2539 repl._prompt();
2540 return;
2541 }
2543 this._input = this._input.substring(line.length);
2544 this._handleInputLine(repl, line);
2545 }
2546 }
2547 });
2548 })
2554 "Marshall the given value for JS.
2555 Strings and numbers are JSON-encoded. Lists (including nil) are
2556 made into JavaScript array literals and their contents encoded
2557 with `js--js-encode-value'."
2584 js--js-repl-prompt-regexp js-js-timeout
2586 ;; start matching against the beginning of the line in
2587 ;; order to catch a prompt that's only partially arrived
2595 ;; Do some initialization the first time we see a process
2601 ;; Send interactor definition
2607 js-js-timeout))
2609 ;; Sanity check
2615 ;; If js--js-repl-depth > 0, we *should* be seeing an
2616 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2617 ;; up with us.
2620 ;; Otherwise, tell Mozilla to enter the interactor mode
2626 js-js-timeout))
2640 js-js-timeout))))
2650 "Convert immediate js< and js! references to deferred ones."
2674 function))
2676 else
2677 collect item)))
2692 "Run FORMS with the Mozilla repl set up for js commands.
2693 Inside the lexical scope of `with-js', `js?', `js!',
2694 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2695 `js-create-instance', and `js-qi' are defined."
2706 function)
2714 function)
2746 props)
2748 ))
2754 "Whether to listify any Array returned by a Mozilla function.
2765 js--js-references)
2770 js--js-references)))
2775 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2776 If function is a string, look it up as a property on the global
2777 object and use the global object for `this'.
2778 If FUNCTION is a list with one element, use that element as the
2779 function with the global object for `this', except that if that
2780 single element is a string, look it up on the global object.
2781 If FUNCTION is a list with more than one argument, use the list
2782 up to the last value as a property descriptor and the last
2783 argument as a function."
2790 ;; Actual funcall
2797 js-js-timeout)
2800 ;; Read the result
2807 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2808 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2811 constructor arguments))
2817 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2820 arguments)))
2829 "Tell the repl about any objects we don't reference anymore.
2830 With argument, run even if no intervening GC has happened."
2841 ;; Don't bother running unless we've had an intervening
2842 ;; garbage collection; without a gc, nothing is deleted
2843 ;; from the weak hash table, so it's pointless telling
2844 ;; MozRepl about that references we still hold
2847 ;; Are we looking at a normal prompt? Make sure not to
2848 ;; interrupt the user if he's doing something
2856 of js--js-references
2857 collect x))
2864 num)))
2869 "Evaluate the JavaScript in JS and return JSON-decoded result."
2877 result)))
2880 "Enumerate all JavaScript contexts available.
2881 Each context is a list:
2882 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2883 (TITLE URL WINDOW) for windows
2885 All tabs of a given window are grouped together. The most recent
2886 window is first. Within each window, the tabs are returned
2887 left-to-right."
2892 "@mozilla.org/appshell/window-mediator;1"
2914 window)
2921 "browsers"
2922 x
2923 "contentDocument"
2927 "browsers"
2928 x
2929 "contentWindow"
2930 "location"
2933 "browsers"
2934 x)
2937 "tabContainer"
2938 "childNodes"
2940 x)
2942 gbrowser))))))
2947 "Read a Mozilla tab with prompt PROMPT.
2948 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2949 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2950 browser, respectively."
2952 ;; Prime IDO
2959 selected-tab prev-hitab)
2961 ;; Disambiguate names
2963 for tab in tabs
2979 ;; Hack to reduce the number of
2980 ;; round-trips to mozilla
2983 ;; Highlighting tab
2986 "style"
2988 cmds)
2990 ;; Highlight window proper
2993 "style"
2995 cmds)
2997 ;; Select tab, when appropriate
3001 cmds)))
3003 ;; Hilighting whole window
3007 "style"
3010 cmds)))
3013 ;; Unhighlighting tab
3016 cmds)
3018 cmds))
3020 ;; Unhighlighting window
3025 cmds)))
3031 ()
3037 ()
3038 ;; Fiddle with the match list a bit: if our first match
3039 ;; is a tabbrowser window, rotate the match list until
3040 ;; the active tab comes up
3046 "document"
3047 "documentElement"
3052 "gBrowser"
3056 for match in ido-matches
3060 and return t)))
3070 prompt
3072 nil t nil
3090 "Helper function for `js-eval-defun'.
3091 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3092 strings making up the class name and NAME is the name of the
3093 function part."
3112 "The current JavaScript context.
3113 This is a cons like the one returned from `js--read-tab'.
3117 "(function(func_info,func) {
3118 func_info.unshift('window');
3119 var obj = window;
3120 for(var i = 1; i < func_info.length - 1; ++i) {
3121 var next = obj[func_info[i]];
3122 if(typeof next !== 'object' && typeof next !== 'function') {
3123 next = obj.prototype && obj.prototype[func_info[i]];
3124 if(typeof next !== 'object' && typeof next !== 'function') {
3125 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3126 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3127 return;
3128 }
3130 func_info.splice(i+1, 0, 'prototype');
3131 ++i;
3132 }
3133 }
3135 obj[func_info[i]] = func;
3136 alert('Successfully updated '+func_info.join('.'));
3140 "Set the JavaScript context to CONTEXT.
3141 When called interactively, prompt for CONTEXT."
3146 "Return a valid JavaScript context.
3147 If one hasn't been set, or if it's stale, prompt for a new one."
3156 js--js-context))
3170 file)))
3183 "Update a Mozilla tab using the JavaScript defun at point."
3186 ;; This function works by generating a temporary file that contains
3187 ;; the function we'd like to insert. We then use the elisp-js bridge
3188 ;; to command mozilla to load this file by inserting a script tag
3189 ;; into the document we set. This way, debuggers and such will have
3190 ;; a way to find the source of the just-inserted function.
3191 ;;
3192 ;; We delete the temporary file if there's an error, but otherwise
3193 ;; we add an unload event listener on the Mozilla side to delete the
3194 ;; file.
3225 ;; (Re)register a Mozilla resource URL to point to the
3226 ;; temporary directory
3244 ;; Give Mozilla responsibility for deleting this file
3249 ;; Regular content
3253 ;; Chrome
3275 ))
3277 ;; temp-name is set to nil on success
3281 ;;; Main Function
3283 ;;;###autoload
3285 "Major mode for editing JavaScript."
3305 ;; Comments
3311 ;; Parse cache
3314 ;; Frameworks
3317 ;; Imenu
3322 ;; for filling, pretend we're cc-mode
3324 c-paragraph-start "$"
3325 c-paragraph-separate "$"
3326 c-block-comment-prefix "* "
3327 c-line-comment-starter "//"
3337 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3338 ;; we call it instead? (Bug#6071)
3349 ;; Important to fontify the whole buffer syntactically! If we don't,
3350 ;; then we might have regular expression literals that aren't marked
3351 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3352 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3353 ;; When we attempt to find the error and scroll to the portion of
3354 ;; the buffer containing the problem, JIT-lock will apply the
3355 ;; correct syntax to the regular expression literal and the problem
3356 ;; will mysteriously disappear.
3357 ;; FIXME: We should actually do this fontification lazily by adding
3358 ;; calls to syntax-propertize wherever it's really needed.
3361 ;;;###autoload
3370 ;; js.el ends here