unofficial mirror of bug-gnu-emacs@gnu.org 
 help / color / mirror / code / Atom feed
blob 9420323c7e19b0010e044f8392aa93de84711369 5912 bytes (raw)
name: lisp/cedet/semantic/wisent/javascript.el 	 # note: path name is non-authoritative(*)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
;;; semantic/wisent/javascript.el --- javascript parser support  -*- lexical-binding: t; -*-

;; Copyright (C) 2005, 2009-2024 Free Software Foundation, Inc.

;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.

;;; Commentary:
;;
;; Parser support for javascript language.


;;; Code:
(require 'semantic/java)
(require 'semantic/wisent)
(require 'semantic/wisent/js-wy)

(defun wisent-javascript-jv-expand-tag (tag)
  "Expand TAG into a list of equivalent tags, or nil.
Expand multiple variable declarations in the same statement, that is
tags of class `variable' whose name is equal to a list of elements of
the form (NAME VALUE START . END).  NAME is a variable name.  VALUE is
an initializer START and END are the bounds in the declaration, related
to this variable NAME."
  (let (elts elt value clone start end xpand)
    (when (and (eq 'variable (semantic-tag-class tag))
               (consp (setq elts (semantic-tag-name tag))))
      ;; There are multiple names in the same variable declaration.
      (while elts
        ;; For each name element, clone the initial tag and give it
        ;; the name of the element.
        (setq elt   (car elts)
              elts  (cdr elts)
              clone (semantic-tag-clone tag (car elt))
	      value (car (cdr elt))
	      start (if elts  (car (cddr elt)) (semantic-tag-start tag))
	      end   (if xpand (cdr (cddr elt)) (semantic-tag-end   tag))
              xpand (cons clone xpand))
        ;; Set the definition of the cloned tag
        (semantic-tag-put-attribute clone :default-value value)
        ;; Set the bounds of the cloned tag with those of the name
        ;; element.
        (semantic-tag-set-bounds clone start end))
      xpand)))

;;; Override Methods
;;
;; These methods override aspects of how semantic-tools can access
;; the tags created by the javascript parser.
;; Local context
(define-mode-local-override semantic-get-local-variables
  js-mode ()
  "Get local values from a specific context.
This function overrides `get-local-variables'."
  ;; Does javascript have identifiable local variables?
  nil)

(define-mode-local-override semantic-tag-protection js-mode (_tag &optional _parent)
  "Return protection information about TAG with optional PARENT.
This function returns on of the following symbols:
   nil         - No special protection.  Language dependent.
   `public'    - Anyone can access this TAG.
   `private'   - Only methods in the local scope can access TAG.
   `protected' - Like private for outside scopes, like public for child
                 classes.
Some languages may choose to provide additional return symbols specific
to themselves.  Use of this function should allow for this.

The default behavior (if not overridden with `tag-protection'
is to return a symbol based on type modifiers."
  nil)

(define-mode-local-override semantic-analyze-scope-calculate-access js-mode (_type _scope)
  "Calculate the access class for TYPE as defined by the current SCOPE.
Access is related to the :parents in SCOPE.  If type is a member of SCOPE
then access would be `private'.  If TYPE is inherited by a member of SCOPE,
the access would be `protected'.  Otherwise, access is `public'."
  nil)

(define-mode-local-override semantic-ctxt-current-symbol js-mode (&optional point)
  "Return the current symbol the cursor is on at POINT in a list.
This is a very simple implementation for Javascript symbols.  It
will at maximum do one split, so that the first part is seen as
one type.  For example:  $('#sel').foo.bar will return (\"$('sel').foo\" \"bar\").
This is currently needed for the mozrepl omniscient database."
  (save-excursion
    (if point (goto-char point))
    (let* ((case-fold-search semantic-case-fold)
	   tmp end) ;; symlist
      (with-syntax-table semantic-lex-syntax-table
	(save-excursion
	  (when (looking-at "\\w\\|\\s_")
	    (forward-sexp 1))
	  (setq end (point))
          (unless (re-search-backward "\\s-" (line-beginning-position) t)
	    (beginning-of-line))
	  (setq tmp (buffer-substring-no-properties (point) end))
	  ;; (setq symlist
	  (if (string-match "\\(.+\\)\\." tmp)
	      (list (match-string 1 tmp)
		    (substring tmp (1+ (match-end 1)) (length tmp)))
	    (list tmp)))))));; )

;;; Setup Function
;;

;; In semantic-imenu.el, not part of Emacs.
(defvar semantic-imenu-summary-function)

;;;###autoload
(defun wisent-javascript-setup-parser ()
  "Setup buffer for parse."
  (wisent-javascript-jv-wy--install-parser)
  (setq
   ;; Lexical Analysis
   semantic-lex-analyzer #'javascript-lexer-jv
   semantic-lex-number-expression semantic-java-number-regexp
   ;; semantic-lex-depth nil ;; Full lexical analysis
   ;; Parsing
   semantic-tag-expand-function #'wisent-javascript-jv-expand-tag
   ;; Environment
   semantic-imenu-summary-function #'semantic-format-tag-name
   semantic--create-index-function-origin imenu-create-index-function
   imenu-create-index-function #'semantic-create-imenu-index
   semantic-command-separation-character ";"
   ))

(provide 'semantic/wisent/javascript-jv)

;; Local variables:
;; generated-autoload-file: "../loaddefs.el"
;; generated-autoload-load-name: "semantic/wisent/javascript"
;; End:

;;; semantic/wisent/javascript-jv.el ends here

debug log:

solving 9420323c7e1 ...
found 9420323c7e1 in https://yhetil.org/emacs-bugs/TYCPR01MB1000493E60747FE15AB458E9AFB3E2@TYCPR01MB10004.jpnprd01.prod.outlook.com/
found 7a1a8637aae in https://git.savannah.gnu.org/cgit/emacs.git
preparing index
index prepared:
100644 7a1a8637aae84705efd0477bd871001684e670bb	lisp/cedet/semantic/wisent/javascript.el

applying [1/1] https://yhetil.org/emacs-bugs/TYCPR01MB1000493E60747FE15AB458E9AFB3E2@TYCPR01MB10004.jpnprd01.prod.outlook.com/
diff --git a/lisp/cedet/semantic/wisent/javascript.el b/lisp/cedet/semantic/wisent/javascript.el
index 7a1a8637aae..9420323c7e1 100644

Checking patch lisp/cedet/semantic/wisent/javascript.el...
Applied patch lisp/cedet/semantic/wisent/javascript.el cleanly.

index at:
100644 9420323c7e19b0010e044f8392aa93de84711369	lisp/cedet/semantic/wisent/javascript.el

(*) Git path names are given by the tree(s) the blob belongs to.
    Blobs themselves have no identifier aside from the hash of its contents.^

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).