* lisp/cedet: Use cl-generic instead of EIEIO's defgeneric/defmethod

* lisp/cedet/**/*.el: Mechanically replace all calls to defmethod/defgeneric
by calls to cl-defmethod/cl-defgeneric.
* lisp/cedet/srecode/table.el:
* lisp/cedet/srecode/fields.el:
* lisp/cedet/srecode/dictionary.el:
* lisp/cedet/srecode/compile.el:
* lisp/cedet/semantic/debug.el:
* lisp/cedet/semantic/db-ref.el:
* lisp/cedet/ede/base.el:
* lisp/cedet/ede/auto.el:
* lisp/cedet/ede.el: Require `cl-generic'.

1 files changed, 19 insertions, 19 deletions

diff --git a/lisp/cedet/ede/cpp-root.el b/lisp/cedet/ede/cpp-root.el
index e32066af89b..81c6737531a 100644
--- a/lisp/cedet/ede/cpp-root.el
+++ b/lisp/cedet/ede/cpp-root.el
@@ -276,11 +276,11 @@ Each directory needs a project file to control it.")
 ;; find previous copies of this project, and make sure that one of the
 ;; objects is deleted.
 
-(defmethod initialize-instance ((this ede-cpp-root-project)
+(cl-defmethod initialize-instance ((this ede-cpp-root-project)
                                 &rest fields)
   "Make sure the :file is fully expanded."
   ;; Add ourselves to the master list
-  (call-next-method)
+  (cl-call-next-method)
   (let ((f (expand-file-name (oref this :file))))
     ;; Remove any previous entries from the main list.
     (let ((old (eieio-instance-tracker-find (file-name-directory f)
@@ -311,7 +311,7 @@ Each directory needs a project file to control it.")
 ;; This is a way to allow a subdirectory to point back to the root
 ;; project, simplifying authoring new single-point projects.
 
-(defmethod ede-find-subproject-for-directory ((proj ede-cpp-root-project)
+(cl-defmethod ede-find-subproject-for-directory ((proj ede-cpp-root-project)
                                               dir)
   "Return PROJ, for handling all subdirs below DIR."
   proj)
@@ -321,7 +321,7 @@ Each directory needs a project file to control it.")
 ;; Creating new targets on a per directory basis is a good way to keep
 ;; files organized.  See ede-emacs for an example with multiple file
 ;; types.
-(defmethod ede-find-target ((proj ede-cpp-root-project) buffer)
+(cl-defmethod ede-find-target ((proj ede-cpp-root-project) buffer)
   "Find an EDE target in PROJ for BUFFER.
 If one doesn't exist, create a new one for this directory."
   (let* ((targets (oref proj targets))
@@ -347,13 +347,13 @@ If one doesn't exist, create a new one for this directory."
 ;;
 ;; This tools also uses the ede-locate setup for augmented file name
 ;; lookup using external tools.
-(defmethod ede-expand-filename-impl ((proj ede-cpp-root-project) name)
+(cl-defmethod ede-expand-filename-impl ((proj ede-cpp-root-project) name)
   "Within this project PROJ, find the file NAME.
 This knows details about or source tree."
   ;; The slow part of the original is looping over subprojects.
   ;; This version has no subprojects, so this will handle some
   ;; basic cases.
-  (let ((ans (call-next-method)))
+  (let ((ans (cl-call-next-method)))
     (unless ans
       (let* ((lf (oref proj locate-fcn))
              (dir (file-name-directory (oref proj file))))
@@ -372,16 +372,16 @@ This knows details about or source tree."
                       (setq ans tmp))
                   (setq ip (cdr ip)) ))
             ;; Else, do the usual.
-            (setq ans (call-next-method)))
+            (setq ans (cl-call-next-method)))
           )))
     ;; TODO - does this call-next-method happen twice.  Is that bad??  Why is it here?
-    (or ans (call-next-method))))
+    (or ans (cl-call-next-method))))
 
-(defmethod ede-project-root ((this ede-cpp-root-project))
+(cl-defmethod ede-project-root ((this ede-cpp-root-project))
   "Return my root."
   this)
 
-(defmethod ede-project-root-directory ((this ede-cpp-root-project))
+(cl-defmethod ede-project-root-directory ((this ede-cpp-root-project))
   "Return my root."
   (oref this directory))
 
@@ -390,12 +390,12 @@ This knows details about or source tree."
 ;; The following code is specific to setting up header files,
 ;; include lists, and Preprocessor symbol tables.
 
-(defmethod ede-cpp-root-header-file-p ((proj ede-cpp-root-project) name)
+(cl-defmethod ede-cpp-root-header-file-p ((proj ede-cpp-root-project) name)
   "Non nil if in PROJ the filename NAME is a header."
   (save-match-data
     (string-match (oref proj header-match-regexp) name)))
 
-(defmethod ede-cpp-root-translate-file ((proj ede-cpp-root-project) filename)
+(cl-defmethod ede-cpp-root-translate-file ((proj ede-cpp-root-project) filename)
   "For PROJ, translate a user specified FILENAME.
 This is for project include paths and spp source files."
   ;; Step one: Root of this project.
@@ -411,11 +411,11 @@ This is for project include paths and spp source files."
 
     filename))
 
-(defmethod ede-system-include-path ((this ede-cpp-root-project))
+(cl-defmethod ede-system-include-path ((this ede-cpp-root-project))
   "Get the system include path used by project THIS."
   (oref this system-include-path))
 
-(defmethod ede-preprocessor-map ((this ede-cpp-root-project))
+(cl-defmethod ede-preprocessor-map ((this ede-cpp-root-project))
   "Get the pre-processor map for project THIS."
   (require 'semantic/db)
   (let ((spp (oref this spp-table))
@@ -445,15 +445,15 @@ This is for project include paths and spp source files."
      (oref this spp-files))
     spp))
 
-(defmethod ede-system-include-path ((this ede-cpp-root-target))
+(cl-defmethod ede-system-include-path ((this ede-cpp-root-target))
   "Get the system include path used by target THIS."
   (ede-system-include-path (ede-target-parent this)))
 
-(defmethod ede-preprocessor-map ((this ede-cpp-root-target))
+(cl-defmethod ede-preprocessor-map ((this ede-cpp-root-target))
   "Get the pre-processor map for project THIS."
   (ede-preprocessor-map  (ede-target-parent this)))
 
-(defmethod project-compile-project ((proj ede-cpp-root-project) &optional command)
+(cl-defmethod project-compile-project ((proj ede-cpp-root-project) &optional command)
   "Compile the entire current project PROJ.
 Argument COMMAND is the command to use when compiling."
   ;; we need to be in the proj root dir for this to work
@@ -469,14 +469,14 @@ Argument COMMAND is the command to use when compiling."
         (let ((default-directory (ede-project-root-directory proj)))
         (compile cmd-str)))))
 
-(defmethod project-compile-target ((obj ede-cpp-root-target) &optional command)
+(cl-defmethod project-compile-target ((obj ede-cpp-root-target) &optional command)
   "Compile the current target OBJ.
 Argument COMMAND is the command to use for compiling the target."
   (when (oref obj :project)
     (project-compile-project (oref obj :project) command)))
 
 
-(defmethod project-rescan ((this ede-cpp-root-project))
+(cl-defmethod project-rescan ((this ede-cpp-root-project))
   "Don't rescan this project from the sources."
   (message "cpp-root has nothing to rescan."))