| blob | 28ee859f9dbf3e26e28d9c1dbc0c5b08cf802107 |
1 ;;; js.el --- Major mode for editing JavaScript -*- lexical-binding: t -*-
3 ;; Copyright (C) 2008-2013 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:
67 ;;; Constants
89 "Regexp matching the prefix of a cpp directive.
90 This includes the directive name, or nil in languages without
91 preprocessor support. The first submatch surrounds the directive
98 Group 1 is a (possibly-dotted) class name, group 2 is a method name,
107 ;; var NewClass = BaseClass.extend(
115 ;; var NewClass = Class.create()
131 ;; var NewClass = Class.create({
138 ;; Parent class name(s) (yes, multiple inheritance in JavaScript) are
139 ;; matched with dedicated font-lock matchers
167 :prototype t
173 :prototype t
189 :prototype t
195 :prototype t
206 :prototype t
220 "List of JavaScript class definition styles.
222 A class definition style is a plist with the following keys:
224 :name is a human-readable name of the class type
226 :class-decl is a regular expression giving the start of the
227 class. Its first group must match the name of its class. If there
228 is a parent class, the second group should match, and it should be
229 the name of the class.
231 If :prototype is present and non-nil, the parser will merge
232 declarations for this constructs with others at the same lexical
233 level that have the same name. Otherwise, multiple definitions
234 will create multiple top-level entries. Don't use :prototype
235 unnecessarily: it has an associated cost in performance.
237 If :strip-prototype is present and non-nil, then if the class
238 name as matched contains
245 collect framework into available-frameworks
246 finally return available-frameworks)
252 "Regexp matching the start of a JavaScript function header.
258 "Regexp matching the start of a function entry in an associative array.
270 "Regexp matching a CPP macro definition, up to the opening parenthesis.
320 ;; js--pitem is the basic building block of the lexical
321 ;; database. When one refers to a real part of the buffer, the region
322 ;; of text to which it refers is split into a conceptual header and
323 ;; body. Consider the (very short) block described by a hypothetical
324 ;; js--pitem:
325 ;;
326 ;; function foo(a,b,c) { return 42; }
327 ;; ^ ^ ^
328 ;; | | |
329 ;; +- h-begin +- h-end +- b-end
330 ;;
331 ;; (Remember that these are buffer positions, and therefore point
332 ;; between characters, not at them. An arrow drawn to a character
333 ;; indicates the corresponding position is between that character and
334 ;; the one immediately preceding it.)
335 ;;
336 ;; The header is the region of text [h-begin, h-end], and is
337 ;; the text needed to unambiguously recognize the start of the
338 ;; construct. If the entire header is not present, the construct is
339 ;; not recognized at all. No other pitems may be nested inside the
340 ;; header.
341 ;;
342 ;; The body is the region [h-end, b-end]. It may contain nested
343 ;; js--pitem instances. The body of a pitem may be empty: in
344 ;; that case, b-end is equal to header-end.
345 ;;
346 ;; The three points obey the following relationship:
347 ;;
348 ;; h-begin < h-end <= b-end
349 ;;
350 ;; We put a text property in the buffer on the character *before*
351 ;; h-end, and if we see it, on the character *before* b-end.
352 ;;
353 ;; The text property for h-end, js--pstate, is actually a list
354 ;; of all js--pitem instances open after the marked character.
355 ;;
356 ;; The text property for b-end, js--pend, is simply the
357 ;; js--pitem that ends after the marked character. (Because
358 ;; pitems always end when the paren-depth drops below a critical
359 ;; value, and because we can only drop one level per character, only
360 ;; one pitem may end at a given character.)
361 ;;
362 ;; In the structure below, we only store h-begin and (sometimes)
363 ;; b-end. We can trivially and quickly find h-end by going to h-begin
364 ;; and searching for an js--pstate text property. Since no other
365 ;; js--pitem instances can be nested inside the header of a
366 ;; pitem, the location after the character with this text property
367 ;; must be h-end.
368 ;;
369 ;; js--pitem instances are never modified (with the exception
370 ;; of the b-end field). Instead, modified copies are added at
371 ;; subsequence parse points.
372 ;; (The exception for b-end and its caveats is described below.)
373 ;;
376 ;; IMPORTANT: Do not alter the position of fields within the list.
377 ;; Various bits of code depend on their positions, particularly
378 ;; anything that manipulates the list of children.
380 ;; List of children inside this pitem's body
383 ;; When we reach this paren depth after h-end, the pitem ends
386 ;; Symbol or class-style plist if this is a class
389 ;; See above
392 ;; List of strings giving the parts of the name of this pitem (e.g.,
393 ;; '("MyClass" "myMethod"), or t if this pitem is anonymous
396 ;; THIS FIELD IS MUTATED, and its value is shared by all copies of
397 ;; this pitem: when we copy-and-modify pitem instances, we share
398 ;; their tail structures, so all the copies actually have the same
399 ;; terminating cons cell. We modify that shared cons cell directly.
400 ;;
401 ;; The field value is either a number (buffer location) or nil if
402 ;; unknown.
403 ;;
404 ;; If the field's value is greater than `js--cache-end', the
405 ;; value is stale and must be treated as if it were nil. Conversely,
406 ;; if this field is nil, it is guaranteed that this pitem is open up
407 ;; to at least `js--cache-end'. (This property is handy when
408 ;; computing whether we're inside a given pitem.)
409 ;;
412 ;; The pitem we start parsing with.
415 :paren-depth most-negative-fixnum
418 ;;; User Customization
421 "Customization variables for JavaScript mode."
426 "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'."
439 "Number of additional spaces for indenting expressions in parentheses.
440 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'."
455 "Number of additional spaces for indenting expressions in curly braces.
456 The value must be no less than minus `js-indent-level'."
463 "Whether to automatically indent when typing punctuation characters.
464 If non-nil, the characters {}();,: also indent the current line
465 in Javascript mode."
470 "Treat nested functions as top-level functions in `js-mode'.
471 This applies to function movement, marking, and so on."
476 "Lineup function for `cc-mode-style', for C comments in `js-mode'."
481 "Frameworks recognized by `js-mode'.
482 To improve performance, you may turn off some frameworks you
483 seldom use, either globally or on a per-buffer basis."
486 js--available-frameworks))
491 "Whether `js-mode' should display tabs while selecting them.
492 This is useful only if the windowing system has a good mechanism
493 for preventing Firefox from stealing the keyboard focus."
498 "~/.emacs.d/js/js"
499 "Temporary directory used by `js-mode' to communicate with Mozilla.
500 This directory must be readable and writable by both Mozilla and Emacs."
505 "Reply timeout for executing commands in Mozilla via `js-mode'.
506 The value is given in seconds. Increase this value if you are
507 getting timeout messages."
511 ;;; KeyMap
527 keymap)
530 ;;; Syntax table and parsing
536 table)
567 "Helper function for `js--update-quick-match-re'.
568 If LIST contains any element that is not nil, return its non-nil
569 elements, separated by SEPARATOR, prefixed by PREFIX, and ended
570 with SUFFIX as with `concat'. Otherwise, if LIST is empty, return
571 nil. If any element in LIST is itself a list, flatten that
572 element."
578 "Internal function used by `js-mode' for caching buffer constructs.
579 This updates `js--quick-match-re', based on the current set of
580 enabled frameworks."
585 ;; #define mumble
594 ;; var mumble = THING (
615 ;; mumble.prototypeTHING
623 ;; mumble.prototype = {
630 "Move over the next value of PROPNAME in the buffer.
631 If found, return that value and leave point after the character
632 having that value; otherwise, return nil and leave point at EOB."
643 next-value))
646 "Move over the previous value of PROPNAME in the buffer.
647 If found, return that value and leave point just before the
648 character that has that value, otherwise return nil and leave
649 point at BOB."
662 prev-value)))
675 "Helper function for `js--re-search-forward'."
677 str-terminator
706 "Search forward, ignoring strings, cpp macros, and comments.
707 This function invokes `re-search-forward', but treats the buffer
708 as if strings, cpp macros, and comments have been removed.
710 If invoked while inside a macro, it treats the contents of the
711 macro as normal text."
728 "Auxiliary function for `js--re-search-backward'."
730 str-terminator
761 "Search backward, ignoring strings, preprocessor macros, and comments.
763 This function invokes `re-search-backward' but treats the buffer
764 as if strings, preprocessor macros, and comments have been
765 removed.
767 If invoked while inside a macro, treat the macro as normal text."
771 "Move forward over a whole JavaScript expression.
772 This function doesn't move over expressions continued across
773 lines."
775 ;; non-continued case; simplistic, but good enough?
788 "Move forward over a JavaScript function declaration.
789 This puts point at the 'function' keyword.
791 If this is a syntactically-correct non-expression function,
792 return the name of the function, or t if the name could not be
793 determined. Otherwise, return nil."
806 name)))))
809 "Return the start of the JavaScript function prologue containing POS.
810 A function prologue is everything from start of the definition up
811 to and including the opening brace. POS defaults to point.
812 If POS is not in a function prologue, return nil."
839 "Helper function for `js-beginning-of-defun'.
840 Go to previous defun-beginning and return the parse state for it,
841 or nil if we went all the way back to bob and don't find
842 anything."
850 "Helper function for `js--beginning-of-defun-nested'.
851 If PSTATE represents a non-empty top-level defun, return the
852 top-most pitem. Otherwise, return nil."
855 with func-pitem
862 "Helper function for `js--beginning-of-defun'.
863 Return the pitem of the function we went to the beginning of."
865 ;; Look for the smallest function that encloses point...
870 and return pitem)
872 ;; ...and if that isn't found, look for the previous top-level
873 ;; defun
875 while pstate
878 and return it)))
881 "Helper function for `js-beginning-of-defun'."
887 "Value of `beginning-of-defun-function' for `js-mode'."
903 ;; If we're just past the end of a function, the user probably wants
904 ;; to go to the beginning of *that* function
918 "Flush the `js-mode' syntax cache after position BEG.
919 BEG defaults to `point-min', meaning to flush the entire cache."
925 ;; `(message ,@arguments)
926 )
935 ;; open-items must contain at least two items for this to
936 ;; work, but because we push a dummy item to start with,
937 ;; that assumption holds.
940 open-items)
943 "Helper function for `js--ensure-cache'.
944 Update parsing information up to point, referring to parse,
945 prev-parse-point, goal-point, and open-items bound lexically in
946 the body of `js--ensure-cache'."
953 ;; Make sure parse-partial-sexp doesn't stop because we *entered*
954 ;; the given depth -- i.e., make sure we're deeper than the target
955 ;; depth.
959 prev-parse-point goal-point
961 nil parse))
963 ;; (let ((overlay (make-overlay prev-parse-point (point))))
964 ;; (overlay-put overlay 'face '(:background "red"))
965 ;; (unwind-protect
966 ;; (progn
967 ;; (js--debug "parsed: %S" parse)
968 ;; (sit-for 1))
969 ;; (delete-overlay overlay)))
985 "Split a JavaScript name into its dot-separated parts.
986 This also removes any prototype parts from the split name
998 "Guess the name of the JavaScript function at POSITION.
1000 Return the name of the function, or nil if the name could not be
1001 guessed.
1003 This function clobbers match data. If we find the preamble
1004 begins earlier than expected while guessing the function name,
1005 set `js--guess-function-name-start' to that position; otherwise,
1006 set that variable to nil."
1023 ;; Clear any endings that occur after point
1030 ;; Remove any cache properties after this point
1035 "Ensures brace cache is valid up to the character before LIMIT.
1036 LIMIT defaults to point."
1042 parse
1043 prev-parse-point
1044 name
1045 case-fold-search
1046 filtered-class-styles
1047 goal-point)
1049 ;; Figure out which class styles we need to look for
1053 js-enabled-frameworks)
1054 collect style))
1060 ;; Find last known good position
1076 ;; Make a placeholder for the top-level definition
1092 ;; Each of these conditions should return non-nil if
1093 ;; we should add a new item and leave point at the end
1094 ;; of the new item's header (h-end in the
1095 ;; js--pitem diagram). This point is the one
1096 ;; after the last character we need to unambiguously
1097 ;; detect this construct. If one of these evaluates to
1098 ;; nil, the location of the point is ignored.
1100 ;; In comment or string
1103 ;; Regular function declaration
1112 js--guess-function-name-start))
1119 :paren-depth orig-depth
1120 :h-begin orig-match-start
1123 name
1126 ;; Macro
1129 ;; Macros often contain unbalanced parentheses.
1130 ;; Make sure that h-end is at the textual end of
1131 ;; the macro no matter what the parenthesis say.
1137 :h-begin orig-match-start
1141 ;; "Prototype function" declaration
1148 :paren-depth orig-depth
1149 :h-begin orig-match-start
1155 ;; Class definition
1157 with syntactic-context =
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).
1653 ;; FIXME: Allow regexps after infix ops like + ...
1654 ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators
1655 ;; We can probably just add +, -, !, <, >, %, ^, ~, |, &, ?, : at which
1656 ;; point I think only * and / would be missing which could also be added,
1657 ;; but need care to avoid affecting the // and */ comment markers.
1662 ;; If the / is at the beginning of line, we have to check
1663 ;; the end of the previous text.
1674 ;;; Indentation
1692 "Return non-nil if point is on a JavaScript operator, other than a comma."
1702 "Return non-nil if the current line continues an expression."
1719 Otherwise, return nil. A braceless do-while statement spanning
1720 several lines requires that the start of the loop is indented to
1721 the same column as the current line."
1743 "Helper function for `js--proper-indentation'.
1744 Return the proper indentation of the current line if it starts
1745 the body of a control statement without braces; otherwise, return
1746 nil."
1770 "Helper function for `js--proper-indentation'.
1771 Return the proper indentation of the current line if it belongs to a declaration
1772 statement spanning multiple lines; otherwise, return nil."
1801 "Return the proper indentation for the current line."
1812 ;; A single closing paren/bracket should be indented at the
1813 ;; same level as the opening statement. Same goes for
1814 ;; "case" and "default".
1828 js-expr-indent-offset))
1835 ;; If there is something following the opening
1836 ;; paren/bracket, everything else should be indented at
1837 ;; the same level.
1848 "Indent the current line as JavaScript."
1858 ;;; Filling
1862 ;; FIXME: Such redefinitions are bad style. We should try and use some other
1863 ;; way to get the same result.
1867 ad-do-it))
1872 ad-do-it))
1877 ad-do-it))
1880 "Fill the paragraph with `c-fill-paragraph'."
1886 ;;; Type database and Imenu
1888 ;; We maintain a cache of semantic information, i.e., the classes and
1889 ;; functions we've encountered so far. In order to avoid having to
1890 ;; re-parse the buffer on every change, we cache the parse state at
1891 ;; each interesting point in the buffer. Each parse state is a
1892 ;; modified copy of the previous one, or in the case of the first
1893 ;; parse state, the empty state.
1894 ;;
1895 ;; The parse state itself is just a stack of js--pitem
1896 ;; instances. It starts off containing one element that is never
1897 ;; closed, that is initially js--initial-pitem.
1898 ;;
1906 name
1908 type
1912 "Helper function for `js--splice-into-items'.
1913 Return a new item that is the result of merging CHILD into
1914 ITEM. NAME-PARTS is a list of parts of the name of CHILD
1915 that we haven't consumed yet."
1920 ;; If the item we're merging into isn't a class, make it into one
1926 ;; Use the child's class-style if it's available
1928 js--dummy-class-style
1933 ;; Now we can merge either a function or a class into a class
1937 ;; if we have more name-parts to go before we get to the
1938 ;; bottom of the class hierarchy, call the merger
1939 ;; recursively
1945 ;; Not merging a class, but something else, so just prepend
1946 ;; it
1950 ;; Otherwise, merge the new child's items into those
1951 ;; of the new class
1957 "Last part of the name of PITEM, as a string or symbol."
1961 name)))
1964 "Splice CHILD into the `js--pitem' ITEMS at NAME-PARTS.
1965 If a class doesn't exist in the tree, create it. Return
1966 the new items list. NAME-PARTS is a list of strings given
1967 the broken-down class name of the item to insert."
1971 new-items last-new-item new-cons)
1974 name-parts
1980 ;; If top-name isn't found in items, then we build a copy of items
1981 ;; and throw it away. But that's okay, since most of the time, we
1982 ;; *will* find an instance.
1986 ;; Okay, we found an entry with the right name. Splice
1987 ;; the merged item into the list...
1990 name-parts)
1997 ;; ...and terminate the loop
1998 nil)
2001 ;; Otherwise, copy the current cons and move onto the
2002 ;; text. This is tricky; we keep track of the tail of
2003 ;; the list that begins with new-items in
2004 ;; last-new-item.
2011 ;; Go to the next cell in items
2015 ;; Yay! We stopped because we found something, not because
2016 ;; we ran out of items to search. Just return the new
2017 ;; list.
2020 new-items)
2022 ;; We didn't find anything. If the child is a class and we don't
2023 ;; have any classes to drill down into, just push that class;
2024 ;; otherwise, make a fake class and carry on.
2027 ;; We have name-parts left to process. Make a fake
2028 ;; class for this particular part...
2030 ;; ...and recursively digest the rest of the name
2033 :type js--dummy-class-style
2036 ;; Otherwise, this is the only name we have, so stick
2037 ;; the item on the front of the list
2038 child)
2039 items))))
2042 "Copy `js--pitem' PITEM, and push CHILD onto its list of children."
2047 t))
2049 ;; This trick works because we know (based on our defstructs) that
2050 ;; the child list is always the first element, and so the second
2051 ;; element and beyond can be shared when we make our "copy".
2058 ;; Use slow path because we need class lookup
2064 ;; Use slow path because we need class merging. We know
2065 ;; name is a list here because down in
2066 ;; `js--ensure-cache', we made sure to only add
2067 ;; class entries with lists for :name
2072 ;; Fast path
2078 "Return a marker for LOCATION if `imenu-use-markers' is non-nil."
2081 location))
2084 "Convert PITEMS, a list of `js--pitem' structures, to imenu format."
2101 imenu-items))
2106 unknown-ctr))
2109 imenu-items))
2118 imenu-items))))
2122 imenu-items))
2125 "Return an imenu index for the current buffer."
2137 ;; Make sure everything is closed
2145 ;; Convert the new-finalized state into what imenu expects
2148 unknown-ctr))))))
2150 ;; Silence the compiler.
2161 symbols)
2162 else
2173 "Return a hash table of all JavaScript symbols.
2174 This searches all existing `js-mode' buffers. Each key is the
2175 name of a symbol (possibly disambiguated with <N>, where N > 1),
2176 and each value is a marker giving the location of that symbol."
2178 with imenu-use-markers = t
2179 for buffer being the buffers
2184 finally return symbols))
2190 "Helper function for `js-find-symbol'.
2191 Read a symbol from SYMBOLS-TABLE, which is a hash table like the
2192 one from `js--get-all-known-symbols', using prompt PROMPT and
2193 initial input INITIAL-INPUT. Return a cons of (SYMBOL-NAME
2194 . LOCATION), where SYMBOL-NAME is a string and LOCATION is a
2195 marker."
2201 prompt
2203 collect key)
2219 ;; etags loads ring.
2223 "Read a JavaScript symbol and jump to it.
2224 With a prefix argument, restrict symbols to those from the
2225 current buffer. Pushes a mark onto the tag ring just like
2226 `find-tag'."
2237 symbols "Jump to: "
2245 ;;; MozRepl integration
2255 "Wait TIMEOUT seconds for PROCESS to output a match for REGEXP.
2256 On timeout, return nil. On success, return t with match data
2257 set. If START is non-nil, look for output starting from START.
2258 Otherwise, use the current value of `process-mark'."
2270 'js-moz-bad-rpc
2274 ;; Integer, mirrors the value we see in JS
2277 ;; Process to which this thing belongs
2298 ; */" Make Emacs happy
2299 "(function(repl) {
2300 repl.defineInteractor('js', {
2301 onStart: function onStart(repl) {
2302 if(!repl._jsObjects) {
2303 repl._jsObjects = {};
2304 repl._jsLastID = 0;
2305 repl._jsGC = this._jsGC;
2306 }
2307 this._input = '';
2308 },
2310 _jsGC: function _jsGC(ids_in_use) {
2311 var objects = this._jsObjects;
2312 var keys = [];
2313 var num_freed = 0;
2315 for(var pn in objects) {
2316 keys.push(Number(pn));
2317 }
2319 keys.sort(function(x, y) x - y);
2320 ids_in_use.sort(function(x, y) x - y);
2321 var i = 0;
2322 var j = 0;
2324 while(i < ids_in_use.length && j < keys.length) {
2325 var id = ids_in_use[i++];
2326 while(j < keys.length && keys[j] !== id) {
2327 var k_id = keys[j++];
2328 delete objects[k_id];
2329 ++num_freed;
2330 }
2331 ++j;
2332 }
2334 while(j < keys.length) {
2335 var k_id = keys[j++];
2336 delete objects[k_id];
2337 ++num_freed;
2338 }
2340 return num_freed;
2341 },
2343 _mkArray: function _mkArray() {
2344 var result = [];
2345 for(var i = 0; i < arguments.length; ++i) {
2346 result.push(arguments[i]);
2347 }
2348 return result;
2349 },
2351 _parsePropDescriptor: function _parsePropDescriptor(parts) {
2352 if(typeof parts === 'string') {
2353 parts = [ parts ];
2354 }
2356 var obj = parts[0];
2357 var start = 1;
2359 if(typeof obj === 'string') {
2360 obj = window;
2361 start = 0;
2362 } else if(parts.length < 2) {
2363 throw new Error('expected at least 2 arguments');
2364 }
2366 for(var i = start; i < parts.length - 1; ++i) {
2367 obj = obj[parts[i]];
2368 }
2370 return [obj, parts[parts.length - 1]];
2371 },
2373 _getProp: function _getProp(/*...*/) {
2374 if(arguments.length === 0) {
2375 throw new Error('no arguments supplied to getprop');
2376 }
2378 if(arguments.length === 1 &&
2379 (typeof arguments[0]) !== 'string')
2380 {
2381 return arguments[0];
2382 }
2384 var [obj, propname] = this._parsePropDescriptor(arguments);
2385 return obj[propname];
2386 },
2388 _putProp: function _putProp(properties, value) {
2389 var [obj, propname] = this._parsePropDescriptor(properties);
2390 obj[propname] = value;
2391 },
2393 _delProp: function _delProp(propname) {
2394 var [obj, propname] = this._parsePropDescriptor(arguments);
2395 delete obj[propname];
2396 },
2398 _typeOf: function _typeOf(thing) {
2399 return typeof thing;
2400 },
2402 _callNew: function(constructor) {
2403 if(typeof constructor === 'string')
2404 {
2405 constructor = window[constructor];
2406 } else if(constructor.length === 1 &&
2407 typeof constructor[0] !== 'string')
2408 {
2409 constructor = constructor[0];
2410 } else {
2411 var [obj,propname] = this._parsePropDescriptor(constructor);
2412 constructor = obj[propname];
2413 }
2415 /* Hacky, but should be robust */
2416 var s = 'new constructor(';
2417 for(var i = 1; i < arguments.length; ++i) {
2418 if(i != 1) {
2419 s += ',';
2420 }
2422 s += 'arguments[' + i + ']';
2423 }
2425 s += ')';
2426 return eval(s);
2427 },
2429 _callEval: function(thisobj, js) {
2430 return eval.call(thisobj, js);
2431 },
2433 getPrompt: function getPrompt(repl) {
2434 return 'EVAL>'
2435 },
2437 _lookupObject: function _lookupObject(repl, id) {
2438 if(typeof id === 'string') {
2439 switch(id) {
2440 case 'global':
2441 return window;
2442 case 'nil':
2443 return null;
2444 case 't':
2445 return true;
2446 case 'false':
2447 return false;
2448 case 'undefined':
2449 return undefined;
2450 case 'repl':
2451 return repl;
2452 case 'interactor':
2453 return this;
2454 case 'NaN':
2455 return NaN;
2456 case 'Infinity':
2457 return Infinity;
2458 case '-Infinity':
2459 return -Infinity;
2460 default:
2461 throw new Error('No object with special id:' + id);
2462 }
2463 }
2465 var ret = repl._jsObjects[id];
2466 if(ret === undefined) {
2467 throw new Error('No object with id:' + id + '(' + typeof id + ')');
2468 }
2469 return ret;
2470 },
2472 _findOrAllocateObject: function _findOrAllocateObject(repl, value) {
2473 if(typeof value !== 'object' && typeof value !== 'function') {
2474 throw new Error('_findOrAllocateObject called on non-object('
2475 + typeof(value) + '): '
2476 + value)
2477 }
2479 for(var id in repl._jsObjects) {
2480 id = Number(id);
2481 var obj = repl._jsObjects[id];
2482 if(obj === value) {
2483 return id;
2484 }
2485 }
2487 var id = ++repl._jsLastID;
2488 repl._jsObjects[id] = value;
2489 return id;
2490 },
2492 _fixupList: function _fixupList(repl, list) {
2493 for(var i = 0; i < list.length; ++i) {
2494 if(list[i] instanceof Array) {
2495 this._fixupList(repl, list[i]);
2496 } else if(typeof list[i] === 'object') {
2497 var obj = list[i];
2498 if(obj.funcall) {
2499 var parts = obj.funcall;
2500 this._fixupList(repl, parts);
2501 var [thisobj, func] = this._parseFunc(parts[0]);
2502 list[i] = func.apply(thisobj, parts.slice(1));
2503 } else if(obj.objid) {
2504 list[i] = this._lookupObject(repl, obj.objid);
2505 } else {
2506 throw new Error('Unknown object type: ' + obj.toSource());
2507 }
2508 }
2509 }
2510 },
2512 _parseFunc: function(func) {
2513 var thisobj = null;
2515 if(typeof func === 'string') {
2516 func = window[func];
2517 } else if(func instanceof Array) {
2518 if(func.length === 1 && typeof func[0] !== 'string') {
2519 func = func[0];
2520 } else {
2521 [thisobj, func] = this._parsePropDescriptor(func);
2522 func = thisobj[func];
2523 }
2524 }
2526 return [thisobj,func];
2527 },
2529 _encodeReturn: function(value, array_as_mv) {
2530 var ret;
2532 if(value === null) {
2533 ret = ['special', 'null'];
2534 } else if(value === true) {
2535 ret = ['special', 'true'];
2536 } else if(value === false) {
2537 ret = ['special', 'false'];
2538 } else if(value === undefined) {
2539 ret = ['special', 'undefined'];
2540 } else if(typeof value === 'number') {
2541 if(isNaN(value)) {
2542 ret = ['special', 'NaN'];
2543 } else if(value === Infinity) {
2544 ret = ['special', 'Infinity'];
2545 } else if(value === -Infinity) {
2546 ret = ['special', '-Infinity'];
2547 } else {
2548 ret = ['atom', value];
2549 }
2550 } else if(typeof value === 'string') {
2551 ret = ['atom', value];
2552 } else if(array_as_mv && value instanceof Array) {
2553 ret = ['array', value.map(this._encodeReturn, this)];
2554 } else {
2555 ret = ['objid', this._findOrAllocateObject(repl, value)];
2556 }
2558 return ret;
2559 },
2561 _handleInputLine: function _handleInputLine(repl, line) {
2562 var ret;
2563 var array_as_mv = false;
2565 try {
2566 if(line[0] === '*') {
2567 array_as_mv = true;
2568 line = line.substring(1);
2569 }
2570 var parts = eval(line);
2571 this._fixupList(repl, parts);
2572 var [thisobj, func] = this._parseFunc(parts[0]);
2573 ret = this._encodeReturn(
2574 func.apply(thisobj, parts.slice(1)),
2575 array_as_mv);
2576 } catch(x) {
2577 ret = ['error', x.toString() ];
2578 }
2580 var JSON = Components.classes['@mozilla.org/dom/json;1'].createInstance(Components.interfaces.nsIJSON);
2581 repl.print(JSON.encode(ret));
2582 repl._prompt();
2583 },
2585 handleInput: function handleInput(repl, chunk) {
2586 this._input += chunk;
2587 var match, line;
2589 line = match[0];
2592 repl.popInteractor();
2593 repl._prompt();
2594 return;
2595 }
2597 this._input = this._input.substring(line.length);
2598 this._handleInputLine(repl, line);
2599 }
2600 }
2601 });
2602 })
2608 "Marshall the given value for JS.
2609 Strings and numbers are JSON-encoded. Lists (including nil) are
2610 made into JavaScript array literals and their contents encoded
2611 with `js--js-encode-value'."
2638 js--js-repl-prompt-regexp js-js-timeout
2640 ;; start matching against the beginning of the line in
2641 ;; order to catch a prompt that's only partially arrived
2644 ;; Presumably "inferior-moz-process" loads comint.
2654 ;; Do some initialization the first time we see a process
2660 ;; Send interactor definition
2666 js-js-timeout))
2668 ;; Sanity check
2674 ;; If js--js-repl-depth > 0, we *should* be seeing an
2675 ;; EVAL> prompt. If we don't, give Mozilla a chance to catch
2676 ;; up with us.
2679 ;; Otherwise, tell Mozilla to enter the interactor mode
2685 js-js-timeout))
2699 js-js-timeout))))
2707 ;; The somewhat complex code layout confuses the byte-compiler into
2708 ;; thinking this function "might not be defined at runtime".
2713 "Convert immediate js< and js! references to deferred ones."
2737 function))
2739 else
2740 collect item)))
2755 "Run FORMS with the Mozilla repl set up for js commands.
2756 Inside the lexical scope of `with-js', `js?', `js!',
2757 `js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',
2758 `js-create-instance', and `js-qi' are defined."
2769 function)
2777 function)
2809 props)
2811 ))
2817 "Whether to listify any Array returned by a Mozilla function.
2824 (`array
2826 (`objid
2828 js--js-references)
2833 js--js-references)))
2841 "Call the Mozilla function FUNCTION with arguments ARGUMENTS.
2842 If function is a string, look it up as a property on the global
2843 object and use the global object for `this'.
2844 If FUNCTION is a list with one element, use that element as the
2845 function with the global object for `this', except that if that
2846 single element is a string, look it up on the global object.
2847 If FUNCTION is a list with more than one argument, use the list
2848 up to the last value as a property descriptor and the last
2849 argument as a function."
2856 ;; Actual funcall
2863 js-js-timeout)
2866 ;; Read the result
2873 "Call CONSTRUCTOR as a constructor, with arguments ARGUMENTS.
2874 CONSTRUCTOR is a JS handle, a string, or a list of these things."
2877 constructor arguments))
2883 "Return a Lisp array resulting from evaluating each of ARGUMENTS."
2886 arguments)))
2895 "Tell the repl about any objects we don't reference anymore.
2896 With argument, run even if no intervening GC has happened."
2907 ;; Don't bother running unless we've had an intervening
2908 ;; garbage collection; without a gc, nothing is deleted
2909 ;; from the weak hash table, so it's pointless telling
2910 ;; MozRepl about that references we still hold
2913 ;; Are we looking at a normal prompt? Make sure not to
2914 ;; interrupt the user if he's doing something
2922 of js--js-references
2923 collect x))
2930 num)))
2935 "Evaluate the JavaScript in JS and return JSON-decoded result."
2943 result)))
2946 "Enumerate all JavaScript contexts available.
2947 Each context is a list:
2948 (TITLE URL BROWSER TAB TABBROWSER) for content documents
2949 (TITLE URL WINDOW) for windows
2951 All tabs of a given window are grouped together. The most recent
2952 window is first. Within each window, the tabs are returned
2953 left-to-right."
2958 "@mozilla.org/appshell/window-mediator;1"
2980 window)
2987 "browsers"
2988 x
2989 "contentDocument"
2993 "browsers"
2994 x
2995 "contentWindow"
2996 "location"
2999 "browsers"
3000 x)
3003 "tabContainer"
3004 "childNodes"
3006 x)
3008 gbrowser))))))
3015 "Read a Mozilla tab with prompt PROMPT.
3016 Return a cons of (TYPE . OBJECT). TYPE is either 'window or
3017 'tab, and OBJECT is a JavaScript handle to a ChromeWindow or a
3018 browser, respectively."
3020 ;; Prime IDO
3027 selected-tab prev-hitab)
3029 ;; Disambiguate names
3032 for tab in tabs
3050 ;; Hack to reduce the number of
3051 ;; round-trips to mozilla
3054 ;; Highlighting tab
3057 "style"
3059 cmds)
3061 ;; Highlight window proper
3064 "style"
3066 cmds)
3068 ;; Select tab, when appropriate
3072 cmds)))
3074 ;; Highlighting whole window
3078 "style"
3081 cmds)))
3084 ;; Unhighlighting tab
3087 cmds)
3089 cmds))
3091 ;; Unhighlighting window
3096 cmds)))
3102 ()
3108 ()
3109 ;; Fiddle with the match list a bit: if our first match
3110 ;; is a tabbrowser window, rotate the match list until
3111 ;; the active tab comes up
3117 "document"
3118 "documentElement"
3123 "gBrowser"
3126 for match in ido-matches
3131 and return t)))
3141 prompt
3143 nil t nil
3160 "Helper function for `js-eval-defun'.
3161 Return a list (NAME . CLASSPARTS), where CLASSPARTS is a list of
3162 strings making up the class name and NAME is the name of the
3163 function part."
3182 "The current JavaScript context.
3183 This is a cons like the one returned from `js--read-tab'.
3187 "(function(func_info,func) {
3188 func_info.unshift('window');
3189 var obj = window;
3190 for(var i = 1; i < func_info.length - 1; ++i) {
3191 var next = obj[func_info[i]];
3192 if(typeof next !== 'object' && typeof next !== 'function') {
3193 next = obj.prototype && obj.prototype[func_info[i]];
3194 if(typeof next !== 'object' && typeof next !== 'function') {
3195 alert('Could not find ' + func_info.slice(0, i+1).join('.') +
3196 ' or ' + func_info.slice(0, i+1).join('.') + '.prototype');
3197 return;
3198 }
3200 func_info.splice(i+1, 0, 'prototype');
3201 ++i;
3202 }
3203 }
3205 obj[func_info[i]] = func;
3206 alert('Successfully updated '+func_info.join('.'));
3210 "Set the JavaScript context to CONTEXT.
3211 When called interactively, prompt for CONTEXT."
3216 "Return a valid JavaScript context.
3217 If one hasn't been set, or if it's stale, prompt for a new one."
3227 js--js-context))
3242 file)))
3255 "Update a Mozilla tab using the JavaScript defun at point."
3258 ;; This function works by generating a temporary file that contains
3259 ;; the function we'd like to insert. We then use the elisp-js bridge
3260 ;; to command mozilla to load this file by inserting a script tag
3261 ;; into the document we set. This way, debuggers and such will have
3262 ;; a way to find the source of the just-inserted function.
3263 ;;
3264 ;; We delete the temporary file if there's an error, but otherwise
3265 ;; we add an unload event listener on the Mozilla side to delete the
3266 ;; file.
3297 ;; (Re)register a Mozilla resource URL to point to the
3298 ;; temporary directory
3316 ;; Give Mozilla responsibility for deleting this file
3321 ;; Regular content
3325 ;; Chrome
3347 ))
3349 ;; temp-name is set to nil on success
3353 ;;; Main Function
3355 ;;;###autoload
3357 "Major mode for editing JavaScript."
3370 ;; Comments
3375 ;; Parse cache
3378 ;; Frameworks
3381 ;; Imenu
3385 ;; for filling, pretend we're cc-mode
3387 c-paragraph-start "$"
3388 c-paragraph-separate "$"
3389 c-block-comment-prefix "* "
3390 c-line-comment-starter "//"
3400 ;; FIXME: These are normally set by `c-basic-common-init'. Should
3401 ;; we call it instead? (Bug#6071)
3411 ;; Important to fontify the whole buffer syntactically! If we don't,
3412 ;; then we might have regular expression literals that aren't marked
3413 ;; as strings, which will screw up parse-partial-sexp, scan-lists,
3414 ;; etc. and produce maddening "unbalanced parenthesis" errors.
3415 ;; When we attempt to find the error and scroll to the portion of
3416 ;; the buffer containing the problem, JIT-lock will apply the
3417 ;; correct syntax to the regular expression literal and the problem
3418 ;; will mysteriously disappear.
3419 ;; FIXME: We should actually do this fontification lazily by adding
3420 ;; calls to syntax-propertize wherever it's really needed.
3423 ;;;###autoload (defalias 'javascript-mode 'js-mode)
3431 ;; js.el ends here