Update from CEDET trunk.

* grammars/c.by (template-type): Add :template-specifier and
:typevar to capture extra details about the template.
(opt-post-fcn-modifiers): Splice in the found symbol into the
return value correctly.
(QUESTION): New punctuation.
(expression): Add ternary conditional support.

* grammars/scheme.by (MODULE): New token.
(scheme): Handle expanding the MODULE tag.
(scheme-list): Remove closeparen required match.
(scheme-in-list): Remove extraneous matches for DEFINE.  Add
support for MODULE Simplify matching for code & make work.
(name-args, name-arg-list, name-arg-expand): Make it work.

* semantic.el (semantic-mode): Add/remove 3
completion-at-point-functions.
(semantic-completion-at-point-function): Removed.
(semantic-analyze-completion-at-point-function)
(semantic-analyze-notc-completion-at-point-function)
(semantic-analyze-nolongprefix-completion-at-point-function): New
completion at point functions.

* semantic/doc.el (semantic-doc-snarf-comment-for-tag): Fix case
when comment-end is empty string.

* semantic/debug.el
(semantic-debug-parser-debugger-source): New buffer local
variable.
(semantic-debug-interface): Add 'nil' initform to overlays.
(semantic-debug-mode): Remove read-only tags from buffers on exit.
(semantic-debug): Add autoload cookie.  Force the language
specific debugger to load.

* semantic/db.el (generic::semanticdb-full-filename): New generic
method to allow this method to be used on buffer names via an
associated database.

* semantic/symref.el
(semantic-symref-cleanup-recent-buffers-fcn): When cleaning up
buffers, don't clean up buffers that are being used (i.e., in a
window) when the hook fires.
(semantic-symref-recently-opened-buffers): New tracking variable.
(semantic-symref-cleanup-recent-buffers-fcn): New hook fcn.
(semantic-symref-result-get-tags): Move logic into
`semantic-symref-hit-to-tag-via-buffer', and cleanup buffers via
the symref cleanup function in post-command-hook.
(semantic-symref-hit-to-tag-via-buffer): Logic that used to be
from above.
(semantic-symref-hit-to-tag-via-db): New.

* semantic/analyze.el:
(semantic-analyze-find-tag-sequence-default): If first entry in
sequence is the only one, apply tagclass filter.
(semantic-analyze-princ-sequence): Show slot even if empty.
(semantic-analyze-find-tag-sequence)
(semantic-analyze-find-tag-sequence-default): Add flags argument.
Add support for forcing the final entry of the sequence to be of
class variable.
(semantic-analyze-find-tag): Fix bug where input class filter was
ignored if there was a typecache match.
(semantic-analyze-current-context-default): For assignments, the
assignee now must be of class variable.

* semantic/analyze/complete.el
(semantic-analyze-possible-completions-default): Add
'no-longprefix' flag.  When used, the prefix and prefixtypes are
shortened to just the last symbol.

* semantic/bovine/c.el (semantic-c-do-lex-if): Catch errors from
'hideif', and push to the parser warning stack.
(semantic-lex-cpp-define): When a comment is at the end of a
macro, do not subtract an extra 1 from the found position.  Fixes
bug with: #define foo (a)/**/ adding an extra ')' to the stream.

* semantic/bovine/scm.el (semantic-lex-scheme-symbol): Allow
symbols to be one char long.

* semantic/bovine/grammar.el
(bovine-grammar-calculate-source-on-path): New.
(bovine-grammar-setupcode-builder): Use it.

* ede.el (ede/detect): New require.
(ede-version): Bump version
(ede-initialize-state-current-buffer): Use new
`ede-detect-directory-for-project' to detect projects first
instead of depending on currente dir only.
(ede-delete-project-from-global-list): New.
(ede-flush-deleted-projects): Use above.
(ede-check-project-query-fcn): New variable
(ede-check-project-directory): Use above when querying the user.
Added to support unit testing of this security measure.
(ede-initialize-state-current-buffer): Use
`ede-directory-project-cons' instead of the -detect- fcn to take
advantage of the cache.  Pass found project into
`ede-load-project-file'.
(ede-load-project-file): Add new input DETECTIN.
(ede-rescan-toplevel): Get the proj root a better way.
(ede-load-project-file): Return the loaded object.  When asking
for existing project, ask for an exact match.
(ede-initialize-state-current-buffer): Simplify some conditional
logic.
(ede-load-project-file): Simplify conditional logic.
(ede-global-list-sanity-check): New Testing fcn.
(ede-parent-project): Replace old code with call to faster
`ede-find-subproject-for-directory'.
(ede-load-project-file): Use
`ede-directory-get-toplevel-open-project' instead of above
deleted.  Rename "pfc" to "autoloader".  Use
`ede-directory-project-cons' to detect a project.  Delete no
project found case where we search up the tree.

* ede/auto.el (ede-project-autoload): Fix doc typo.  Add
`:root-only' slot.
(ede-auto-load-project): Doc update: warn to not use.
(ede-dir-to-projectfile): Deleted.
(ede-project-autoload-dirmatch): Add subdir-only slot.  Make
configdatastash unbound by default.
(ede-do-dirmatch): If subdir-only is true, then don't allow exact
matches.  Account for configdatastash as unbound.  Assume value of
nil means no tool installed.  Make sure loaded path matches from
beginning.  Stash the regexp, not the raw string.
(ede-project-class-files): Note that makefile and automake are not
root only.
(ede-auto-detect-in-dir): New (for use with `ede/detect.el').
(ede-project-dirmatch-p): Deleted.
(ede-project-root-directory): Remove body, return nil.
(ede-project-autoload): :proj-root-dirmatch can be null & doc fix.
(ede-auto-detect-in-dir): If there is no :proj-file, check for a
dirmatch.

* ede/generic.el (ede/config): Replace require of ede.
(ede-generic-new-autoloader): Generic projects are now safe by
default.  Note this is NOT a root only project.
(project-rescan, ede-project-root, ede-generic-target-java)
(ede-java-classpath, ede-find-subproject-for-directory): New.
(ede-enable-generic-projects): Add new autoloaders for git, bzr,
hg, sv, CVS.
(ede-generic-vc-project)
(ede-generic-vc-project::ede-generic-setup-configuration): New.
(ede-generic-config): Remove slots: c-include-path,
c-preprocessor-table, c-preprocessor-files, classpath,
build-command, debug-command, run command.  Inherit from
ede-extra-config-build, ede-extra-config-program.  Make
run-command :value match :custom so only strings are accepted.
Add some more :group slot specifiers.
(ede-generic-project): Add mixins `ede-project-with-config-c' and
`ede-project-with-config-java'. Inherit from
`ede-project-with-config-build',
`ede-project-with-config-program'.  Subclass
`ede-project-with-config'.  Remove duplication from new baseclass.
(ede-generic-target): Inherit from `ede-target-with-config-build',
`ede-target-with-config-program'. Subclass `ede-target-with-config'.
(ede-generic-target-c-cpp): Add mixin `ede-target-with-config-c'.
(ede-generic-target-java): Add mixin `ede-target-with-config-java'.
(ede-preprocessor-map, ede-system-include-path)
(edejava-classpath): Deleted, moved to config.el.
(project-compile-project, project-compile-target)
(project-debug-target, project-run-target): Deleted.
(ede-generic-get-configuration, ede-generic-setup-configuration)
(ede-commit-project, project-rescan)
(ede-generic-project::ede-customize)
(ede-generic-target::ede-customize)
(ede-generic-config::eieio-done-customizing)
(ede-generic-config::ede-commit): Deleted.  Subsumed by new
baseclass.
(ede-preprocessor-map, ede-system-include-path)
(project-debug-target, project-run-target): Call new
`ede-config-get-configuration' instead of old version.
(ede-generic-load): Do not add to global list here.

* ede/files.el (ede-find-project-root)
(ede-files-find-existing)
(ede-directory-get-toplevel-open-project-new): Deleted.
(ede-project-root-directory): Use `ede-project-root' first.
(ede-project-directory-remove-hash)
(ede--directory-project-from-hash)
(ede--directory-project-add-description-to-hash): Rename to make
internal symbols (via --).  Expand input dir first.
(ede-directory-project-p): Doc fix (note obsoleted.)
(ede-toplevel-project-or-nil): Alias to `ede-toplevel-project'.
(ede-toplevel-project): Doc Fix.  Delete commented out old code.
Simplify returning result from ede-detect-directory-for-project.
(ede-directory-get-open-project): Support when
inodes are disabled.  If disabled to str compare on root project.
(ede-directory-get-toplevel-open-project): Enabled nested
projects.  When doing directory name matching, save the 'short'
version of an answer (non-exact match) and eventually select the
shortest answer at the end.  Expand the filename of tested
projects.  Better support for when inodes are disabled.  Add
'exact' option so that it will return a project that is an exact
match.
(ede-find-subproject-for-directory): Small optimization to run
`file-truename' less often.
(ede-directory-project-p): Move content, then use
`ede-directory-project-cons'.  Use
`ede-detect-directory-for-project', replacing old detection loop.
(ede-directory-project-cons): New, from above.
(ede-toplevel-project): Toss old scanning code.  Use
`ede-detect-directory-for-project' instead.
(ede-directory-get-toplevel-open-project-new): New.

* ede/linux.el (ede-linux-project-root): Deleted.
(ede-project-autoload): Remove dirmatch entry - it is no longer
needed.

* lisp/cedet/ede/proj.el (project-rescan): Replace direct
manipulation of `ede-projects' with equivalent and better
functions.
(ede-proj-load): Replace call to test if dir has project to
explicity ask filesystem if Project.ede is there.

* ede/config.el:
* ede/detect.el: New files.

* ede/project-am.el (project-run-target): Add "./" to program to
run for systems where '.' isn't in PATH.
(project-am-load): Remove old code regarding `ede-constructing'.
Just read in the makefiles.

* ede/linux.el (ede-linux-load): Do not add to global list here.
Don't check for existing anymore.
(project-rescan): New.
(ede-linux-project-list, ede-linux-file-existing): Deleted.
(ede-linux-project-root): Delete body.  Need symbol for autoloads
for now.
(ede-linux-project): No longer instance tracker.
(ede-project-autoload): Don't provide :proj-root

* ede/emacs.el (ede-emacs-load): Do not add project to global list
here.  Don't look for existing first.
(ede-project-autoload): Remove dirmatch entry - it is no longer
needed.  Don't provide proj-root anymore.
(ede-emacs-project-list, ede-emacs-file-existing): Delete.
(ede-emacs-project-root): Remove body (need symbol for loaddefs
still).
(ede-emacs-project): Do not instance track anymore.

* ede/cpp-root.el (initialize-instance): Remove commented code.
Add note about why we are adding the project to the master list.
Make sure if we are replacing a prev version, remove from global
list.
(ede-cpp-root-file-existing)
(ede-cpp-root-project-file-for-dir)
(ede-cpp-root-count, ede-cpp-root-project-root, ede-cpp-root-load)
(ede-project-autoload cpp-root): Deleted.
(ede-project-root-directory): Return :directory instead of
calculating from :file.
(project-rescan): New.

* ede/base.el (ede-toplevel): Only use buffer cached value if
subproj not passed in.

* srecode/java.el (srecode-semantic-handle-:java): Fix case when
an EDE project didn't support java paths.

* lisp/cedet/ede/proj-elisp.el
(ede-proj-target-elisp::ede-proj-tweak-autoconf): Kill buffer
after saving modified elisp-comp script, as to avoid "file has
changed on disk; really edit the buffer" questions when script
gets rewritten.

* emacs-lisp/eieio-custom.el (eieio-customize-object): Set
eieio-cog (current group) to g, which is an improved form of input
group.

* srecode/doc-cpp.srt (mode): Set to c mode so this works with
both C and C++.

1 files changed, 167 insertions, 155 deletions

diff --git a/lisp/cedet/ede/files.el b/lisp/cedet/ede/files.el
index ac245cf61bd..1a97bfc4a5d 100644
--- a/lisp/cedet/ede/files.el
+++ b/lisp/cedet/ede/files.el
@@ -80,46 +80,15 @@ Allows for one-project-object-for-a-tree type systems."
 Allows for one-project-object-for-a-tree type systems.
 Optional FILE is the file to test.  It is ignored in preference
 of the anchor file for the project."
-  (file-name-directory (expand-file-name (oref this file))))
+  (let ((root (or (ede-project-root this) this)))
+    (file-name-directory (expand-file-name (oref this file)))))
 
 
-(defmethod ede--project-inode ((proj ede-project-placeholder))
-  "Get the inode of the directory project PROJ is in."
-  (if (slot-boundp proj 'dirinode)
-      (oref proj dirinode)
-    (oset proj dirinode (ede--inode-for-dir (oref proj :directory)))))
-
-(defmethod ede-find-subproject-for-directory ((proj ede-project-placeholder)
-					      dir)
-  "Find a subproject of PROJ that corresponds to DIR."
-  (if ede--disable-inode
-      (let ((ans nil))
-	;; Try to find the right project w/out inodes.
-	(ede-map-subprojects
-	 proj
-	 (lambda (SP)
-	   (when (not ans)
-	     (if (string= (file-truename dir) (oref SP :directory))
-		 (setq ans SP)
-	       (ede-find-subproject-for-directory SP dir)))))
-	ans)
-    ;; We can use inodes, so let's try it.
-    (let ((ans nil)
-	  (inode (ede--inode-for-dir dir)))
-      (ede-map-subprojects
-       proj
-       (lambda (SP)
-	 (when (not ans)
-	   (if (equal (ede--project-inode SP) inode)
-	       (setq ans SP)
-	     (setq ans (ede-find-subproject-for-directory SP dir))))))
-      ans)))
+;; Why INODEs?
+;; An inode represents is a unique id that trancends symlinks, hardlinks, etc
+;; so when we cache an inode in a project, and hash directories to inodes, we
+;; can avoid costly filesystem queries and regex matches.
 
-;;; DIRECTORY IN OPEN PROJECT
-;;
-;; These routines match some directory name to one of the many pre-existing
-;; open projects.  This should avoid hitting the disk, or asking lots of questions
-;; if used throughout the other routines.
 (defvar ede-inode-directory-hash (make-hash-table
 				  ;; Note on test.  Can we compare inodes or something?
 				  :test 'equal)
@@ -147,6 +116,32 @@ of the anchor file for the project."
 	    (ede--put-inode-dir-hash dir (nth 10 fattr))
 	    )))))
 
+(defmethod ede--project-inode ((proj ede-project-placeholder))
+  "Get the inode of the directory project PROJ is in."
+  (if (slot-boundp proj 'dirinode)
+      (oref proj dirinode)
+    (oset proj dirinode (ede--inode-for-dir (oref proj :directory)))))
+
+(defun ede--inode-get-toplevel-open-project (inode)
+  "Return an already open toplevel project that is managing INODE.
+Does not check subprojects."
+  (when (or (and (numberp inode) (/= inode 0))
+	    (consp inode))
+    (let ((all ede-projects)
+	  (found nil)
+	  )
+      (while (and all (not found))
+	(when (equal inode (ede--project-inode (car all)))
+	  (setq found (car all)))
+	(setq all (cdr all)))
+      found)))
+
+;;; DIRECTORY IN OPEN PROJECT
+;;
+;; These routines match some directory name to one of the many pre-existing
+;; open projects.  This should avoid hitting the disk, or asking lots of questions
+;; if used throughout the other routines.
+
 (defun ede-directory-get-open-project (dir &optional rootreturn)
   "Return an already open project that is managing DIR.
 Optional ROOTRETURN specifies a symbol to set to the root project.
@@ -156,66 +151,105 @@ If DIR is the root project, then it is the same."
 	 (proj (ede--inode-get-toplevel-open-project inode))
 	 (ans nil))
     ;; Try file based search.
-    (when (not proj)
+    (when (or ede--disable-inode (not proj))
       (setq proj (ede-directory-get-toplevel-open-project ft)))
     ;; Default answer is this project
     (setq ans proj)
     ;; Save.
     (when rootreturn (set rootreturn proj))
     ;; Find subprojects.
-    (when (and proj (or ede--disable-inode
-			(not (equal inode (ede--project-inode proj)))))
+    (when (and proj (if ede--disable-inode
+			(not (string= ft (expand-file-name (oref proj :directory))))
+		      (not (equal inode (ede--project-inode proj)))))
       (setq ans (ede-find-subproject-for-directory proj ft)))
     ans))
 
-(defun ede--inode-get-toplevel-open-project (inode)
-  "Return an already open toplevel project that is managing INODE.
-Does not check subprojects."
-  (when (or (and (numberp inode) (/= inode 0))
-	    (consp inode))
-    (let ((all ede-projects)
-	  (found nil)
-	  )
-      (while (and all (not found))
-	(when (equal inode (ede--project-inode (car all)))
-	  (setq found (car all)))
-	(setq all (cdr all)))
-      found)))
-
-(defun ede-directory-get-toplevel-open-project (dir)
-  "Return an already open toplevel project that is managing DIR."
+;; Force all users to switch to `ede-directory-get-open-project'
+;; for performance reasons.
+(defun ede-directory-get-toplevel-open-project (dir &optional exact)
+  "Return an already open toplevel project that is managing DIR.
+If optional EXACT is non-nil, only return exact matches for DIR."
   (let ((ft (file-name-as-directory (expand-file-name dir)))
 	(all ede-projects)
-	(ans nil))
+	(ans nil)
+	(shortans nil))
     (while (and all (not ans))
       ;; Do the check.
-      (let ((pd (oref (car all) :directory))
+      (let ((pd (expand-file-name (oref (car all) :directory)))
 	    )
 	(cond
 	 ;; Exact text match.
 	 ((string= pd ft)
 	  (setq ans (car all)))
 	 ;; Some sub-directory
-	 ((string-match (concat "^" (regexp-quote pd)) ft)
-	  (setq ans (car all)))
+	 ((and (not exact) (string-match (concat "^" (regexp-quote pd)) ft))
+	  (if (not shortans)
+	      (setq shortans (car all))
+	    ;; We already have a short answer, so see if pd (the match we found)
+	    ;; is longer.  If it is longer, then it is more precise.
+	    (when (< (length (oref shortans :directory))
+		     (length pd))
+	      (setq shortans (car all))))
+	  )
 	 ;; Exact inode match.  Useful with symlinks or complex automounters.
-	 ((let ((pin (ede--project-inode (car all)))
-		(inode (ede--inode-for-dir dir)))
-	    (and (not (eql pin 0)) (equal pin inode)))
-	  (setq ans (car all)))
+	 ((and (not ede--disable-inode)
+	       (let ((pin (ede--project-inode (car all)))
+		     (inode (ede--inode-for-dir dir)))
+		 (and (not (eql pin 0)) (equal pin inode))))
+	  (setq ans (car all))) 
 	 ;; Subdir via truename - slower by far, but faster than a traditional lookup.
-	 ((let ((ftn (file-truename ft))
-		(ptd (file-truename (oref (car all) :directory))))
-	    (string-match (concat "^" (regexp-quote ptd)) ftn))
-	  (setq ans (car all)))
-	 ))
+	 ;; Note that we must resort to truename in order to resolve issues such as
+	 ;; cross-symlink projects.
+	 ((and (not exact)
+	       (let ((ftn (file-truename ft))
+		     (ptd (file-truename pd)))
+		 (string-match (concat "^" (regexp-quote ptd)) ftn)))
+	  (if (not shortans)
+	      (setq shortans (car all))
+	    ;; We already have a short answer, so see if pd (the match we found)
+	    ;; is longer.  If it is longer, then it is more precise.
+	    (when (< (length (expand-file-name (oref shortans :directory)))
+		     (length pd))
+	      (setq shortans (car all))))
+	  )))
       (setq all (cdr all)))
-    ans))
+    ;; If we have an exact answer, use that, otherwise use
+    ;; the short answer we found -> ie - we are in a subproject.
+    (or ans shortans)))
+
+(defmethod ede-find-subproject-for-directory ((proj ede-project-placeholder)
+					      dir)
+  "Find a subproject of PROJ that corresponds to DIR."
+  (if ede--disable-inode
+      (let ((ans nil)
+	    (fulldir (file-truename dir)))
+	;; Try to find the right project w/out inodes.
+	(ede-map-subprojects
+	 proj
+	 (lambda (SP)
+	   (when (not ans)
+	     (if (string= fulldir (file-truename (oref SP :directory)))
+		 (setq ans SP)
+	       (ede-find-subproject-for-directory SP dir)))))
+	ans)
+    ;; We can use inodes, so let's try it.
+    (let ((ans nil)
+	  (inode (ede--inode-for-dir dir)))
+      (ede-map-subprojects
+       proj
+       (lambda (SP)
+	 (when (not ans)
+	   (if (equal (ede--project-inode SP) inode)
+	       (setq ans SP)
+	     (setq ans (ede-find-subproject-for-directory SP dir))))))
+      ans)))
 
-;;; DIRECTORY-PROJECT-P
+;;; DIRECTORY HASH
 ;;
-;; For a fresh buffer, or for a path w/ no open buffer, use this
-;; routine to determine if there is a known project type here.
+;; The directory hash matches expanded directory names to already detected
+;; projects.  By hashing projects to directories, we can detect projects in
+;; places we have been before much more quickly.
+
 (defvar ede-project-directory-hash (make-hash-table
 				    ;; Note on test.  Can we compare inodes or something?
 				    :test 'equal)
@@ -237,7 +271,7 @@ Do this only when developing new projects that are incorrectly putting
   "Reset the directory hash for DIR.
 Do this whenever a new project is created, as opposed to loaded."
   ;; TODO - Use maphash, and delete by regexp, not by dir searching!
-
+  (setq dir (expand-file-name dir))
   (when (fboundp 'remhash)
     (remhash (file-name-as-directory dir) ede-project-directory-hash)
     ;; Look for all subdirs of D, and remove them.
@@ -248,98 +282,95 @@ Do this whenever a new project is created, as opposed to loaded."
 	       ede-project-directory-hash))
     ))
 
-(defun ede-directory-project-from-hash (dir)
+(defun ede--directory-project-from-hash (dir)
   "If there is an already loaded project for DIR, return it from the hash."
   (when (fboundp 'gethash)
+    (setq dir (expand-file-name dir))
     (gethash dir ede-project-directory-hash nil)))
 
-(defun ede-directory-project-add-description-to-hash (dir desc)
+(defun ede--directory-project-add-description-to-hash (dir desc)
   "Add to the EDE project hash DIR associated with DESC."
   (when (fboundp 'puthash)
+    (setq dir (expand-file-name dir))
     (puthash dir desc ede-project-directory-hash)
     desc))
 
+;;; DIRECTORY-PROJECT-P, -CONS
+;;
+;; These routines are useful for detecting if a project exists
+;; in a provided directory.
+;;
+;; Note that -P provides less information than -CONS, so use -CONS
+;; instead so that -P can be obsoleted.
 (defun ede-directory-project-p (dir &optional force)
-  "Return a project description object if DIR has a project.
+  "Return a project description object if DIR is in a project.
 Optional argument FORCE means to ignore a hash-hit of 'nomatch.
 This depends on an up to date `ede-project-class-files' variable.
 Any directory that contains the file .ede-ignore will always
-return nil."
+return nil.
+
+Consider using `ede-directory-project-cons' instead if the next
+question you want to ask is where the root of found project is."
+  ;; @TODO - We used to have a full impl here, but moved it all
+  ;;         to ede-directory-project-cons, and now hash contains only
+  ;;         the results of detection which includes the root dir.
+  ;;         Perhaps we can eventually remove this fcn?
+  (let ((detect (ede-directory-project-cons dir force)))
+    (cdr detect)))
+
+(defun ede-directory-project-cons (dir &optional force)
+  "Return a project CONS (ROOTDIR . AUTOLOAD) for DIR.
+If there is no project in DIR, return nil.
+Optional FORCE means to ignore the hash of known directories."
   (when (not (file-exists-p (expand-file-name ".ede-ignore" dir)))
     (let* ((dirtest (expand-file-name dir))
-	   (match (ede-directory-project-from-hash dirtest)))
+	   (match (ede--directory-project-from-hash dirtest)))
       (cond
        ((and (eq match 'nomatch) (not force))
 	nil)
        ((and match (not (eq match 'nomatch)))
 	match)
        (t
-	(let ((types ede-project-class-files)
-	      (ret nil))
-	  ;; Loop over all types, loading in the first type that we find.
-	  (while (and types (not ret))
-	    (if (ede-dir-to-projectfile (car types) dirtest)
-		(progn
-		  ;; We found one!  Require it now since we will need it.
-		  (require (oref (car types) file))
-		  (setq ret (car types))))
-	    (setq types (cdr types)))
-	  (ede-directory-project-add-description-to-hash dirtest (or ret 'nomatch))
-	  ret))))))
+	;; First time here?  Use the detection code to identify if we have
+	;; a project here.
+	(let* ((detect (ede-detect-directory-for-project dirtest))
+	       (autoloader (cdr detect))) ;; autoloader
+	  (when autoloader (require (oref autoloader file)))
+	  (ede--directory-project-add-description-to-hash dirtest (or detect 'nomatch))
+	  detect)
+	)))))
+  
 
 ;;; TOPLEVEL
 ;;
 ;; These utilities will identify the "toplevel" of a project.
 ;;
-(defun ede-toplevel-project-or-nil (dir)
-  "Starting with DIR, find the toplevel project directory, or return nil.
-nil is returned if the current directory is not a part of a project."
-  (let* ((ans (ede-directory-get-toplevel-open-project dir)))
-    (if ans
-	(oref ans :directory)
-      (if (ede-directory-project-p dir)
-	  (ede-toplevel-project dir)
-	nil))))
+;; NOTE: These two -toplevel- functions return a directory even though
+;;       the function name implies a project.
 
 (defun ede-toplevel-project (dir)
-  "Starting with DIR, find the toplevel project directory."
-  (if (and (string= dir default-directory)
+  "Starting with DIR, find the toplevel project directory.
+If DIR is not part of a project, return nil."
+  (let ((ans nil))
+
+    (cond
+     ;; Check if it is cached in the current buffer.
+     ((and (string= dir default-directory)
 	   ede-object-root-project)
       ;; Try the local buffer cache first.
-      (oref ede-object-root-project :directory)
-    ;; Otherwise do it the hard way.
-    (let* ((thisdir (ede-directory-project-p dir))
-	   (ans (ede-directory-get-toplevel-open-project dir)))
-      (if (and ans ;; We have an answer
-	       (or (not thisdir) ;; this dir isn't setup
-		   (and (object-of-class-p ;; Same as class for this dir?
-			 ans (oref thisdir :class-sym)))
-		   ))
-	  (oref ans :directory)
-	(let* ((toppath (expand-file-name dir))
-	       (newpath toppath)
-	       (proj (ede-directory-project-p dir))
-	       (ans nil))
-	  (if proj
-	      ;; If we already have a project, ask it what the root is.
-	      (setq ans (ede-project-root-directory proj)))
-
-	  ;; If PROJ didn't know, or there is no PROJ, then
-
-	  ;; Loop up to the topmost project, and then load that single
-	  ;; project, and its sub projects.  When we are done, identify the
-	  ;; sub-project object belonging to file.
-	  (while (and (not ans) newpath proj)
-	    (setq toppath newpath
-		  newpath (ede-up-directory toppath))
-	    (when newpath
-	      (setq proj (ede-directory-project-p newpath)))
-
-	    (when proj
-	      ;; We can home someone in the middle knows too.
-	      (setq ans (ede-project-root-directory proj)))
-	    )
-	  (or ans toppath))))))
+      (oref ede-object-root-project :directory))
+
+     ;; See if there is an existing project in DIR.
+     ((setq ans (ede-directory-get-toplevel-open-project dir))
+      (oref ans :directory))
+
+     ;; Detect using our file system detector.
+     ((setq ans (ede-detect-directory-for-project dir))
+      (car ans))
+
+     (t nil))))
+
+(defalias 'ede-toplevel-project-or-nil 'ede-toplevel-project)
 
 ;;; DIRECTORY CONVERSION STUFF
 ;;
@@ -509,25 +540,6 @@ Argument DIR is the directory to trim upwards."
 	nil
       fnd)))
 
-(defun ede-find-project-root (prj-file-name &optional dir)
-  "Tries to find directory with given project file"
-  (let ((prj-dir (locate-dominating-file (or dir default-directory)
-					 prj-file-name)))
-    (when prj-dir
-      (expand-file-name prj-dir))))
-
-(defun ede-files-find-existing (dir prj-list)
-  "Find a project in the list of projects stored in given variable.
-DIR is the directory to search from."
-  (let ((projs prj-list)
-        (ans nil))
-    (while (and projs (not ans))
-      (let ((root (ede-project-root-directory (car projs))))
-        (when (string-match (concat "^" (regexp-quote root)) dir)
-          (setq ans (car projs))))
-      (setq projs (cdr projs)))
-    ans))
-
 
 (provide 'ede/files)