| blob | 9fb4822436af2a877e480f4600cac1af5380f86d |
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 for indenting continued expressions.
435 The value must be no less than minus `js-indent-level'."
440 "Number of additional spaces for indenting expressions in parentheses.
441 The value must be no less than minus `js-indent-level'."
447 "Number of additional spaces for indenting expressions in square braces.
448 The value must be no less than minus `js-indent-level'."
454 "Number of additional spaces for indenting expressions in curly braces.
455 The value must be no less than minus `js-indent-level'."
461 "Whether to automatically indent when typing punctuation characters.
462 If non-nil, the characters {}();,: also indent the current line
463 in Javascript mode."
468 "Treat nested functions as top-level functions in `js-mode'.
469 This applies to function movement, marking, and so on."
474 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
479 "Frameworks recognized by `js-mode'.
480 To improve performance, you may turn off some frameworks you
481 seldom use, either globally or on a per-buffer basis."
484 js--available-frameworks))
489 "Whether `js-mode' should display tabs while selecting them.
490 This is useful only if the windowing system has a good mechanism
491 for preventing Firefox from stealing the keyboard focus."
496 "~/.emacs.d/js/js"
497 "Temporary directory used by `js-mode' to communicate with Mozilla.
498 This directory must be readable and writable by both Mozilla and Emacs."
503 "Reply timeout for executing commands in Mozilla via `js-mode'.
504 The value is given in seconds. Increase this value if you are
505 getting timeout messages."
509 ;;; KeyMap
528 keymap)
532 "Run the command bound to KEY, and indent if necessary.
533 Indentation does not take place if point is in a string or
534 comment."
539 js-auto-indent-flag)
546 ;;; Syntax table and parsing
552 table)
583 "Helper function for `js--update-quick-match-re'.
584 If LIST contains any element that is not nil, return its non-nil
585 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
586 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
587 nil. If any element in LIST is itself a list, flatten that
588 element."
594 "Internal function used by `js-mode' for caching buffer constructs.
595 This updates `js--quick-match-re', based on the current set of
596 enabled frameworks."
601 ;; #define mumble
610 ;; var mumble = THING (
631 ;; mumble.prototypeTHING
639 ;; mumble.prototype = {
646 "Move over the next value of PROPNAME in the buffer.
647 If found, return that value and leave point after the character
648 having that value; otherwise, return nil and leave point at EOB."
659 next-value))
662 "Move over the previous value of PROPNAME in the buffer.
663 If found, return that value and leave point just before the
664 character that has that value, otherwise return nil and leave
665 point at BOB."
678 prev-value)))
691 "Helper function for `js--re-search-forward'."
693 str-terminator
722 "Search forward, ignoring strings, cpp macros, and comments.
723 This function invokes `re-search-forward', but treats the buffer
724 as if strings, cpp macros, and comments have been removed.
726 If invoked while inside a macro, it treats the contents of the
727 macro as normal text."
745 "Auxiliary function for `js--re-search-backward'."
747 str-terminator
778 "Search backward, ignoring strings, preprocessor macros, and comments.
780 This function invokes `re-search-backward' but treats the buffer
781 as if strings, preprocessor macros, and comments have been
782 removed.
784 If invoked while inside a macro, treat the macro as normal text."
801 "Move forward over a whole JavaScript expression.
802 This function doesn't move over expressions continued across
803 lines."
805 ;; non-continued case; simplistic, but good enough?
818 "Move forward over a JavaScript function declaration.
819 This puts point at the 'function' keyword.
821 If this is a syntactically-correct non-expression function,
822 return the name of the function, or t if the name could not be
823 determined. Otherwise, return nil."
836 name)))))
839 "Return the start of the JavaScript function prologue containing POS.
840 A function prologue is everything from start of the definition up
841 to and including the opening brace. POS defaults to point.
842 If POS is not in a function prologue, return nil."
869 "Helper function for `js-beginning-of-defun'.
870 Go to previous defun-beginning and return the parse state for it,
871 or nil if we went all the way back to bob and don't find
872 anything."
880 "Helper function for `js--beginning-of-defun-nested'.
881 If PSTATE represents a non-empty top-level defun, return the
882 top-most pitem. Otherwise, return nil."
885 with func-pitem
892 "Helper function for `js--beginning-of-defun'.
893 Return the pitem of the function we went to the beginning of."
895 ;; Look for the smallest function that encloses point...
900 and return pitem)
902 ;; ...and if that isn't found, look for the previous top-level
903 ;; defun
905 while pstate
908 and return it)))
911 "Helper function for `js-beginning-of-defun'."
917 "Value of `beginning-of-defun-function' for `js-mode'."
933 ;; If we're just past the end of a function, the user probably wants
934 ;; to go to the beginning of *that* function
948 "Flush the `js-mode' syntax cache after position BEG.
949 BEG defaults to `point-min', meaning to flush the entire cache."
955 ;; `(message ,@arguments)
956 )
965 ;; open-items must contain at least two items for this to
966 ;; work, but because we push a dummy item to start with,
967 ;; that assumption holds.
970 open-items)
973 "Helper function for `js--ensure-cache'.
974 Update parsing information up to point, referring to parse,
975 prev-parse-point, goal-point, and open-items bound lexically in
976 the body of `js--ensure-cache'."
983 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
984 ;; the given depth -- i.e., make sure we're deeper than the target
985 ;; depth.
989 prev-parse-point goal-point
991 nil parse))
993 ;; (let ((overlay (make-overlay prev-parse-point (point))))
994 ;; (overlay-put overlay 'face '(:background "red"))
995 ;; (unwind-protect
996 ;; (progn
997 ;; (js--debug "parsed: %S" parse)
998 ;; (sit-for 1))
999 ;; (delete-overlay overlay)))
1015 "Split a JavaScript name into its dot-separated parts.
1016 This also removes any prototype parts from the split name
1028 "Guess the name of the JavaScript function at POSITION.
1030 Return the name of the function, or nil if the name could not be
1031 guessed.
1033 This function clobbers match data. If we find the preamble
1034 begins earlier than expected while guessing the function name,
1035 set `js--guess-function-name-start' to that position; otherwise,
1036 set that variable to nil."
1053 ;; Clear any endings that occur after point
1060 ;; Remove any cache properties after this point
1065 "Ensures brace cache is valid up to the character before LIMIT.
1066 LIMIT defaults to point."
1072 orig-match-start
1073 orig-match-end
1074 orig-depth
1075 parse
1076 prev-parse-point
1077 name
1078 case-fold-search
1079 filtered-class-styles
1080 new-item
1081 goal-point
1082 end-prop)
1084 ;; Figure out which class styles we need to look for
1088 js-enabled-frameworks)
1089 collect style))
1095 ;; Find last known good position
1111 ;; Make a placeholder for the top-level definition
1127 ;; Each of these conditions should return non-nil if
1128 ;; we should add a new item and leave point at the end
1129 ;; of the new item's header (h-end in the
1130 ;; js--pitem diagram). This point is the one
1131 ;; after the last character we need to unambiguously
1132 ;; detect this construct. If one of these evaluates to
1133 ;; nil, the location of the point is ignored.
1135 ;; In comment or string
1138 ;; Regular function declaration
1147 js--guess-function-name-start))
1154 :paren-depth orig-depth
1155 :h-begin orig-match-start
1158 name
1161 ;; Macro
1164 ;; Macros often contain unbalanced parentheses.
1165 ;; Make sure that h-end is at the textual end of
1166 ;; the macro no matter what the parenthesis say.
1172 :h-begin orig-match-start
1176 ;; "Prototype function" declaration
1183 :paren-depth orig-depth
1184 :h-begin orig-match-start
1190 ;; Class definition
1193 for class-style in filtered-class-styles
1199 and return
1201 :paren-depth orig-depth
1202 :h-begin orig-match-start
1203 :type class-style
1218 )))))
1221 "Helper function for `js-end-of-defun'."
1226 return t
1230 "Helper function for `js-end-of-defun'."
1239 found)
1242 ;; We're already inside a function; just go to its end.
1245 ;; Otherwise, go to the end of the next function...
1252 ;; ... or eob.
1256 "Value of `end-of-defun-function' for `js-mode'."
1267 ;; look for function backward. if we're inside it, go to that
1268 ;; function's end. otherwise, search for the next function's end and
1269 ;; go there
1273 ;; if we're doing nested functions, see whether we're in the
1274 ;; prologue. If we are, go to the end of the function; otherwise,
1275 ;; call js--end-of-defun-nested to do the real work
1296 t
1298 nil))))
1301 "Simple implementation of `c-backward-syntactic-ws' for `js-mode'."
1312 pos
1316 "Simple implementation of `c-forward-syntactic-ws' for `js-mode'."
1326 pos
1329 ;; Like (up-list -1), but only considers lists that end nearby"
1332 ;; Look at a very small region so our compuation time doesn't
1333 ;; explode in pathological cases.
1338 "Return non-nil iff point is in a function parameter list."
1349 "Return non-nil iff point is in a Dojo multiple-inheritance class block."
1371 ;;; Font Lock
1373 "Helper function for building `js--font-lock-keywords'.
1374 Create a byte-compiled function for matching a concatenation of
1375 REGEXPS, but only if FRAMEWORK is in `js-enabled-frameworks'."
1386 "Move forward over a JavaScript destructuring spec.
1387 If FUNC is supplied, call it with no arguments before every
1388 variable name in the spec. Return true iff this was actually a
1389 spec. FUNC must preserve the match data."
1401 t)
1406 t))))
1409 t))
1423 t))
1428 t)))))
1431 t))))
1434 "Font-lock matcher for variable names in a variable declaration.
1435 This is a cc-mode-style matcher that *always* fails, from the
1436 point of view of font-lock. It applies highlighting directly with
1437 `font-lock-apply-highlight'."
1449 t))
1471 ;; Conditions to handle
1475 ;; Matcher always "fails"
1476 nil)
1479 `(
1480 ;; This goes before keywords-2 so it gets used preferentially
1481 ;; instead of the keywords in keywords-2. Don't use override
1482 ;; because that will override syntactic fontification too, which
1483 ;; will fontify commented-out directives as if they weren't
1484 ;; commented out.
1487 ,@js--font-lock-keywords-2
1492 ;; Highlights class being declared, in parts
1496 nil
1499 ;; Highlights parent class, in parts, if available
1516 ;; Highlights parent class
1520 ;; Dojo needs its own matcher to override the string highlighting
1522 'dojo
1529 ;; Match Dojo base classes. Of course Mojo has to be different
1530 ;; from everything else under the sun...
1532 'dojo
1541 ;; continued Dojo base-class list
1543 'dojo
1554 ;; variable declarations
1559 ;; class instantiation
1564 ;; instanceof
1569 ;; formal parameters
1573 js--name-start-re)
1579 ;; continued formal parameter list
1593 "Return whether point is inside the given pitem's header or body."
1603 "Parse the JavaScript program state at point.
1604 Return a list of `js--pitem' instances that apply to point, most
1605 specific first. In the worst case, the current toplevel instance
1606 will be returned."
1616 ;; Loop until we either hit a pitem at BOB or pitem ends after
1617 ;; point (or at point if we're at eob)
1624 pstate))))
1627 "Return the JavaScript syntactic context corresponding to PSTATE."
1630 type)
1636 "Return the JavaScript syntactic context at point.
1637 When called interatively, also display a message with that
1638 context."
1646 syntactic-context))
1649 "Font lock function used by `js-mode'.
1650 This performs fontification according to `js--class-styles'."
1658 js-enabled-frameworks)
1661 decl-re
1664 and return t)
1665 return t
1670 js--font-lock-keywords-2
1671 js--font-lock-keywords-3)
1674 ;; XXX: Javascript can continue a regexp literal across lines so long
1675 ;; as the newline is escaped with \. Account for that in the regexp
1676 ;; below.
1679 "Regexp matching a JavaScript regular expression literal.
1680 Match groups 1 and 2 are the characters forming the beginning and
1683 ;; we want to match regular expressions only at the beginning of
1684 ;; expressions
1687 "Syntactic font lock keywords matching regexps in JavaScript.
1690 ;;; Indentation
1705 "Return non-nil if point is on a JavaScript operator, other than a comma."
1715 "Return non-nil if the current line continues an expression."
1732 Otherwise, return nil. A braceless do-while statement spanning
1733 several lines requires that the start of the loop is indented to
1734 the same column as the current line."
1756 "Helper function for `js--proper-indentation'.
1757 Return the proper indentation of the current line if it starts
1758 the body of a control statement without braces; otherwise, return
1759 nil."
1783 "Return the proper indentation for the current line."
1793 ;; A single closing paren/bracket should be indented at the
1794 ;; same level as the opening statement. Same goes for
1795 ;; "case" and "default".
1809 js-expr-indent-offset))
1816 ;; If there is something following the opening
1817 ;; paren/bracket, everything else should be indented at
1818 ;; the same level.
1829 "Indent the current line as JavaScript."
1839 ;;; Filling
1842 "Fill the paragraph with `c-fill-paragraph'."
1856 ;;; Type database and Imenu
1858 ;; We maintain a cache of semantic information, i.e., the classes and
1859 ;; functions we've encountered so far. In order to avoid having to
1860 ;; re-parse the buffer on every change, we cache the parse state at
1861 ;; each interesting point in the buffer. Each parse state is a
1862 ;; modified copy of the previous one, or in the case of the first
1863 ;; parse state, the empty state.
1864 ;;
1865 ;; The parse state itself is just a stack of js--pitem
1866 ;; instances. It starts off containing one element that is never
1867 ;; closed, that is initially js--initial-pitem.
1868 ;;
1876 name
1878 type
1882 "Helper function for `js--splice-into-items'.
1883 Return a new item that is the result of merging CHILD into
1884 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1885 that we haven't consumed yet."
1890 ;; If the item we're merging into isn't a class, make it into one
1896 ;; Use the child's class-style if it's available
1898 js--dummy-class-style
1903 ;; Now we can merge either a function or a class into a class
1907 ;; if we have more name-parts to go before we get to the
1908 ;; bottom of the class hierarchy, call the merger
1909 ;; recursively
1915 ;; Not merging a class, but something else, so just prepend
1916 ;; it
1920 ;; Otherwise, merge the new child's items into those
1921 ;; of the new class
1927 "Last part of the name of PITEM, as a string or symbol."
1931 name)))
1934 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1935 If a class doesn't exist in the tree, create it. Return
1936 the new items list. NAME-PARTS is a list of strings given
1937 the broken-down class name of the item to insert."
1941 new-items last-new-item new-cons item)
1944 name-parts
1950 ;; If top-name isn't found in items, then we build a copy of items
1951 ;; and throw it away. But that's okay, since most of the time, we
1952 ;; *will* find an instance.
1956 ;; Okay, we found an entry with the right name. Splice
1957 ;; the merged item into the list...
1960 name-parts)
1967 ;; ...and terminate the loop
1968 nil)
1971 ;; Otherwise, copy the current cons and move onto the
1972 ;; text. This is tricky; we keep track of the tail of
1973 ;; the list that begins with new-items in
1974 ;; last-new-item.
1981 ;; Go to the next cell in items
1985 ;; Yay! We stopped because we found something, not because
1986 ;; we ran out of items to search. Just return the new
1987 ;; list.
1990 new-items)
1992 ;; We didn't find anything. If the child is a class and we don't
1993 ;; have any classes to drill down into, just push that class;
1994 ;; otherwise, make a fake class and carry on.
1997 ;; We have name-parts left to process. Make a fake
1998 ;; class for this particular part...
2000 ;; ...and recursively digest the rest of the name
2003 :type js--dummy-class-style
2006 ;; Otherwise, this is the only name we have, so stick
2007 ;; the item on the front of the list
2008 child)
2009 items))))
2012 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2017 t))
2019 ;; This trick works because we know (based on our defstructs) that
2020 ;; the child list is always the first element, and so the second
2021 ;; element and beyond can be shared when we make our "copy".
2028 ;; Use slow path because we need class lookup
2034 ;; Use slow path because we need class merging. We know
2035 ;; name is a list here because down in
2036 ;; `js--ensure-cache', we made sure to only add
2037 ;; class entries with lists for :name
2042 ;; Fast path
2048 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2051 location))
2054 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2071 imenu-items))
2076 unknown-ctr))
2079 imenu-items))
2088 imenu-items))))
2092 imenu-items))
2095 "Return an imenu index for the current buffer."
2107 ;; Make sure everything is closed
2115 ;; Convert the new-finalized state into what imenu expects
2118 unknown-ctr))))))
2120 ;; Silence the compiler.
2131 symbols)
2132 else
2143 "Return a hash table of all JavaScript symbols.
2144 This searches all existing `js-mode' buffers. Each key is the
2145 name of a symbol (possibly disambiguated with <N>, where N > 1),
2146 and each value is a marker giving the location of that symbol."
2148 with imenu-use-markers = t
2149 for buffer being the buffers
2154 finally return symbols))
2160 "Helper function for `js-find-symbol'.
2161 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2162 one from `js--get-all-known-symbols', using prompt PROMPT and
2163 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2164 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2165 marker."
2171 prompt
2173 collect key)
2188 "Read a JavaScript symbol and jump to it.
2189 With a prefix argument, restrict symbols to those from the
2190 current buffer. Pushes a mark onto the tag ring just like
2191 `find-tag'."
2201 symbols "Jump to: "
2209 ;;; MozRepl integration
2219 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2220 On timeout, return nil. On success, return t with match data
2221 set. If START is non-nil, look for output starting from START.
2222 Otherwise, use the current value of `process-mark'."
2234 'js-moz-bad-rpc
2238 ;; Integer, mirrors the value we see in JS
2241 ;; Process to which this thing belongs
2262 ; */" Make Emacs happy
2263 "(function(repl) {
2264 repl.defineInteractor('js', {
2265 onStart: function onStart(repl) {
2266 if(!repl._jsObjects) {
2267 repl._jsObjects = {};
2268 repl._jsLastID = 0;
2269 repl._jsGC = this._jsGC;
2270 }
2271 this._input = '';
2272 },
2274 _jsGC: function _jsGC(ids_in_use) {
2275 var objects = this._jsObjects;
2276 var keys = [];
2277 var num_freed = 0;
2279 for(var pn in objects) {
2280 keys.push(Number(pn));
2281 }
2283 keys.sort(function(x, y) x - y);
2284 ids_in_use.sort(function(x, y) x - y);
2285 var i = 0;
2286 var j = 0;
2288 while(i < ids_in_use.length && j < keys.length) {
2289 var id = ids_in_use[i++];
2290 while(j < keys.length && keys[j] !== id) {
2291 var k_id = keys[j++];
2292 delete objects[k_id];
2293 ++num_freed;
2294 }
2295 ++j;
2296 }
2298 while(j < keys.length) {
2299 var k_id = keys[j++];
2300 delete objects[k_id];
2301 ++num_freed;
2302 }
2304 return num_freed;
2305 },
2307 _mkArray: function _mkArray() {
2308 var result = [];
2309 for(var i = 0; i < arguments.length; ++i) {
2310 result.push(arguments[i]);
2311 }
2312 return result;
2313 },
2315 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2316 if(typeof parts === 'string') {
2317 parts = [ parts ];
2318 }
2320 var obj = parts[0];
2321 var start = 1;
2323 if(typeof obj === 'string') {
2324 obj = window;
2325 start = 0;
2326 } else if(parts.length < 2) {
2327 throw new Error('expected at least 2 arguments');
2328 }
2330 for(var i = start; i < parts.length - 1; ++i) {
2331 obj = obj[parts[i]];
2332 }
2334 return [obj, parts[parts.length - 1]];
2335 },
2337 _getProp: function _getProp(/*...*/) {
2338 if(arguments.length === 0) {
2339 throw new Error('no arguments supplied to getprop');
2340 }
2342 if(arguments.length === 1 &&
2343 (typeof arguments[0]) !== 'string')
2344 {
2345 return arguments[0];
2346 }
2348 var [obj, propname] = this._parsePropDescriptor(arguments);
2349 return obj[propname];
2350 },
2352 _putProp: function _putProp(properties, value) {
2353 var [obj, propname] = this._parsePropDescriptor(properties);
2354 obj[propname] = value;
2355 },
2357 _delProp: function _delProp(propname) {
2358 var [obj, propname] = this._parsePropDescriptor(arguments);
2359 delete obj[propname];
2360 },
2362 _typeOf: function _typeOf(thing) {
2363 return typeof thing;
2364 },
2366 _callNew: function(constructor) {
2367 if(typeof constructor === 'string')
2368 {
2369 constructor = window[constructor];
2370 } else if(constructor.length === 1 &&
2371 typeof constructor[0] !== 'string')
2372 {
2373 constructor = constructor[0];
2374 } else {
2375 var [obj,propname] = this._parsePropDescriptor(constructor);
2376 constructor = obj[propname];
2377 }
2379 /* Hacky, but should be robust */
2380 var s = 'new constructor(';
2381 for(var i = 1; i < arguments.length; ++i) {
2382 if(i != 1) {
2383 s += ',';
2384 }
2386 s += 'arguments[' + i + ']';
2387 }
2389 s += ')';
2390 return eval(s);
2391 },
2393 _callEval: function(thisobj, js) {
2394 return eval.call(thisobj, js);
2395 },
2397 getPrompt: function getPrompt(repl) {
2398 return 'EVAL>'
2399 },
2401 _lookupObject: function _lookupObject(repl, id) {
2402 if(typeof id === 'string') {
2403 switch(id) {
2404 case 'global':
2405 return window;
2406 case 'nil':
2407 return null;
2408 case 't':
2409 return true;
2410 case 'false':
2411 return false;
2412 case 'undefined':
2413 return undefined;
2414 case 'repl':
2415 return repl;
2416 case 'interactor':
2417 return this;
2418 case 'NaN':
2419 return NaN;
2420 case 'Infinity':
2421 return Infinity;
2422 case '-Infinity':
2423 return -Infinity;
2424 default:
2425 throw new Error('No object with special id:' + id);
2426 }
2427 }
2429 var ret = repl._jsObjects[id];
2430 if(ret === undefined) {
2431 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2432 }
2433 return ret;
2434 },
2436 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2437 if(typeof value !== 'object' && typeof value !== 'function') {
2438 throw new Error('_findOrAllocateObject called on non-object('
2439 + typeof(value) + '): '
2440 + value)
2441 }
2443 for(var id in repl._jsObjects) {
2444 id = Number(id);
2445 var obj = repl._jsObjects[id];
2446 if(obj === value) {
2447 return id;
2448 }
2449 }
2451 var id = ++repl._jsLastID;
2452 repl._jsObjects[id] = value;
2453 return id;
2454 },
2456 _fixupList: function _fixupList(repl, list) {
2457 for(var i = 0; i < list.length; ++i) {
2458 if(list[i] instanceof Array) {
2459 this._fixupList(repl, list[i]);
2460 } else if(typeof list[i] === 'object') {
2461 var obj = list[i];
2462 if(obj.funcall) {
2463 var parts = obj.funcall;
2464 this._fixupList(repl, parts);
2465 var [thisobj, func] = this._parseFunc(parts[0]);
2466 list[i] = func.apply(thisobj, parts.slice(1));
2467 } else if(obj.objid) {
2468 list[i] = this._lookupObject(repl, obj.objid);
2469 } else {
2470 throw new Error('Unknown object type: ' + obj.toSource());
2471 }
2472 }
2473 }
2474 },
2476 _parseFunc: function(func) {
2477 var thisobj = null;
2479 if(typeof func === 'string') {
2480 func = window[func];
2481 } else if(func instanceof Array) {
2482 if(func.length === 1 && typeof func[0] !== 'string') {
2483 func = func[0];
2484 } else {
2485 [thisobj, func] = this._parsePropDescriptor(func);
2486 func = thisobj[func];
2487 }
2488 }
2490 return [thisobj,func];
2491 },
2493 _encodeReturn: function(value, array_as_mv) {
2494 var ret;
2496 if(value === null) {
2497 ret = ['special', 'null'];
2498 } else if(value === true) {
2499 ret = ['special', 'true'];
2500 } else if(value === false) {
2501 ret = ['special', 'false'];
2502 } else if(value === undefined) {
2503 ret = ['special', 'undefined'];
2504 } else if(typeof value === 'number') {
2505 if(isNaN(value)) {
2506 ret = ['special', 'NaN'];
2507 } else if(value === Infinity) {
2508 ret = ['special', 'Infinity'];
2509 } else if(value === -Infinity) {
2510 ret = ['special', '-Infinity'];
2511 } else {
2512 ret = ['atom', value];
2513 }
2514 } else if(typeof value === 'string') {
2515 ret = ['atom', value];
2516 } else if(array_as_mv && value instanceof Array) {
2517 ret = ['array', value.map(this._encodeReturn, this)];
2518 } else {
2519 ret = ['objid', this._findOrAllocateObject(repl, value)];
2520 }
2522 return ret;
2523 },
2525 _handleInputLine: function _handleInputLine(repl, line) {
2526 var ret;
2527 var array_as_mv = false;
2529 try {
2530 if(line[0] === '*') {
2531 array_as_mv = true;
2532 line = line.substring(1);
2533 }
2534 var parts = eval(line);
2535 this._fixupList(repl, parts);
2536 var [thisobj, func] = this._parseFunc(parts[0]);
2537 ret = this._encodeReturn(
2538 func.apply(thisobj, parts.slice(1)),
2539 array_as_mv);
2540 } catch(x) {
2541 ret = ['error', x.toString() ];
2542 }
2544 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2545 repl.print(JSON.encode(ret));
2546 repl._prompt();
2547 },
2549 handleInput: function handleInput(repl, chunk) {
2550 this._input += chunk;
2551 var match, line;
2553 line = match[0];
2556 repl.popInteractor();
2557 repl._prompt();
2558 return;
2559 }
2561 this._input = this._input.substring(line.length);
2562 this._handleInputLine(repl, line);
2563 }
2564 }
2565 });
2566 })
2572 "Marshall the given value for JS.
2573 Strings and numbers are JSON-encoded. Lists (including nil) are
2574 made into JavaScript array literals and their contents encoded
2575 with `js--js-encode-value'."
2602 js--js-repl-prompt-regexp js-js-timeout
2604 ;; start matching against the beginning of the line in
2605 ;; order to catch a prompt that's only partially arrived
2613 ;; Do some initialization the first time we see a process
2619 ;; Send interactor definition
2625 js-js-timeout))
2627 ;; Sanity check
2633 ;; If js--js-repl-depth > 0, we *should* be seeing an
2634 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2635 ;; up with us.
2638 ;; Otherwise, tell Mozilla to enter the interactor mode
2644 js-js-timeout))
2658 js-js-timeout))))
2668 "Convert immediate js< and js! references to deferred ones."
2692 function))
2694 else
2695 collect item)))
2710 "Run FORMS with the Mozilla repl set up for js commands.
2711 Inside the lexical scope of `with-js', `js?', `js!',
2712 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2713 `js-create-instance', and `js-qi' are defined."
2724 function)
2732 function)
2764 props)
2766 ))
2772 "Whether to listify any Array returned by a Mozilla function.
2783 js--js-references)
2788 js--js-references)))
2793 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2794 If function is a string, look it up as a property on the global
2795 object and use the global object for `this'.
2796 If FUNCTION is a list with one element, use that element as the
2797 function with the global object for `this', except that if that
2798 single element is a string, look it up on the global object.
2799 If FUNCTION is a list with more than one argument, use the list
2800 up to the last value as a property descriptor and the last
2801 argument as a function."
2808 ;; Actual funcall
2815 js-js-timeout)
2818 ;; Read the result
2825 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2826 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2829 constructor arguments))
2835 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2838 arguments)))
2847 "Tell the repl about any objects we don't reference anymore.
2848 With argument, run even if no intervening GC has happened."
2859 ;; Don't bother running unless we've had an intervening
2860 ;; garbage collection; without a gc, nothing is deleted
2861 ;; from the weak hash table, so it's pointless telling
2862 ;; MozRepl about that references we still hold
2865 ;; Are we looking at a normal prompt? Make sure not to
2866 ;; interrupt the user if he's doing something
2874 of js--js-references
2875 collect x))
2882 num)))
2887 "Evaluate the JavaScript in JS and return JSON-decoded result."
2895 result)))
2898 "Enumerate all JavaScript contexts available.
2899 Each context is a list:
2900 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2901 (TITLE URL WINDOW) for windows
2903 All tabs of a given window are grouped together. The most recent
2904 window is first. Within each window, the tabs are returned
2905 left-to-right."
2910 "@mozilla.org/appshell/window-mediator;1"
2932 window)
2939 "browsers"
2940 x
2941 "contentDocument"
2945 "browsers"
2946 x
2947 "contentWindow"
2948 "location"
2951 "browsers"
2952 x)
2955 "tabContainer"
2956 "childNodes"
2958 x)
2960 gbrowser))))))
2965 "Read a Mozilla tab with prompt PROMPT.
2966 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
2967 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
2968 browser, respectively."
2970 ;; Prime IDO
2977 selected-tab prev-hitab)
2979 ;; Disambiguate names
2981 for tab in tabs
2997 ;; Hack to reduce the number of
2998 ;; round-trips to mozilla
3001 ;; Highlighting tab
3004 "style"
3006 cmds)
3008 ;; Highlight window proper
3011 "style"
3013 cmds)
3015 ;; Select tab, when appropriate
3019 cmds)))
3021 ;; Hilighting whole window
3025 "style"
3028 cmds)))
3031 ;; Unhighlighting tab
3034 cmds)
3036 cmds))
3038 ;; Unhighlighting window
3043 cmds)))
3049 ()
3055 ()
3056 ;; Fiddle with the match list a bit: if our first match
3057 ;; is a tabbrowser window, rotate the match list until
3058 ;; the active tab comes up
3064 "document"
3065 "documentElement"
3070 "gBrowser"
3074 for match in ido-matches
3078 and return t)))
3088 prompt
3090 nil t nil
3108 "Helper function for `js-eval-defun'.
3109 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3110 strings making up the class name and NAME is the name of the
3111 function part."
3130 "The current JavaScript context.
3131 This is a cons like the one returned from `js--read-tab'.
3135 "(function(func_info,func) {
3136 func_info.unshift('window');
3137 var obj = window;
3138 for(var i = 1; i < func_info.length - 1; ++i) {
3139 var next = obj[func_info[i]];
3140 if(typeof next !== 'object' && typeof next !== 'function') {
3141 next = obj.prototype && obj.prototype[func_info[i]];
3142 if(typeof next !== 'object' && typeof next !== 'function') {
3143 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3144 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3145 return;
3146 }
3148 func_info.splice(i+1, 0, 'prototype');
3149 ++i;
3150 }
3151 }
3153 obj[func_info[i]] = func;
3154 alert('Successfully updated '+func_info.join('.'));
3158 "Set the JavaScript context to CONTEXT.
3159 When called interactively, prompt for CONTEXT."
3164 "Return a valid JavaScript context.
3165 If one hasn't been set, or if it's stale, prompt for a new one."
3174 js--js-context))
3188 file)))
3201 "Update a Mozilla tab using the JavaScript defun at point."
3204 ;; This function works by generating a temporary file that contains
3205 ;; the function we'd like to insert. We then use the elisp-js bridge
3206 ;; to command mozilla to load this file by inserting a script tag
3207 ;; into the document we set. This way, debuggers and such will have
3208 ;; a way to find the source of the just-inserted function.
3209 ;;
3210 ;; We delete the temporary file if there's an error, but otherwise
3211 ;; we add an unload event listener on the Mozilla side to delete the
3212 ;; file.
3243 ;; (Re)register a Mozilla resource URL to point to the
3244 ;; temporary directory
3262 ;; Give Mozilla responsibility for deleting this file
3267 ;; Regular content
3271 ;; Chrome
3293 ))
3295 ;; temp-name is set to nil on success
3299 ;;; Main Function
3301 ;;;###autoload
3303 "Major mode for editing JavaScript.
3305 Key bindings:
3310 :syntax-table js-mode-syntax-table
3321 nil nil nil nil
3323 . js-font-lock-syntactic-keywords)))
3330 ;; Comments
3336 ;; Parse cache
3339 ;; Frameworks
3342 ;; Imenu
3350 ;; for filling, pretend we're cc-mode
3352 c-paragraph-start "$"
3353 c-paragraph-separate "$"
3354 c-block-comment-prefix "* "
3355 c-line-comment-starter "//"
3360 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3361 ;; we call it instead? (Bug#6071)
3372 ;; Important to fontify the whole buffer syntactically! If we don't,
3373 ;; then we might have regular expression literals that aren't marked
3374 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3375 ;; etc. and and produce maddening "unbalanced parenthesis" errors.
3376 ;; When we attempt to find the error and scroll to the portion of
3377 ;; the buffer containing the problem, JIT-lock will apply the
3378 ;; correct syntax to the regular expresion literal and the problem
3379 ;; will mysteriously disappear.
3385 ;;;###autoload
3394 ;; arch-tag: 1a0d0409-e87f-4fc7-a58c-3731c66ddaac
3395 ;; js.el ends here