=== modified file 'lisp/cedet/ede/cpp-root.el' --- lisp/cedet/ede/cpp-root.el 2012-04-22 21:25:01 +0000 +++ lisp/cedet/ede/cpp-root.el 2012-06-18 02:03:03 +0000 @@ -85,7 +85,7 @@ ;; file name for a header in your project where most of your CPP ;; macros reside. Doing this can be easier than listing everything in ;; the :spp-table option. The files listed in :spp-files should not -;; start with a /, and are relative to something in :include-path.;; +;; start with a /, and are relative to something in :include-path. ;; ;; If you want to override the file-finding tool with your own ;; function you can do this: === modified file 'lisp/cedet/semantic/find.el' --- lisp/cedet/semantic/find.el 2011-11-07 20:57:12 +0000 +++ lisp/cedet/semantic/find.el 2012-06-22 03:27:13 +0000 @@ -1,6 +1,6 @@ ;;; semantic/find.el --- Search routines for Semantic -;; Copyright (C) 1999-2005, 2008-2011 Free Software Foundation, Inc. +;; Copyright (C) 1999-2005, 2008-2012 Free Software Foundation, Inc. ;; Author: Eric M. Ludlam ;; Keywords: syntax @@ -362,7 +362,8 @@ table (require 'semantic/tag-ls) (semantic--find-tags-by-macro - (not (semantic-tag-protected-p (car tags) scopeprotection parent)) + (not (and (semantic-tag-protected-p (car tags) scopeprotection parent) + (semantic-tag-package-protected-p (car tags) parent))) table))) ;;;###autoload === modified file 'lisp/cedet/semantic/java.el' --- lisp/cedet/semantic/java.el 2011-11-07 20:57:12 +0000 +++ lisp/cedet/semantic/java.el 2012-06-22 03:21:37 +0000 @@ -1,6 +1,6 @@ ;;; semantic/java.el --- Semantic functions for Java -;;; Copyright (C) 1999-2011 Free Software Foundation, Inc. +;;; Copyright (C) 1999-2012 Free Software Foundation, Inc. ;; Author: David Ponce @@ -173,6 +173,15 @@ (semantic-find-tags-by-class 'type (semantic-find-tag-by-overlay point)))) +;; Tag Protection +;; +(define-mode-local-override semantic-tag-protection + java-mode (tag &optional parent) + "Return the protection of TAG in PARENT. +Override function for `semantic-tag-protection'." + (let ((prot (semantic-tag-protection-default tag parent))) + (or prot 'package))) + ;; Prototype handler ;; (defun semantic-java-prototype-function (tag &optional parent color) @@ -256,7 +265,6 @@ (let ((name (semantic-tag-name tag))) (concat (mapconcat 'identity (split-string name "\\.") "/") ".java"))) - ;; Documentation handler ;; (defsubst semantic-java-skip-spaces-backward () === modified file 'lisp/cedet/semantic/tag-ls.el' --- lisp/cedet/semantic/tag-ls.el 2011-11-07 20:57:12 +0000 +++ lisp/cedet/semantic/tag-ls.el 2012-06-22 03:31:13 +0000 @@ -236,10 +236,38 @@ ((string= s "private") 'private) ((string= s "protected") - 'protected))))) + 'protected) + ((string= s "package") + 'package) + )))) (setq mods (cdr mods))) prot)) +(defun semantic-tag-package-protected-p (tag &optional parent currentpackage) + "Non-nil if TAG is not available via package access control. +For languages (such as Java) where a method is package protected, +this method will return nil if TAG, as found in PARENT is available +for access from a file in CURRENTPACKAGE. +If TAG is not protected by PACKAGE, also return t. Use +`semantic-tag-protected-p' instead. +If PARENT is not provided, it will be derived when passed to +`semantic-tag-protection'. +If CURRENTPACKAGE is not provided, it will be derived from the current +buffer." + (let ((tagpro (semantic-tag-protection tag parent))) + (if (not (eq tagpro 'package)) + t ;; protected + + ;; package protection, so check currentpackage. + ;; Deriving the package is better from the parent, as TAG is + ;; probably a field or method. + (if (not currentpackage) + (setq currentpackage (semantic-tag-full-package nil (current-buffer)))) + (let ((tagpack (semantic-tag-full-package (or parent tag)))) + (if (string= currentpackage tagpack) + nil + t)) ))) + (defun semantic-tag-protected-p (tag protection &optional parent) "Non-nil if TAG is is protected. PROTECTION is a symbol which can be returned by the method @@ -361,19 +389,47 @@ ;; For programmer convenience, a full name is not specified in source ;; code. Instead some abbreviation is made, and the local environment ;; will contain the info needed to determine the full name. +(define-overloadable-function semantic-tag-full-package (tag &optional stream-or-buffer) + "Return the fully qualified package name of TAG in a package hierarchy. +STREAM-OR-BUFFER can be anything convertable by `semantic-something-to-stream', +but must be a toplevel semantic tag stream that contains TAG. +A Package Hierarchy is defined in UML by the way classes and methods +are organized on disk. Some languages use this concept such that a +class can be accessed via it's fully qualified name, (such as Java.) +Other languages qualify names within a Namespace (such as C++) which +result in a different package like structure. + +Languages which do not override this function will just search the +stream for a tag of class 'package, and return that." + (let ((stream (semantic-something-to-tag-table + (or stream-or-buffer tag)))) + (:override-with-args (tag stream)))) + +(defun semantic-tag-full-package-default (tag stream) + "Default method for `semantic-tag-full-package' for TAG. +Return the name of the first tag of class `package' in STREAM." + (let ((pack (car-safe (semantic-find-tags-by-class 'package stream)))) + (when (and pack (semantic-tag-p pack)) + (semantic-tag-name pack)))) (define-overloadable-function semantic-tag-full-name (tag &optional stream-or-buffer) "Return the fully qualified name of TAG in the package hierarchy. STREAM-OR-BUFFER can be anything convertable by `semantic-something-to-stream', but must be a toplevel semantic tag stream that contains TAG. A Package Hierarchy is defined in UML by the way classes and methods -are organized on disk. Some language use this concept such that a +are organized on disk. Some languages use this concept such that a class can be accessed via it's fully qualified name, (such as Java.) Other languages qualify names within a Namespace (such as C++) which -result in a different package like structure. Languages which do not -override this function with `tag-full-name' will use -`semantic-tag-name'. Override functions only need to handle -STREAM-OR-BUFFER with a tag stream value, or nil." +result in a different package like structure. + +Languages which do not override this function with +`tag-full-name' will combine `semantic-tag-full-package' and +`semantic-tag-name', separated with language separator character. +Override functions only need to handle STREAM-OR-BUFFER with a +tag stream value, or nil. + +TODO - this function should probably also take a PARENT to TAG to +resolve issues where a method in a class in a package is present." (let ((stream (semantic-something-to-tag-table (or stream-or-buffer tag)))) (:override-with-args (tag stream)))) @@ -384,7 +440,13 @@ (defun semantic-tag-full-name-default (tag stream) "Default method for `semantic-tag-full-name'. Return the name of TAG found in the toplevel STREAM." - (semantic-tag-name tag)) + (let ((pack (semantic-tag-full-package tag stream)) + (name (semantic-tag-name tag))) + (if pack + (concat pack + (car semantic-type-relation-separator-character) + name) + name))) (provide 'semantic/tag-ls)