[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] trunk r115495: Merge from CEDET upstream.
|
From: |
David Engster |
|
Subject: |
[Emacs-diffs] trunk r115495: Merge from CEDET upstream. |
|
Date: |
Thu, 12 Dec 2013 22:10:55 +0000 |
|
User-agent: |
Bazaar (2.6b2) |
------------------------------------------------------------
revno: 115495 [merge]
revision-id: address@hidden
parent: address@hidden
parent: address@hidden
committer: David Engster <address@hidden>
branch nick: trunk
timestamp: Thu 2013-12-12 23:09:15 +0100
message:
Merge from CEDET upstream.
modified:
admin/ChangeLog changelog-20091113204419-o5vbwnq5f7feedwu-2226
admin/grammars/c.by c.by-20110730020351-lkqh5evroiy9byav-4
lisp/cedet/ChangeLog changelog-20100919015713-3rbr456yray5m84f-1
lisp/cedet/ede/generic.el generic.el-20100921014038-cmeeiezf6hlvwp28-1
lisp/cedet/ede/linux.el linux.el-20091113204419-o5vbwnq5f7feedwu-11210
lisp/cedet/semantic/analyze.el
analyze.el-20091113204419-o5vbwnq5f7feedwu-11237
lisp/cedet/semantic/analyze/refs.el
refs.el-20091113204419-o5vbwnq5f7feedwu-11242
lisp/cedet/semantic/bovine/c.el c.el-20091113204419-o5vbwnq5f7feedwu-11246
lisp/cedet/semantic/bovine/gcc.el gcc.el-20091113204419-o5vbwnq5f7feedwu-11249
lisp/cedet/semantic/ctxt.el ctxt.el-20091113204419-o5vbwnq5f7feedwu-11256
lisp/cedet/semantic/db-mode.el dbmode.el-20091113204419-o5vbwnq5f7feedwu-11264
lisp/cedet/semantic/db.el db.el-20091113204419-o5vbwnq5f7feedwu-11267
lisp/cedet/semantic/decorate/include.el
include.el-20091113204419-o5vbwnq5f7feedwu-11271
lisp/cedet/semantic/decorate/mode.el
mode.el-20091113204419-o5vbwnq5f7feedwu-11272
lisp/cedet/semantic/format.el format.el-20091113204419-o5vbwnq5f7feedwu-11278
lisp/cedet/semantic/lex-spp.el lexspp.el-20091113204419-o5vbwnq5f7feedwu-11287
lisp/cedet/semantic/scope.el scope.el-20091113204419-o5vbwnq5f7feedwu-11291
=== modified file 'admin/ChangeLog'
--- a/admin/ChangeLog 2013-12-12 08:54:21 +0000
+++ b/admin/ChangeLog 2013-12-12 22:09:15 +0000
@@ -1,3 +1,18 @@
+2013-12-12 David Engster <address@hidden>
+
+ * grammars/c.by (expr-binop): Add MOD.
+ (variablearg): Add 'opt-assign'.
+ (variablearg, varnamelist): Add default values so that it can be
+ later expanded into the tag.
+ (opt-stuff-after-symbol): Rename to 'brackets-after-symbol' and
+ remove empty match.
+ (multi-stage-dereference): Adapt to above rename.
+ (unaryexpression): Use 'symbol' instead of 'namespace-symbol',
+ since the latter also leads to an empty match at the end which
+ would make this too greedy.
+ (variablearg-opt-name): Support parsing of function pointers
+ inside an argument list.
+
2013-12-12 Glenn Morris <address@hidden>
* update_autogen (info_dir):
=== modified file 'admin/grammars/c.by'
--- a/admin/grammars/c.by 2013-11-30 02:06:34 +0000
+++ b/admin/grammars/c.by 2013-12-12 21:33:06 +0000
@@ -901,8 +901,8 @@
;; I should store more in this def, but leave it simple for now.
;; Klaus Berndl: const and volatile can be written after the type!
variablearg
- : declmods typeformbase cv-declmods opt-ref variablearg-opt-name
- ( VARIABLE-TAG (list $5) $2 nil
+ : declmods typeformbase cv-declmods opt-ref variablearg-opt-name opt-assign
+ ( VARIABLE-TAG (list (append $5 ,$6)) $2 nil
:constant-flag (if (member "const" (append $1 $3)) t nil)
:typemodifiers (delete "const" (append $1 $3))
:reference (car ,$4)
@@ -912,6 +912,8 @@
variablearg-opt-name
: varname
( ,$1 )
+ | semantic-list arg-list
+ ( (car ( EXPAND $1 function-pointer )) $2)
;; Klaus Berndl: This allows variableargs without a arg-name being
;; parsed correct even if there several pointers (*)
| opt-stars
@@ -926,9 +928,9 @@
varnamelist
: opt-ref varname varname-opt-initializer COMA varnamelist
- ( ,(cons $2 $5) )
+ ( ,(cons (append $2 $3) $5) )
| opt-ref varname varname-opt-initializer
- ( $2 )
+ ( (append $2 $3) )
;
;; Klaus Berndl: Is necessary to parse stuff like
@@ -1152,16 +1154,15 @@
: open-paren typeformbase close-paren
;
-opt-stuff-after-symbol
+brackets-after-symbol
: PAREN_BLCK
| BRACK_BLCK
- | ;; EMPTY
;
multi-stage-dereference
- : namespace-symbol opt-stuff-after-symbol PERIOD multi-stage-dereference ;;
method call
- | namespace-symbol opt-stuff-after-symbol MINUS GREATER
multi-stage-dereference ;;method call
- | namespace-symbol opt-stuff-after-symbol
+ : namespace-symbol brackets-after-symbol PERIOD multi-stage-dereference ;;
method call
+ | namespace-symbol brackets-after-symbol MINUS GREATER
multi-stage-dereference ;;method call
+ | namespace-symbol brackets-after-symbol
;
string-seq
@@ -1187,6 +1188,7 @@
| AMPERSAND
| OR OR
| OR
+ | MOD
;; There are more.
;
@@ -1204,8 +1206,7 @@
| multi-stage-dereference
| NEW multi-stage-dereference
| NEW builtintype-types semantic-list
- ;; Klaus Berndl: symbol -> namespace-symbol!
- | namespace-symbol
+ | symbol
;; Klaus Berndl: C/C++ allows sequences of strings which are
;; concatenated by the precompiler to one string
| string-seq
=== modified file 'lisp/cedet/ChangeLog'
--- a/lisp/cedet/ChangeLog 2013-11-30 02:06:34 +0000
+++ b/lisp/cedet/ChangeLog 2013-12-12 21:33:06 +0000
@@ -1,3 +1,128 @@
+2013-12-12 David Engster <address@hidden>
+
+ * semantic/analyze.el
+ (semantic-analyze-find-tag-sequence-default): Always add scope to
+ the local miniscope for each type. Otherwise, structure tags are
+ not analyzed correctly. Also, always search the extended
+ miniscope even when not dealing with types.
+
+ * semantic/ctxt.el (semantic-get-local-variables-default): Also
+ try to parse local variables for buffers which are currently
+ marked as unparseable. Otherwise, it is often impossible to
+ complete local variables.
+
+ * semantic/scope.el (semantic-analyze-scoped-types-default): If we
+ cannot find a type in the typecache, also look into the the types
+ we already found. This is necessary since in C++, a 'using
+ namespace' can be dependend on a previous one.
+ (semantic-completable-tags-from-type): When creating the list of
+ completable types, pull in types which are referenced through
+ 'using' statements, and also preserve their filenames.
+
+ * semanitc/bovine/c.el (semantic/analyze/refs): Require.
+ (semantic-analyze-tag-references): New override. Mainly copied
+ from the default implementation, but if nothing could be found (or
+ just the tag itself), drop all namespaces from the scope and
+ search again. This is necessary for implementations which are
+ defined outside of the namespace and only pull those in through
+ 'using' statements.
+ (semantic-ctxt-scoped-types): Go through all tags around point and
+ search them for using statements. In the case for using
+ statements outside of function scope, append them in the correct
+ order instead of using 'cons'. This is important since using
+ statements may depend on previous ones.
+ (semantic-expand-c-tag-namelist): Do not try to parse struct
+ definitions as default values. The grammar parser seems to return
+ the point positions slightly differently (as a cons instead of a
+ list). Also, set parent for typedefs to 'nil'. It does not
+ really make sense to set a parent class for typedefs, and it can
+ also lead to endless loops when calculating scope.
+ (semantic-c-reconstitute-token): Change handling of function
+ pointers; instead of seeing them as variables, handle them as
+ functions with a 'function-pointer' attribute. Also, correctly
+ deal with function pointers as function arguments.
+ (semantic-c-reconstitute-function-arglist): New function to parse
+ function pointers inside an argument list.
+ (semantic-format-tag-name): Use 'function-pointer' attribute
+ instead of the old 'functionpointer-flag'.
+ (semantic-cpp-lexer): Use new `semantic-lex-spp-paren-or-list'.
+
+ * semantic/bovine/gcc.el (semantic-gcc-setup): Add 'features.h' to
+ the list of files whose preprocessor symbols are included. This
+ pulls in things like __USE_POSIX and similar.
+
+ * semantic/format.el (semantic-format-tag-prototype-default):
+ Display default values if available.
+
+ * semantic/analyze/refs.el (semantic-analyze-refs-impl)
+ (semantic-analyze-refs-proto): Add 'default-value' as ignorable in
+ call to `semantic-tag-similar-p'.
+
+ * semantic/db-mode.el (semanticdb-semantic-init-hook-fcn): Always
+ set buffer for `semanticdb-current-table'.
+
+ * semantic/db.el (semanticdb-table::semanticdb-refresh-table): The
+ previous change turned up a bug in this method. Since the current
+ table now correctly has a buffer set, the first clause in the
+ `cond' would be taken, but there was a `save-excursion' missing.
+
+ * semantic/lex-spp.el (semantic-c-end-of-macro): Declare.
+ (semantic-lex-spp-token-macro-to-macro-stream): Deal with macros
+ which open/close a scope. For this, leave an overlay if we
+ encounter a single open paren and return a semantic-list in the
+ lexer. When this list gets expanded, retrieve the old position
+ from the overlay. See the comments in the function for further
+ details.
+ (semantic-lex-spp-find-closing-macro): New function to find the
+ next macro which closes scope (i.e., has a closing paren).
+ (semantic-lex-spp-replace-or-symbol-or-keyword): Go to end of
+ closing macro if necessary.
+ (semantic-lex-spp-paren-or-list): New lexer to specially deal with
+ parens in macro definitions.
+
+ * semantic/decorate/mode.el (semantic-decoration-mode): Do not
+ decorate available tags immediately but in an idle timer, since
+ EDE will usually not be activated yet, which will make it
+ impossible to find project includes.
+
+ * semantic/decorate/include.el
+ (semantic-decoration-on-includes-highlight-default): Remove
+ 'unloaded' from throttle when decorating includes, otherwise all
+ would be loaded. Rename 'table' to 'currenttable' to make things
+ clearer.
+
+ * ede/linux.el (cl): Require during compile.
+
+2013-12-12 Lluís Vilanova <address@hidden>
+
+ * ede/linux.el (project-linux-build-directory-default)
+ (project-linux-architecture-default): Add customizable variables.
+ (ede-linux-project): Add additional slots to track Linux-specific
+ information (out-of-tree build directory and selected
+ architecture).
+ (ede-linux--get-build-directory, ede-linux--get-archs)
+ (ede-linux--detect-architecture, ede-linux--get-architecture)
+ (ede-linux--include-path): Added function to detect Linux-specific
+ information.
+ (ede-linux-load): Set new Linux-specific information when creating
+ a project.
+ (ede-expand-filename-impl): Use new and more accurate include
+ information.
+
+2013-12-12 Eric Ludlam <address@hidden>
+
+ * semantic/scope.el (semantic-calculate-scope): Return a clone of
+ the scopecache, so that everyone is working with its own (shallow)
+ copy. Otherwise, if one caller is resetting the scope, it would
+ be reset for all others working with the scope cache as well.
+
+2013-12-12 Alex Ott <address@hidden>
+
+ * ede/generic.el (project-run-target): Remove incorrect require.
+
+ * semantic/format.el (semantic-format-tag-prototype-default): Use
+ concat only for strings.
+
2013-11-30 Glenn Morris <address@hidden>
Stop keeping (most) generated cedet grammar files in the repository.
=== modified file 'lisp/cedet/ede/generic.el'
--- a/lisp/cedet/ede/generic.el 2013-01-01 09:11:05 +0000
+++ b/lisp/cedet/ede/generic.el 2013-12-12 21:33:06 +0000
@@ -360,7 +360,6 @@
(defmethod project-run-target ((target ede-generic-target))
"Run the current project derived from TARGET."
- (require 'ede-shell)
(let* ((proj (ede-target-parent target))
(config (ede-generic-get-configuration proj))
(run (concat "./" (oref config :run-command)))
=== modified file 'lisp/cedet/ede/linux.el'
--- a/lisp/cedet/ede/linux.el 2013-01-01 09:11:05 +0000
+++ b/lisp/cedet/ede/linux.el 2013-12-12 21:33:06 +0000
@@ -32,6 +32,8 @@
;; * Add texinfo lookup options.
;; * Add website
+(eval-when-compile (require 'cl))
+
(require 'ede)
(require 'ede/make)
@@ -46,6 +48,19 @@
:group 'ede
:version "24.3")
+(defcustom project-linux-build-directory-default 'ask
+ "Build directory."
+ :group 'project-linux
+ :type '(choice (const :tag "Same as source directory" 'same)
+ (const :tag "Ask the user" 'ask)))
+
+(defcustom project-linux-architecture-default 'ask
+ "Target architecture to assume when not auto-detected."
+ :group 'project-linux
+ :type '(choice (string :tag "Architecture name")
+ (const :tag "Ask the user" 'ask)))
+
+
(defcustom project-linux-compile-target-command (concat ede-make-command " -k
-C %s SUBDIRS=%s")
"*Default command used to compile a target."
:group 'project-linux
@@ -109,10 +124,100 @@
(defclass ede-linux-project (ede-project eieio-instance-tracker)
((tracking-symbol :initform 'ede-linux-project-list)
- )
+ (build-directory :initarg :build-directory
+ :type string
+ :documentation "Build directory.")
+ (architecture :initarg :architecture
+ :type string
+ :documentation "Target architecture.")
+ (include-path :initarg :include-path
+ :type list
+ :documentation "Include directories.
+Contains both common and target architecture-specific directories."))
"Project Type for the Linux source code."
:method-invocation-order :depth-first)
+
+(defun ede-linux--get-build-directory (dir)
+ "Detect build directory for sources in DIR.
+If DIR has not been used as a build directory, fall back to
+`project-linux-build-directory-default'."
+ (or
+ ;; detected build on source directory
+ (and (file-exists-p (expand-file-name ".config" dir)) dir)
+ ;; use configuration
+ (case project-linux-build-directory-default
+ (same dir)
+ (ask (read-directory-name "Select Linux' build directory: " dir)))))
+
+
+(defun ede-linux--get-archs (dir)
+ "Returns a list of architecture names found in DIR."
+ (let ((archs-dir (expand-file-name "arch" dir))
+ archs)
+ (when (file-directory-p archs-dir)
+ (mapc (lambda (elem)
+ (when (and
+ (not (string= elem "."))
+ (not (string= elem ".."))
+ (not (string= elem "x86_64")) ; has no separate sources
+ (file-directory-p
+ (expand-file-name elem archs-dir)))
+ (add-to-list 'archs elem t)))
+ (directory-files archs-dir)))
+ archs))
+
+
+(defun ede-linux--detect-architecture (dir)
+ "Try to auto-detect the architecture as configured in DIR.
+DIR is Linux' build directory. If it cannot be auto-detected,
+returns `project-linux-architecture-default'."
+ (let ((archs-dir (expand-file-name "arch" dir))
+ (archs (ede-linux--get-archs dir))
+ arch found)
+ (or (and
+ archs
+ ;; Look for /arch/<arch>/include/generated
+ (progn
+ (while (and archs (not found))
+ (setq arch (car archs))
+ (when (file-directory-p
+ (expand-file-name (concat arch "/include/generated")
+ archs-dir))
+ (setq found arch))
+ (setq archs (cdr archs)))
+ found))
+ project-linux-architecture-default)))
+
+(defun ede-linux--get-architecture (dir bdir)
+ "Try to auto-detect the architecture as configured in BDIR.
+Uses `ede-linux--detect-architecture' for the auto-detection. If
+the result is `ask', let the user choose from architectures found
+in DIR."
+ (let ((arch (ede-linux--detect-architecture bdir)))
+ (case arch
+ (ask
+ (completing-read "Select target architecture: "
+ (ede-linux--get-archs dir)))
+ (t arch))))
+
+
+(defun ede-linux--include-path (dir bdir arch)
+ "Returns a list with include directories.
+Returned directories might not exist, since they are not created
+until Linux is built for the first time."
+ (map 'list
+ (lambda (elem) (format (concat (car elem) "/" (cdr elem)) arch))
+ ;; XXX: taken from the output of "make V=1"
+ (list (cons dir "arch/%s/include")
+ (cons bdir "arch/%s/include/generated")
+ (cons dir "include")
+ (cons bdir "include")
+ (cons dir "arch/%s/include/uapi")
+ (cons bdir "arch/%s/include/generated/uapi")
+ (cons dir "include/uapi")
+ (cons bdir "include/generated/uapi"))))
+
;;;###autoload
(defun ede-linux-load (dir &optional rootproj)
"Return an Linux Project object if there is a match.
@@ -121,15 +226,20 @@
ROOTPROJ is nil, since there is only one project."
(or (ede-linux-file-existing dir)
;; Doesn't already exist, so let's make one.
- (let ((proj (ede-linux-project
- "Linux"
- :name "Linux"
- :version (ede-linux-version dir)
- :directory (file-name-as-directory dir)
- :file (expand-file-name "scripts/ver_linux"
- dir))))
- (ede-add-project-to-global-list proj))
- ))
+ (let* ((bdir (ede-linux--get-build-directory dir))
+ (arch (ede-linux--get-architecture dir bdir))
+ (include-path (ede-linux--include-path dir bdir arch))
+ (proj (ede-linux-project
+ "Linux"
+ :name "Linux"
+ :version (ede-linux-version dir)
+ :directory (file-name-as-directory dir)
+ :file (expand-file-name "scripts/ver_linux"
+ dir)
+ :build-directory bdir
+ :architecture arch
+ :include-path include-path)))
+ (ede-add-project-to-global-list proj))))
;;;###autoload
(ede-add-project-autoload
@@ -245,18 +355,23 @@
"Within this project PROJ, find the file NAME.
Knows about how the Linux source tree is organized."
(let* ((ext (file-name-extension name))
- (root (ede-project-root proj))
- (dir (ede-project-root-directory root))
- (F (cond
- ((not ext) nil)
- ((string-match "h" ext)
- (or (ede-linux-file-exists-name name dir "")
- (ede-linux-file-exists-name name dir "include"))
- )
- ((string-match "txt" ext)
- (ede-linux-file-exists-name name dir "Documentation"))
- (t nil)))
- )
+ (root (ede-project-root proj))
+ (dir (ede-project-root-directory root))
+ (bdir (oref proj build-directory))
+ (F (cond
+ ((not ext) nil)
+ ((string-match "h" ext)
+ (let ((dirs (oref proj include-path))
+ found)
+ (while (and dirs (not found))
+ (setq found
+ (or (ede-linux-file-exists-name name bdir (car dirs))
+ (ede-linux-file-exists-name name dir (car dirs))))
+ (setq dirs (cdr dirs)))
+ found))
+ ((string-match "txt" ext)
+ (ede-linux-file-exists-name name dir "Documentation"))
+ (t nil))))
(or F (call-next-method))))
(defmethod project-compile-project ((proj ede-linux-project)
=== modified file 'lisp/cedet/semantic/analyze.el'
--- a/lisp/cedet/semantic/analyze.el 2013-03-21 22:11:03 +0000
+++ b/lisp/cedet/semantic/analyze.el 2013-12-12 21:33:06 +0000
@@ -295,18 +295,10 @@
;; In some cases the found TMP is a type,
;; and we can use it directly.
(cond ((semantic-tag-of-class-p tmp 'type)
- ;; update the miniscope when we need to analyze types
directly.
- (when miniscope
- (let ((rawscope
- (apply 'append
- (mapcar 'semantic-tag-type-members
- tagtype))))
- (oset miniscope fullscope rawscope)))
- ;; Now analyze the type to remove metatypes.
(or (semantic-analyze-type tmp miniscope)
tmp))
(t
- (semantic-analyze-tag-type tmp scope))))
+ (semantic-analyze-tag-type tmp miniscope))))
(typefile
(when tmptype
(semantic-tag-file-name tmptype)))
@@ -336,6 +328,11 @@
(semantic--tag-put-property tmp :filename fname))
(setq tag (cons tmp tag))
(setq tagtype (cons tmptype tagtype))
+ (when miniscope
+ (let ((rawscope
+ (apply 'append
+ (mapcar 'semantic-tag-type-members tagtype))))
+ (oset miniscope fullscope rawscope)))
)
(setq s (cdr s)))
=== modified file 'lisp/cedet/semantic/analyze/refs.el'
--- a/lisp/cedet/semantic/analyze/refs.el 2013-01-01 09:11:05 +0000
+++ b/lisp/cedet/semantic/analyze/refs.el 2013-12-12 21:33:06 +0000
@@ -118,7 +118,8 @@
(semantic-tag-similar-p tag aT
:prototype-flag
:parent
- :typemodifiers))
+ :typemodifiers
+ :default-value))
(when in-buffer (save-excursion (semantic-go-to-tag aT aDB)))
(push aT impl))))
allhits)
@@ -141,7 +142,8 @@
(semantic-tag-similar-p tag aT
:prototype-flag
:parent
- :typemodifiers))
+ :typemodifiers
+ :default-value))
(when in-buffer (save-excursion (semantic-go-to-tag aT aDB)))
(push aT proto))))
allhits)
=== modified file 'lisp/cedet/semantic/bovine/c.el'
--- a/lisp/cedet/semantic/bovine/c.el 2013-06-02 13:33:09 +0000
+++ b/lisp/cedet/semantic/bovine/c.el 2013-12-12 21:33:06 +0000
@@ -27,6 +27,7 @@
(require 'semantic)
(require 'semantic/analyze)
+(require 'semantic/analyze/refs)
(require 'semantic/bovine)
(require 'semantic/bovine/gcc)
(require 'semantic/idle)
@@ -812,7 +813,7 @@
;; semantic-lex-spp-replace-or-symbol-or-keyword
semantic-lex-symbol-or-keyword
semantic-lex-charquote
- semantic-lex-paren-or-list
+ semantic-lex-spp-paren-or-list
semantic-lex-close-paren
semantic-lex-ignore-comments
semantic-lex-punctuation
@@ -1118,7 +1119,8 @@
(semantic-tag-new-variable
(car cur) ;name
ty ;type
- (if default
+ (if (and default
+ (listp (cdr default)))
(buffer-substring-no-properties
(car default) (car (cdr default))))
:constant-flag (semantic-tag-variable-constant-p tag)
@@ -1173,11 +1175,7 @@
(nth 1 (car names)) ; name
"typedef"
(semantic-tag-type-members tag)
- ;; parent is just the name of what
- ;; is passed down as a tag.
- (list
- (semantic-tag-name
- (semantic-tag-type-superclasses tag)))
+ nil
:pointer
(let ((stars (car (car (car names)))))
(if (= stars 0) nil stars))
@@ -1227,6 +1225,45 @@
name
(delete "" ans))))
+(define-mode-local-override semantic-analyze-tag-references c-mode (tag
&optional db)
+ "Analyze the references for TAG.
+Returns a class with information about TAG.
+
+Optional argument DB is a database. It will be used to help
+locate TAG.
+
+Use `semantic-analyze-current-tag' to debug this fcn."
+ (when (not (semantic-tag-p tag)) (signal 'wrong-type-argument (list
'semantic-tag-p tag)))
+ (let ((allhits nil)
+ (scope nil)
+ (refs nil))
+ (save-excursion
+ (semantic-go-to-tag tag db)
+ (setq scope (semantic-calculate-scope))
+
+ (setq allhits (semantic--analyze-refs-full-lookup tag scope t))
+
+ (when (or (zerop (semanticdb-find-result-length allhits))
+ (and (= (semanticdb-find-result-length allhits) 1)
+ (eq (car (semanticdb-find-result-nth allhits 0)) tag)))
+ ;; It found nothing or only itself - not good enough. As a
+ ;; last resort, let's remove all namespaces from the scope and
+ ;; search again.
+ (oset scope parents
+ (let ((parents (oref scope parents))
+ newparents)
+ (dolist (cur parents)
+ (unless (string= (semantic-tag-type cur) "namespace")
+ (push cur newparents)))
+ (reverse newparents)))
+ (setq allhits (semantic--analyze-refs-full-lookup tag scope t)))
+
+ (setq refs (semantic-analyze-references (semantic-tag-name tag)
+ :tag tag
+ :tagdb db
+ :scope scope
+ :rawsearchdata allhits)))))
+
(defun semantic-c-reconstitute-token (tokenpart declmods typedecl)
"Reconstitute a token TOKENPART with DECLMODS and TYPEDECL.
This is so we don't have to match the same starting text several times.
@@ -1258,7 +1295,8 @@
(nth 10 tokenpart) ; initializers
)
(not (car (nth 3 tokenpart)))))
- (fcnpointer (string-match "^\\*" (car tokenpart)))
+ (fcnpointer (and (> (length (car tokenpart)) 0)
+ (= (aref (car tokenpart) 0) ?*)))
(fnname (if fcnpointer
(substring (car tokenpart) 1)
(car tokenpart)))
@@ -1266,70 +1304,80 @@
nil
t))
)
- (if fcnpointer
- ;; Function pointers are really variables.
- (semantic-tag-new-variable
- fnname
- typedecl
- nil
- ;; It is a function pointer
- :functionpointer-flag t
- )
- ;; The function
- (semantic-tag-new-function
- fnname
- (or typedecl ;type
- (cond ((car (nth 3 tokenpart) )
- "void") ; Destructors have no return?
- (constructor
- ;; Constructors return an object.
- (semantic-tag-new-type
- ;; name
- (or (car semantic-c-classname)
- (let ((split (semantic-analyze-split-name-c-mode
- (car (nth 2 tokenpart)))))
- (if (stringp split) split
- (car (last split)))))
- ;; type
- (or (cdr semantic-c-classname)
- "class")
- ;; members
- nil
- ;; parents
- nil
- ))
- (t "int")))
- (nth 4 tokenpart) ;arglist
- :constant-flag (if (member "const" declmods) t nil)
- :typemodifiers (delete "const" declmods)
- :parent (car (nth 2 tokenpart))
- :destructor-flag (if (car (nth 3 tokenpart) ) t)
- :constructor-flag (if constructor t)
- :pointer (nth 7 tokenpart)
- :operator-flag operator
- ;; Even though it is "throw" in C++, we use
- ;; `throws' as a common name for things that toss
- ;; exceptions about.
- :throws (nth 5 tokenpart)
- ;; Reentrant is a C++ thingy. Add it here
- :reentrant-flag (if (member "reentrant" (nth 6 tokenpart)) t)
- ;; A function post-const is funky. Try stuff
- :methodconst-flag (if (member "const" (nth 6 tokenpart)) t)
- ;; prototypes are functions w/ no body
- :prototype-flag (if (nth 8 tokenpart) t)
- ;; Pure virtual
- :pure-virtual-flag (if (eq (nth 8 tokenpart) :pure-virtual-flag)
t)
- ;; Template specifier.
- :template-specifier (nth 9 tokenpart)
- )))
- )
- ))
+ ;; The function
+ (semantic-tag-new-function
+ fnname
+ (or typedecl ;type
+ (cond ((car (nth 3 tokenpart) )
+ "void") ; Destructors have no return?
+ (constructor
+ ;; Constructors return an object.
+ (semantic-tag-new-type
+ ;; name
+ (or (car semantic-c-classname)
+ (let ((split (semantic-analyze-split-name-c-mode
+ (car (nth 2 tokenpart)))))
+ (if (stringp split) split
+ (car (last split)))))
+ ;; type
+ (or (cdr semantic-c-classname)
+ "class")
+ ;; members
+ nil
+ ;; parents
+ nil
+ ))
+ (t "int")))
+ ;; Argument list can contain things like function pointers
+ (semantic-c-reconstitute-function-arglist (nth 4 tokenpart))
+ :constant-flag (if (member "const" declmods) t nil)
+ :typemodifiers (delete "const" declmods)
+ :parent (car (nth 2 tokenpart))
+ :destructor-flag (if (car (nth 3 tokenpart) ) t)
+ :constructor-flag (if constructor t)
+ :function-pointer fcnpointer
+ :pointer (nth 7 tokenpart)
+ :operator-flag operator
+ ;; Even though it is "throw" in C++, we use
+ ;; `throws' as a common name for things that toss
+ ;; exceptions about.
+ :throws (nth 5 tokenpart)
+ ;; Reentrant is a C++ thingy. Add it here
+ :reentrant-flag (if (member "reentrant" (nth 6 tokenpart)) t)
+ ;; A function post-const is funky. Try stuff
+ :methodconst-flag (if (member "const" (nth 6 tokenpart)) t)
+ ;; prototypes are functions w/ no body
+ :prototype-flag (if (nth 8 tokenpart) t)
+ ;; Pure virtual
+ :pure-virtual-flag (if (eq (nth 8 tokenpart) :pure-virtual-flag) t)
+ ;; Template specifier.
+ :template-specifier (nth 9 tokenpart))))))
(defun semantic-c-reconstitute-template (tag specifier)
"Reconstitute the token TAG with the template SPECIFIER."
(semantic-tag-put-attribute tag :template (or specifier ""))
tag)
+(defun semantic-c-reconstitute-function-arglist (arglist)
+ "Reconstitute the argument list of a function.
+This currently only checks if the function expects a function
+pointer as argument."
+ (let (result)
+ (dolist (arg arglist)
+ ;; Names starting with a '*' denote a function pointer
+ (if (and (> (length (semantic-tag-name arg)) 0)
+ (= (aref (semantic-tag-name arg) 0) ?*))
+ (setq result
+ (append result
+ (list
+ (semantic-tag-new-function
+ (substring (semantic-tag-name arg) 1)
+ (semantic-tag-type arg)
+ (cadr (semantic-tag-attributes arg))
+ :function-pointer t))))
+ (setq result (append result (list arg)))))
+ result))
+
;;; Override methods & Variables
;;
@@ -1338,7 +1386,7 @@
"Convert TAG to a string that is the print name for TAG.
Optional PARENT and COLOR are ignored."
(let ((name (semantic-format-tag-name-default tag parent color))
- (fnptr (semantic-tag-get-attribute tag :functionpointer-flag))
+ (fnptr (semantic-tag-get-attribute tag :function-pointer))
)
(if (not fnptr)
name
@@ -1823,31 +1871,31 @@
(let ((idx 0)
(len (semanticdb-find-result-length tmp)))
(while (< idx len)
- (setq tagreturn (cons (semantic-tag-type (car
(semanticdb-find-result-nth tmp idx))) tagreturn))
- (setq idx (1+ idx)))
- )
- ;; Use the encompassed types around point to also look for using
statements.
- ;;(setq tagreturn (cons "bread_name" tagreturn))
- (while (cdr tagsaroundpoint) ; don't search the last one
- (setq tmp (semantic-find-tags-by-class 'using (semantic-tag-components
(car tagsaroundpoint))))
- (dolist (T tmp)
- (setq tagreturn (cons (semantic-tag-type T) tagreturn))
- )
- (setq tagsaroundpoint (cdr tagsaroundpoint))
- )
- ;; If in a function...
- (when (and (semantic-tag-of-class-p (car tagsaroundpoint) 'function)
- ;; ...search for using statements in the local scope...
- (setq tmp (semantic-find-tags-by-class
- 'using
- (semantic-get-local-variables))))
- ;; ... and add them.
- (setq tagreturn
- (append tagreturn
- (mapcar 'semantic-tag-type tmp))))
+ (setq tagreturn
+ (append tagreturn (list (semantic-tag-type
+ (car (semanticdb-find-result-nth tmp
idx))))))
+ (setq idx (1+ idx))))
+ ;; Use the encompassed types around point to also look for using
+ ;; statements. If we deal with types, search inside members; for
+ ;; functions, we have to call `semantic-get-local-variables' to
+ ;; parse inside the function's body.
+ (dolist (cur tagsaroundpoint)
+ (cond
+ ((and (eq (semantic-tag-class cur) 'type)
+ (setq tmp (semantic-find-tags-by-class
+ 'using
+ (semantic-tag-components (car tagsaroundpoint)))))
+ (dolist (T tmp)
+ (setq tagreturn (cons (semantic-tag-type T) tagreturn))))
+ ((and (semantic-tag-of-class-p (car (last tagsaroundpoint)) 'function)
+ (setq tmp (semantic-find-tags-by-class
+ 'using
+ (semantic-get-local-variables))))
+ (setq tagreturn
+ (append tagreturn
+ (mapcar 'semantic-tag-type tmp))))))
;; Return the stuff
- tagreturn
- ))
+ tagreturn))
(define-mode-local-override semantic-ctxt-imported-packages c++-mode
(&optional point)
"Return the list of using tag types in scope of POINT."
=== modified file 'lisp/cedet/semantic/bovine/gcc.el'
--- a/lisp/cedet/semantic/bovine/gcc.el 2013-03-21 22:11:03 +0000
+++ b/lisp/cedet/semantic/bovine/gcc.el 2013-12-12 21:33:06 +0000
@@ -210,7 +210,8 @@
(semantic-add-system-include D 'c-mode))
(dolist (D (semantic-gcc-get-include-paths "c++"))
(semantic-add-system-include D 'c++-mode)
- (let ((cppconfig (list (concat D "/bits/c++config.h") (concat D
"/sys/cdefs.h"))))
+ (let ((cppconfig (list (concat D "/bits/c++config.h") (concat D
"/sys/cdefs.h")
+ (concat D "/features.h"))))
(dolist (cur cppconfig)
;; Presumably there will be only one of these files in the try-paths
list...
(when (file-readable-p cur)
=== modified file 'lisp/cedet/semantic/ctxt.el'
--- a/lisp/cedet/semantic/ctxt.el 2013-06-18 02:06:33 +0000
+++ b/lisp/cedet/semantic/ctxt.el 2013-12-12 21:33:06 +0000
@@ -168,8 +168,7 @@
to collect tags, such as local variables or prototypes."
;; This assumes a bovine parser. Make sure we don't do
;; anything in that case.
- (when (and semantic--parse-table (not (eq semantic--parse-table t))
- (not (semantic-parse-tree-unparseable-p)))
+ (when (and semantic--parse-table (not (eq semantic--parse-table t)))
(let ((vars (semantic-get-cache-data 'get-local-variables)))
(if vars
(progn
=== modified file 'lisp/cedet/semantic/db-mode.el'
--- a/lisp/cedet/semantic/db-mode.el 2013-10-20 09:51:21 +0000
+++ b/lisp/cedet/semantic/db-mode.el 2013-12-12 21:33:06 +0000
@@ -105,7 +105,8 @@
(oset ctbl major-mode major-mode)
;; Local state
(setq semanticdb-current-table ctbl)
- ;; Try to swap in saved tags
+ (oset ctbl buffer (current-buffer))
+ ;; Try to swap in saved tags
(if (or (not (slot-boundp ctbl 'tags)) (not (oref ctbl tags))
(/= (or (oref ctbl pointmax) 0) (point-max))
)
@@ -133,7 +134,6 @@
(semantic--set-buffer-cache (oref ctbl tags))
;; Don't need it to be dirty. Set dirty due to hooks from above.
(oset ctbl dirty nil) ;; Special case here.
- (oset ctbl buffer (current-buffer))
;; Bind into the buffer.
(semantic--tag-link-cache-to-buffer)
)
=== modified file 'lisp/cedet/semantic/db.el'
--- a/lisp/cedet/semantic/db.el 2013-11-30 02:06:34 +0000
+++ b/lisp/cedet/semantic/db.el 2013-12-12 21:33:06 +0000
@@ -560,8 +560,9 @@
;;
;; Already in a buffer, just do it.
((semanticdb-in-buffer-p obj)
- (semanticdb-set-buffer obj)
- (semantic-fetch-tags))
+ (save-excursion
+ (semanticdb-set-buffer obj)
+ (semantic-fetch-tags)))
;;
;; Not in a buffer. Forcing a load.
(force
=== modified file 'lisp/cedet/semantic/decorate/include.el'
--- a/lisp/cedet/semantic/decorate/include.el 2013-03-21 22:11:03 +0000
+++ b/lisp/cedet/semantic/decorate/include.el 2013-12-12 21:33:06 +0000
@@ -335,6 +335,9 @@
(defun semantic-decoration-on-includes-highlight-default (tag)
"Highlight the include TAG to show that semantic can't find it."
(let* ((file (semantic-dependency-tag-file tag))
+ ;; Don't actually load includes
+ (semanticdb-find-default-throttle
+ (remq 'unloaded semanticdb-find-default-throttle))
(table (semanticdb-find-table-for-include tag (current-buffer)))
(face nil)
(map nil)
@@ -365,8 +368,8 @@
(semanticdb-cache-get
table 'semantic-decoration-unparsed-include-cache)
;; Add a dependency.
- (let ((table semanticdb-current-table))
- (semanticdb-add-reference table tag))
+ (let ((currenttable semanticdb-current-table))
+ (semanticdb-add-reference currenttable tag))
)
))
=== modified file 'lisp/cedet/semantic/decorate/mode.el'
--- a/lisp/cedet/semantic/decorate/mode.el 2013-07-29 20:26:19 +0000
+++ b/lisp/cedet/semantic/decorate/mode.el 2013-12-12 21:33:06 +0000
@@ -275,7 +275,13 @@
'semantic-decorate-tags-after-full-reparse nil t)
;; Add decorations to available tags. The above hooks ensure
;; that new tags will be decorated when they become available.
- (semantic-decorate-add-decorations (semantic-fetch-available-tags)))
+ ;; However, don't do this immediately, because EDE will be
+ ;; activated later by find-file-hook, and includes might not
+ ;; be found yet.
+ (run-with-idle-timer
+ 0.1 nil
+ (lambda ()
+ (semantic-decorate-add-decorations
(semantic-fetch-available-tags)))))
;; Remove decorations from available tags.
(semantic-decorate-clear-decorations (semantic-fetch-available-tags))
;; Cleanup any leftover crap too.
=== modified file 'lisp/cedet/semantic/format.el'
--- a/lisp/cedet/semantic/format.el 2013-01-01 09:11:05 +0000
+++ b/lisp/cedet/semantic/format.el 2013-12-12 21:33:06 +0000
@@ -499,7 +499,12 @@
(setq r (concat r "[]")
deref (1- deref)))
r)))
- )
+ (default (when (eq class 'variable)
+ (let ((defval
+ (semantic-tag-get-attribute tag :default-value)))
+ (when (and defval (stringp defval))
+ (concat "[=" defval "]")))))
+ )
(if args
(setq args
(concat " "
@@ -512,7 +517,8 @@
(if type (concat type " "))
name
(or args "")
- (or array ""))))
+ (or array "")
+ (or default ""))))
;;;###autoload
(define-overloadable-function semantic-format-tag-concise-prototype (tag
&optional parent color)
=== modified file 'lisp/cedet/semantic/lex-spp.el'
--- a/lisp/cedet/semantic/lex-spp.el 2013-01-01 09:11:05 +0000
+++ b/lisp/cedet/semantic/lex-spp.el 2013-12-12 21:33:06 +0000
@@ -70,6 +70,8 @@
(require 'semantic)
(require 'semantic/lex)
+(declare-function semantic-c-end-of-macro "semantic/bovine/c")
+
;;; Code:
(defvar semantic-lex-spp-macro-symbol-obarray nil
"Table of macro keywords used by the Semantic Preprocessor.
@@ -527,16 +529,54 @@
;;
;; Nested token FOO shows up in the table of macros, and gets replace
;; inline. This is the same as case 2.
-
- (let ((arglist (semantic-lex-spp-macro-with-args val))
- (argalist nil)
- (val-tmp nil)
- (v nil)
- )
+ ;;
+ ;; CASE 5: Macros which open a scope without closing it
+ ;;
+ ;; #define __NAMESPACE_STD namespace std {
+ ;; #define __NAMESPACE_END }
+ ;; ==>
+ ;; ((NAMESPACE "namespace" 140 . 149)
+ ;; (symbol "std" 150 . 153)
+ ;; (open-paren "{" 154 . 155))
+ ;;
+ ;; Note that we get a single 'open-paren' instead of a
+ ;; 'semantic-list', which is because we use
+ ;; 'semantic-lex-spp-paren-or-list' instead of
+ ;; 'semantic-lex-paren-or-list' in our spp-lexer. To keep things
+ ;; reasonably simple, we assume that such an open scope will always
+ ;; be closed by another macro (see
+ ;; `semantic-lex-spp-find-closing-macro'). We generate a
+ ;; 'semantic-list' to this closing macro, and we leave an overlay
+ ;; which contains information how far we got into the macro's
+ ;; stream (since it might open several scopes).
+
+ (let* ((arglist (semantic-lex-spp-macro-with-args val))
+ (argalist nil)
+ (val-tmp nil)
+ (v nil)
+ (sppov (semantic-lex-spp-get-overlay beg))
+ (sppinfo (when sppov (overlay-get sppov 'semantic-spp))))
+
+ ;; First, check if we were already here and left information
+ (when sppinfo
+ ;; Advance in the tokens as far as we got last time
+ (when (numberp (car sppinfo))
+ (while (and val
+ (>= (car sppinfo) (car (last (car val)))))
+ (setq val (cdr val))))
+ ;; And push an open paren
+ (semantic-lex-push-token
+ (semantic-lex-token 'open-paren beg (1+ beg) "{"))
+ (setq semantic-lex-current-depth (1+ semantic-lex-current-depth))
+ (unless val
+ ;; We reached the end of this macro, so delete overlay
+ (delete-overlay sppov)))
+
;; CASE 2: Dealing with the arg list.
- (when arglist
+ (when (and val arglist)
;; Skip the arg list.
- (setq val (cdr val))
+ (when (eq (caar val) 'spp-arg-list)
+ (setq val (cdr val)))
;; Push args into the replacement list.
(let ((AV argvalues))
@@ -616,7 +656,32 @@
(semantic-lex-push-token
(semantic-lex-token (semantic-lex-token-class v) beg end txt))
)
-
+ ;; CASE 5: Macro which opens a scope
+ ((eq (semantic-lex-token-class v) 'open-paren)
+ ;; We assume that the scope will be closed by another macro.
+ ;; (Everything else would be a terrible idea anyway.)
+ (let* ((endpoint (semantic-lex-spp-find-closing-macro))
+ (ov (when endpoint
+ (or sppov
+ (make-overlay beg end)))))
+ (when ov
+ ;; Generate a semantic-list which spans to the end of
+ ;; the closing macro
+ (semantic-lex-push-token
+ (semantic-lex-token 'semantic-list beg endpoint))
+ ;; The rest of the current macro's stream will be parsed
+ ;; next time.
+ (setq val-tmp nil)
+ ;; Store our current state were we are in the macro and
+ ;; the endpoint.
+ (overlay-put ov 'semantic-spp
+ (cons (car (last v)) endpoint)))))
+ ((eq (semantic-lex-token-class v) 'close-paren)
+ ;; Macro which closes a scope
+ ;; Just push the close paren, but also decrease depth
+ (semantic-lex-push-token
+ (semantic-lex-token 'close-paren beg end txt))
+ (setq semantic-lex-current-depth (1- semantic-lex-current-depth)))
;; CASE 1: Just another token in the stream.
(t
;; Nothing new.
@@ -652,6 +717,37 @@
txt
""))
+(defun semantic-lex-spp-find-closing-macro ()
+ "Find next macro which closes a scope through a close-paren.
+Returns position with the end of that macro."
+ (let ((macros (semantic-lex-spp-macros))
+ (cmacro-regexp "\\(")
+ (case-fold-search nil))
+ ;; Build a regexp which search for all macros with a closing
+ ;; paren, and search for it.
+ (dolist (cur macros)
+ (let ((stream (symbol-value cur)))
+ (when (and (listp stream) (listp (car stream)))
+ (while stream
+ (if (and (eq (caar stream) 'close-paren)
+ (string= (nth 1 (car stream)) "}"))
+ (setq cmacro-regexp (concat cmacro-regexp (symbol-name cur)
"\\|")
+ stream nil)
+ (setq stream (cdr-safe stream)))))))
+ (when cmacro-regexp
+ (save-excursion
+ (when (re-search-forward
+ (concat (substring cmacro-regexp 0 -2) "\\)[^0-9a-zA-Z_]") nil t)
+ (point))))))
+
+(defun semantic-lex-spp-get-overlay (&optional point)
+ "Return first overlay which has a 'semantic-spp property."
+ (let ((overlays (overlays-at (or point (point)))))
+ (while (and overlays
+ (null (overlay-get (car overlays) 'semantic-spp)))
+ (setq overlays (cdr overlays)))
+ (car-safe overlays)))
+
;;; Macro Merging
;;
;; Used when token streams from different macros include each other.
@@ -824,8 +920,46 @@
"\\(\\sw\\|\\s_\\)+"
(let ((str (match-string 0))
(beg (match-beginning 0))
- (end (match-end 0)))
- (semantic-lex-spp-analyzer-push-tokens-for-symbol str beg end)))
+ (end (match-end 0))
+ sppov)
+ (semantic-lex-spp-analyzer-push-tokens-for-symbol str beg end)
+ (when (setq sppov (semantic-lex-spp-get-overlay beg))
+ (setq semantic-lex-end-point (cdr (overlay-get sppov 'semantic-spp))))))
+
+(define-lex-regex-analyzer semantic-lex-spp-paren-or-list
+ "Detect open parenthesis.
+Contrary to `semantic-lex-paren-or-list', this will push a single
+open-paren onto the stream if no closing paren can be found.
+This is important for macros which open a scope which is closed
+by another macro."
+ "\\s("
+ (if (or (not semantic-lex-maximum-depth)
+ (< semantic-lex-current-depth semantic-lex-maximum-depth))
+ (progn
+ (setq semantic-lex-current-depth (1+ semantic-lex-current-depth))
+ (semantic-lex-push-token
+ (semantic-lex-token
+ 'open-paren (match-beginning 0) (match-end 0))))
+ (save-excursion
+ (let ((start (match-beginning 0))
+ (end (match-end 0))
+ (peom (save-excursion (semantic-c-end-of-macro) (point))))
+ (condition-case nil
+ (progn
+ ;; This will throw an error if no closing paren can be found.
+ (forward-list 1)
+ (when (> (point) peom)
+ ;; If we have left the macro, this is the wrong closing
+ ;; paren, so error out as well.
+ (error ""))
+ (semantic-lex-push-token
+ (semantic-lex-token
+ 'semantic-list start (point))))
+ (error
+ ;; Only push a single open-paren.
+ (semantic-lex-push-token
+ (semantic-lex-token
+ 'open-paren start end))))))))
;;; ANALYZERS FOR NEW MACROS
;;
=== modified file 'lisp/cedet/semantic/scope.el'
--- a/lisp/cedet/semantic/scope.el 2013-01-01 09:11:05 +0000
+++ b/lisp/cedet/semantic/scope.el 2013-12-12 21:33:06 +0000
@@ -195,12 +195,18 @@
;; Get this thing as a tag
(let ((tmp (cond
((stringp (car sp))
- (semanticdb-typecache-find (car sp)))
- ;(semantic-analyze-find-tag (car sp) 'type))
+ (or (semanticdb-typecache-find (car sp))
+ ;; If we did not find it in the typecache,
+ ;; look in the tags we found so far
+ (car (semantic-deep-find-tags-by-name
+ (car sp)
+ code-scoped-types))))
((semantic-tag-p (car sp))
(if (semantic-tag-prototype-p (car sp))
- (semanticdb-typecache-find (semantic-tag-name (car
sp)))
- ;;(semantic-analyze-find-tag (semantic-tag-name (car
sp)) 'type)
+ (or (semanticdb-typecache-find (semantic-tag-name
(car sp)))
+ (car (semantic-deep-find-tags-by-name
+ (semantic-tag-name (car sp))
+ code-scoped-types)))
(car sp)))
(t nil))))
(when tmp
@@ -506,10 +512,33 @@
(leftover nil)
)
(dolist (S allslots)
- (when (or (not (semantic-tag-of-class-p S 'function))
- (not (semantic-tag-function-parent S)))
- (setq leftover (cons S leftover)))
- )
+ ;; We have to specially deal with 'using' tags here, since those
+ ;; pull in namespaces or classes into the current scope.
+ ;; (Should this go into c.el? If so, into which override?)
+ (if (semantic-tag-of-class-p S 'using)
+ (let* ((fullname (semantic-analyze-unsplit-name
+ (list (semantic-tag-name type)
+ (semantic-tag-name S))))
+ ;; Search the typecache, first for the unqualified name
+ (usingtype (or
+ (semanticdb-typecache-find (semantic-tag-name S))
+ ;; If that didn't return anything, use
+ ;; fully qualified name
+ (semanticdb-typecache-find fullname)))
+ (filename (when usingtype (semantic-tag-file-name usingtype))))
+ (when usingtype
+ ;; Use recursion to examine that namespace or class
+ (let ((tags (semantic-completable-tags-from-type usingtype)))
+ (if filename
+ ;; If we have a filename, copy the tags with it
+ (dolist (cur tags)
+ (setq leftover (cons (semantic-tag-copy cur nil filename)
+ leftover)))
+ ;; Otherwise just run with it
+ (setq leftover (append tags leftover))))))
+ (when (or (not (semantic-tag-of-class-p S 'function))
+ (not (semantic-tag-function-parent S)))
+ (setq leftover (cons S leftover)))))
(nreverse leftover)))
(defun semantic-analyze-scoped-type-parts (type &optional scope noinherit
protection)
@@ -734,8 +763,9 @@
(when (called-interactively-p 'any)
(require 'eieio-datadebug)
(data-debug-show scopecache))
- ;; Return ourselves
- scopecache))))
+ ;; Return ourselves, but make a clone first so that the caller
+ ;; can reset the scope cache without affecting others.
+ (clone scopecache)))))
(defun semantic-scope-find (name &optional class scope-in)
"Find the tag with NAME, and optional CLASS in the current SCOPE-IN.
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] trunk r115495: Merge from CEDET upstream.,
David Engster <=