Use CLOS-style accessors in oref/oset

* lisp/cedet/srecode/texi.el (srecode-semantic-handle-:texitag):
* lisp/cedet/srecode/table.el (srecode-mode-table-new):
(srecode-dump):
* lisp/cedet/srecode/srt-mode.el (srecode-parse-this-macro):
(semantic-analyze-possible-completions):
* lisp/cedet/srecode/semantic.el (srecode-compound-toString):
(srecode-semantic-apply-tag-to-dict-default):
* lisp/cedet/srecode/mode.el (srecode-minor-mode-templates-menu):
(srecode-edit):
* lisp/cedet/srecode/insert.el (srecode-insert-method):
(srecode-inserter-apply-state):
(srecode-insert-ask-default):
(srecode-insert-method-ask):
(srecode-insert-method-field):
(srecode-insert-method-helper):
(srecode-parse-input):
(srecode-match-end):
(srecode-insert-include-lookup):
(srecode-insert-method):
* lisp/cedet/srecode/find.el (srecode-template-table-in-project-p):
(srecode-template-get-table):
(srecode-template-get-table-for-binding):
(srecode-all-template-hash):
* lisp/cedet/srecode/extract.el (srecode-inserter-extract):
(srecode-inserter-extract):
* lisp/cedet/srecode/el.el (srecode-semantic-apply-tag-to-dict):
* lisp/cedet/srecode/dictionary.el (initialize-instance):
(srecode-dictionary-add-template-table):
(srecode-compound-toString):
* lisp/cedet/srecode/cpp.el (srecode-semantic-apply-tag-to-dict):
* lisp/cedet/srecode/compile.el (srecode-compile-template-table):
(srecode-dump):
* lisp/cedet/srecode/args.el (srecode-semantic-handle-:project):
* lisp/cedet/semantic/texi.el (semantic-analyze-possible-completions):
* lisp/cedet/semantic/symref/list.el (semantic-symref-results-dump):
(semantic-symref-list-create-macro-on-open-hit):
(semantic-symref-list-rename-open-hits):
(semantic-symref-list-map-open-hits):
* lisp/cedet/semantic/symref/idutils.el
(semantic-symref-perform-search):
(semantic-symref-parse-tool-output-one-line):
* lisp/cedet/semantic/symref/global.el (semantic-symref-perform-search):
(semantic-symref-parse-tool-output-one-line):
* lisp/cedet/semantic/symref/cscope.el (semantic-symref-perform-search):
(semantic-symref-parse-tool-output-one-line):
* lisp/cedet/semantic/mru-bookmark.el
(semantic-mrub-ring-to-assoc-list):
* lisp/cedet/semantic/grammar.el
(semantic-analyze-possible-completions):
* lisp/cedet/semantic/decorate/include.el
(semantic-decoration-include-describe):
* lisp/cedet/semantic/debug.el (semantic-debug-highlight-lexical-token):
(semantic-debug-highlight-rule):
* lisp/cedet/semantic/db-typecache.el
(semanticdb-typecache-for-database):
* lisp/cedet/semantic/complete.el
(semantic-collector-calculate-completions-raw):
* lisp/cedet/semantic/bovine/make.el
(semantic-analyze-possible-completions):
* lisp/cedet/semantic/analyze/refs.el (semantic-analyze-refs-impl):
(semantic-analyze-refs-proto):
* lisp/cedet/semantic/analyze/debug.el
(semantic-analyzer-debug-describe-scope):
* lisp/cedet/semantic/analyze.el (semantic-analyze-interesting-tag):
(semantic-analyze-interesting-tag):
(semantic-analyze-pulse):
* lisp/cedet/ede/util.el (ede-update-version):
* lisp/cedet/ede/shell.el (ede-shell-run-something):
* lisp/cedet/ede/project-am.el (project-am-load-makefile):
(project-rescan):
(project-am-macro):
(ede-buffer-mine):
(project-compile-target-command):
(project-am-package-info):
* lisp/cedet/ede/files.el (ede--project-inode):
(ede-directory-get-open-project):
(ede-directory-get-toplevel-open-project):
(ede-find-subproject-for-directory):
(ede-toplevel-project):
* lisp/cedet/ede/cpp-root.el (initialize-instance):
(project-compile-project):
(project-compile-target):
* lisp/cedet/ede/config.el (ede-config-get-configuration):
(project-debug-target):
(project-run-target):
(project-compile-project):
(ede-preprocessor-map):
(ede-java-classpath):
* lisp/cedet/ede/base.el (ede-normalize-file/directory): Use
CLOS-style oref/oset accessors instead of eieio-style :colon
accessors.  This avoids compilation warnings and is allegedly
faster.

13 files changed, 79 insertions, 83 deletions

diff --git a/lisp/cedet/srecode/args.el b/lisp/cedet/srecode/args.el
index 7f5600083ee..086f369b7f2 100644
--- a/lisp/cedet/srecode/args.el
+++ b/lisp/cedet/srecode/args.el
@@ -174,8 +174,8 @@ do not contain any text from preceding or following text."
           (srecode-dictionary-set-value dict "PROJECT_FILENAME" relfname)
           (srecode-dictionary-set-value dict "PROJECT_DIRECTORY" reldir)
           (srecode-dictionary-set-value dict "PROJECT_NAME" (ede-name (ede-toplevel)))
-          (srecode-dictionary-set-value dict "PROJECT_VERSION" (oref (ede-toplevel) :version))
-          )
+          (srecode-dictionary-set-value dict "PROJECT_VERSION"
+                                        (oref (ede-toplevel) version)))
       ;; If there is no EDE project, then put in some base values.
       (srecode-dictionary-set-value dict "PROJECT_FILENAME" bfn)
       (srecode-dictionary-set-value dict "PROJECT_DIRECTORY" dir)
diff --git a/lisp/cedet/srecode/compile.el b/lisp/cedet/srecode/compile.el
index 204211b5e53..ff640c020f3 100644
--- a/lisp/cedet/srecode/compile.el
+++ b/lisp/cedet/srecode/compile.el
@@ -547,8 +547,8 @@ A list of defined variables VARS provides a variable table."
 
     (while lp
 
-      (let* ((objname (oref (car lp) :object-name))
-             (context (oref (car lp) :context))
+      (let* ((objname (oref (car lp) object-name))
+             (context (oref (car lp) context))
              (globalname (concat context ":" objname))
              )
 
@@ -583,7 +583,7 @@ A list of defined variables VARS provides a variable table."
            (tmpl (oref table templates)))
       ;; Loop over all the templates, and xref.
       (while tmpl
-        (oset (car tmpl) :table table)
+        (oset (car tmpl) table table)
         (setq tmpl (cdr tmpl))))
     ))
 
@@ -644,9 +644,9 @@ Argument INDENT specifies the indentation level for the list."
   "Dump the state of the SRecode template inserter INS."
   (princ "INS: \"")
   (princ (eieio-object-name-string ins))
-  (when (oref ins :secondname)
+  (when (oref ins secondname)
     (princ "\" : \"")
-    (princ (oref ins :secondname)))
+    (princ (oref ins secondname)))
   (princ "\" type \"")
   (let* ((oc (symbol-name (eieio-object-class ins)))
          (junk (string-match "srecode-template-inserter-" oc))
diff --git a/lisp/cedet/srecode/cpp.el b/lisp/cedet/srecode/cpp.el
index cedc195433c..306c60f1b61 100644
--- a/lisp/cedet/srecode/cpp.el
+++ b/lisp/cedet/srecode/cpp.el
@@ -122,7 +122,7 @@ specified in a C file."
   (srecode-semantic-apply-tag-to-dict-default tag-wrapper dict)
 
   ;; Pull out the tag for the individual pieces.
-  (let* ((tag   (oref tag-wrapper :prime))
+  (let* ((tag   (oref tag-wrapper prime))
          (class (semantic-tag-class tag)))
 
     ;; Add additional information based on the class of the tag.
diff --git a/lisp/cedet/srecode/dictionary.el b/lisp/cedet/srecode/dictionary.el
index 4b1f28babd5..8508371d53b 100644
--- a/lisp/cedet/srecode/dictionary.el
+++ b/lisp/cedet/srecode/dictionary.el
@@ -122,7 +122,7 @@ Makes sure that :value is compiled."
 
     (cl-call-next-method this (nreverse newfields))
     (when (not (slot-boundp this 'compiled))
-      (let ((val (oref this :value))
+      (let ((val (oref this value))
             (comp nil))
         (while val
           (let ((nval (car val))
@@ -141,7 +141,7 @@ Makes sure that :value is compiled."
                    (error "Don't know how to handle variable value %S" nval)))
             )
           (setq val (cdr val)))
-        (oset this :compiled (nreverse comp))))))
+        (oset this compiled (nreverse comp))))))
 
 ;;; DICTIONARY METHODS
 ;;
@@ -223,7 +223,7 @@ TPL is an object representing a compiled template file."
     ;; Tables are sorted with highest priority first, useful for looking
     ;; up templates, but this means we need to install the variables in
     ;; reverse order so higher priority variables override lower ones.
-    (let ((tabs (reverse (oref tpl :tables))))
+    (let ((tabs (reverse (oref tpl tables))))
       (require 'srecode/find) ; For srecode-template-table-in-project-p
       (while tabs
         (when (srecode-template-table-in-project-p (car tabs))
@@ -518,7 +518,7 @@ inserted with a new editable field.")
     (let* ((dv (oref cp defaultvalue))
            (sti (oref cp firstinserter))
            (start (point))
-           (name (oref sti :object-name)))
+           (name (oref sti object-name)))
 
       (cond
        ;; No default value.
diff --git a/lisp/cedet/srecode/el.el b/lisp/cedet/srecode/el.el
index 0bc8e1f450c..33b75cad692 100644
--- a/lisp/cedet/srecode/el.el
+++ b/lisp/cedet/srecode/el.el
@@ -86,7 +86,7 @@ Calls `srecode-semantic-apply-tag-to-dict-default' first."
   (srecode-semantic-apply-tag-to-dict-default tagobj dict)
 
   ;; Pull out the tag for the individual pieces.
-  (let* ((tag (oref tagobj :prime))
+  (let* ((tag (oref tagobj prime))
          (doc (semantic-tag-docstring tag)))
 
     ;; It is much more common to have doc on ELisp.
diff --git a/lisp/cedet/srecode/extract.el b/lisp/cedet/srecode/extract.el
index acb200a46ec..c46ff7e38f7 100644
--- a/lisp/cedet/srecode/extract.el
+++ b/lisp/cedet/srecode/extract.el
@@ -161,10 +161,9 @@ Return nil as this inserter will extract nothing."
 Return t if something was extracted.
 Return nil if this inserter doesn't need to extract anything."
   (srecode-dictionary-set-value vdict
-                                (oref ins :object-name)
+                                (oref ins object-name)
                                 (buffer-substring-no-properties
-                                 start end)
-                                )
+                                 start end))
   t)
 
 ;;; Section Inserter
@@ -178,10 +177,9 @@ Return nil if this inserter doesn't need to extract anything."
   "Extract text from START/END and store in INDICT.
 Return the starting location of the first plain-text match.
 Return nil if nothing was extracted."
-  (let ((name (oref ins :object-name))
+  (let ((name (oref ins object-name))
         (subdict (srecode-create-dictionary indict))
-        (allsubdict nil)
-        )
+        (allsubdict nil))
 
     ;; Keep extracting till we can extract no more.
     (while (condition-case nil
@@ -217,10 +215,10 @@ Return nil if nothing was extracted."
   ;; There are two modes for includes.  One is with no dict,
   ;; so it is inserted straight.  If the dict has a name, then
   ;; we need to run once per dictionary occurrence.
-  (if (not (string= (oref ins :object-name) ""))
+  (if (not (string= (oref ins object-name) ""))
       ;; With a name, do the insertion.
       (let ((subdict (srecode-dictionary-add-section-dictionary
-                      dict (oref ins :object-name))))
+                      dict (oref ins object-name))))
         (error "Need to implement include w/ name extractor")
         ;; Recurse into the new template while no errors.
         (while (condition-case nil
diff --git a/lisp/cedet/srecode/find.el b/lisp/cedet/srecode/find.el
index f5ddc619b8c..f130edcee8d 100644
--- a/lisp/cedet/srecode/find.el
+++ b/lisp/cedet/srecode/find.el
@@ -100,7 +100,7 @@ all template files for that application will be loaded."
   "Return non-nil if the table TAB can be used in the current project.
 If TAB has a :project set, check that the directories match.
 If TAB is nil, then always return t."
-  (let ((proj (oref tab :project)))
+  (let ((proj (oref tab project)))
     ;; Return t if the project wasn't set.
     (if (not proj) t
       ;; If the project directory was set, let's check it.
@@ -139,10 +139,10 @@ Optional argument APPLICATION restricts searches to only template tables
 belonging to a specific application.  If APPLICATION is nil, then only
 tables that do not belong to an application will be searched."
   (let* ((mt tab)
-         (tabs (oref mt :tables))
+         (tabs (oref mt tables))
          (ans nil))
     (while (and (not ans) tabs)
-      (let ((app (oref (car tabs) :application)))
+      (let ((app (oref (car tabs) application)))
         (when (or (and (not application) (null app))
                   (and application (eq app application)))
           (setq ans (srecode-template-get-table (car tabs) template-name
@@ -150,7 +150,7 @@ tables that do not belong to an application will be searched."
         (setq tabs (cdr tabs))))
     (or ans
         ;; Recurse to the default.
-        (when (not (equal (oref tab :major-mode) 'default))
+        (when (not (equal (oref tab major-mode) 'default))
           (srecode-template-get-table (srecode-get-mode-table 'default)
                                       template-name context application)))))
 
@@ -199,10 +199,10 @@ Optional argument APPLICATION restricts searches to only template tables
 belonging to a specific application.  If APPLICATION is nil, then only
 tables that do not belong to an application will be searched."
   (let* ((mt tab)
-         (tabs (oref mt :tables))
+         (tabs (oref mt tables))
          (ans nil))
     (while (and (not ans) tabs)
-      (let ((app (oref (car tabs) :application)))
+      (let ((app (oref (car tabs) application)))
         (when (or (and (not application) (null app))
                   (and application (eq app application)))
           (setq ans (srecode-template-get-table-for-binding
@@ -210,7 +210,7 @@ tables that do not belong to an application will be searched."
         (setq tabs (cdr tabs))))
     (or ans
         ;; Recurse to the default.
-        (when (not (equal (oref tab :major-mode) 'default))
+        (when (not (equal (oref tab major-mode) 'default))
           (srecode-template-get-table-for-binding
            (srecode-get-mode-table 'default) binding context)))))
 ;;; Interactive
@@ -241,10 +241,10 @@ templates."
 
     ;; Load up the hash table for our current mode.
     (let* ((mt   (srecode-get-mode-table mmode))
-           (tabs (when mt (oref mt :tables))))
+           (tabs (when mt (oref mt tables))))
       (dolist (tab tabs)
         ;; Exclude templates for a particular application.
-        (when (and (not (oref tab :application))
+        (when (and (not (oref tab application))
                    (srecode-template-table-in-project-p tab))
           (maphash (lambda (key temp)
                      (when (or (not predicate)
diff --git a/lisp/cedet/srecode/insert.el b/lisp/cedet/srecode/insert.el
index 66bdf785c63..d23597ec479 100644
--- a/lisp/cedet/srecode/insert.el
+++ b/lisp/cedet/srecode/insert.el
@@ -471,12 +471,11 @@ If SECONDNAME is nil, return VALUE."
                                   dictionary)
   "Insert the STI inserter."
   ;; Convert the name into a name/fcn pair
-  (let* ((name (oref sti :object-name))
-         (fcnpart (oref sti :secondname))
+  (let* ((name (oref sti object-name))
+         (fcnpart (oref sti secondname))
          (val (srecode-dictionary-lookup-name
                dictionary name))
-         (do-princ t)
-         )
+         (do-princ t))
     ;; Alert if a macro wasn't found.
     (when (not val)
       (message "Warning: macro %S was not found in the dictionary." name)
@@ -545,12 +544,12 @@ Loop over the prompts to see if we have a match."
         )
     (while prompts
       (when (string= (semantic-tag-name (car prompts))
-                     (oref ins :object-name))
-        (oset ins :prompt
+                     (oref ins object-name))
+        (oset ins prompt
               (semantic-tag-get-attribute (car prompts) :text))
-        (oset ins :defaultfcn
+        (oset ins defaultfcn
               (semantic-tag-get-attribute (car prompts) :default))
-        (oset ins :read-fcn
+        (oset ins read-fcn
               (or (semantic-tag-get-attribute (car prompts) :read)
                   'read-string))
         )
@@ -561,7 +560,7 @@ Loop over the prompts to see if we have a match."
                                   dictionary)
   "Insert the STI inserter."
   (let ((val (srecode-dictionary-lookup-name
-              dictionary (oref sti :object-name))))
+              dictionary (oref sti object-name))))
     (if val
         ;; Does some extra work.  Oh well.
         (cl-call-next-method)
@@ -577,7 +576,7 @@ Loop over the prompts to see if we have a match."
       ;; the user can use the same name again later.
       (srecode-dictionary-set-value
        (srecode-root-dictionary dictionary)
-       (oref sti :object-name) val)
+       (oref sti object-name) val)
 
       ;; Now that this value is safely stowed in the dictionary,
       ;; we can do what regular inserters do.
@@ -587,7 +586,7 @@ Loop over the prompts to see if we have a match."
                                        dictionary)
   "Derive the default value for an askable inserter STI.
 DICTIONARY is used to derive some values."
-  (let ((defaultfcn (oref sti :defaultfcn)))
+  (let ((defaultfcn (oref sti defaultfcn)))
     (cond
      ((stringp defaultfcn)
       defaultfcn)
@@ -614,13 +613,13 @@ DICTIONARY is used to derive some values."
 Use DICTIONARY to resolve values."
   (let* ((prompt (oref sti prompt))
          (default (srecode-insert-ask-default sti dictionary))
-         (reader (oref sti :read-fcn))
+         (reader (oref sti read-fcn))
          (val nil)
          )
     (cond ((eq reader 'y-or-n-p)
            (if (y-or-n-p (or prompt
                              (format "%s? "
-                                     (oref sti :object-name))))
+                                     (oref sti object-name))))
                (setq val default)
              (setq val "")))
           ((eq reader 'read-char)
@@ -628,14 +627,14 @@ Use DICTIONARY to resolve values."
                       "%c"
                       (read-char (or prompt
                                      (format "Char for %s: "
-                                             (oref sti :object-name))))))
+                                             (oref sti object-name))))))
            )
           (t
            (save-excursion
              (setq val (funcall reader
                                 (or prompt
                                     (format "Specify %s: "
-                                            (oref sti :object-name)))
+                                            (oref sti object-name)))
                                 default
                                 )))))
     ;; Return our derived value.
@@ -648,7 +647,7 @@ Use DICTIONARY to resolve values."
 Use DICTIONARY to resolve values."
   (let* ((default (srecode-insert-ask-default sti dictionary))
          (compound-value
-          (srecode-field-value (oref sti :object-name)
+          (srecode-field-value (oref sti object-name)
                                :firstinserter sti
                                :defaultvalue default))
          )
@@ -816,12 +815,12 @@ Arguments ESCAPE-START and ESCAPE-END are the current escape sequences in use."
 Loops over the embedded CODE which was saved here during compilation.
 The template to insert is stored in SLOT."
   (let ((dicts (srecode-dictionary-lookup-name
-                dictionary (oref sti :object-name))))
+                dictionary (oref sti object-name))))
     (when (not (listp dicts))
       (srecode-insert-report-error
        dictionary
        "Cannot insert section %S from non-section variable."
-       (oref sti :object-name)))
+       (oref sti object-name)))
     ;; If there is no section dictionary, then don't output anything
     ;; from this section.
     (while dicts
@@ -829,7 +828,7 @@ The template to insert is stored in SLOT."
         (srecode-insert-report-error
          dictionary
          "Cannot insert section %S from non-section variable."
-         (oref sti :object-name)))
+         (oref sti object-name)))
       (srecode-insert-subtemplate sti (car dicts) slot)
       (setq dicts (cdr dicts)))))
 
@@ -860,7 +859,7 @@ applied to the text between the section start and the
 Shorten input until the END token is found.
 Return the remains of INPUT."
   (let* ((out (srecode-compile-split-code tag input STATE
-                                          (oref ins :object-name))))
+                                          (oref ins object-name))))
     (oset ins template (srecode-template
                         (eieio-object-name-string ins)
                         :context nil
@@ -893,7 +892,7 @@ are treated specially.")
 (cl-defmethod srecode-match-end ((ins srecode-template-inserter-section-end) name)
 
   "For the template inserter INS, do I end a section called NAME?"
-  (string= name (oref ins :object-name)))
+  (string= name (oref ins object-name)))
 
 (defclass srecode-template-inserter-include (srecode-template-inserter-subtemplate)
   ((key :initform ?>
@@ -924,13 +923,13 @@ Arguments ESCAPE-START and ESCAPE-END are the current escape sequences in use."
   "For the template inserter STI, lookup the template to include.
 Finds the template with this macro function part and stores it in
 this template instance."
-  (let ((templatenamepart (oref sti :secondname)))
+  (let ((templatenamepart (oref sti secondname)))
     ;; If there was no template name, throw an error.
     (unless templatenamepart
       (srecode-insert-report-error
        dictionary
        "Include macro `%s' needs a template name"
-       (oref sti :object-name)))
+       (oref sti object-name)))
 
     ;; NOTE: We used to cache the template and not look it up a second time,
     ;; but changes in the template tables can change which template is
@@ -968,14 +967,14 @@ this template instance."
         )
 
       ;; Store the found template into this object for later use.
-      (oset sti :includedtemplate tmpl))
+      (oset sti includedtemplate tmpl))
 
     (unless (oref sti includedtemplate)
       ;; @todo - Call into a debugger to help find the template in question.
       (srecode-insert-report-error
        dictionary
        "No template \"%s\" found for include macro `%s'"
-       templatenamepart (oref sti :object-name)))))
+       templatenamepart (oref sti object-name)))))
 
 (cl-defmethod srecode-insert-method ((sti srecode-template-inserter-include)
                                   dictionary)
@@ -985,7 +984,7 @@ with the dictionaries found in the dictionary."
   (srecode-insert-include-lookup sti dictionary)
   ;; Insert the template.
   ;; Our baseclass has a simple way to do this.
-  (if (srecode-dictionary-lookup-name dictionary (oref sti :object-name))
+  (if (srecode-dictionary-lookup-name dictionary (oref sti object-name))
       ;; If we have a value, then call the next method
       (srecode-insert-method-helper sti dictionary 'includedtemplate)
     ;; If we don't have a special dictionary, then just insert with the
@@ -1053,7 +1052,7 @@ template where a ^ inserter occurs."
           (lambda (dict)
             (let ((srecode-template-inserter-point-override nil))
               (if (srecode-dictionary-lookup-name
-                   dict (oref sti :object-name))
+                   dict (oref sti object-name))
                   ;; Insert our sectional part with looping.
                   (srecode-insert-method-helper
                    sti dict 'template)
diff --git a/lisp/cedet/srecode/mode.el b/lisp/cedet/srecode/mode.el
index a47520e013a..a40b9d09a6f 100644
--- a/lisp/cedet/srecode/mode.el
+++ b/lisp/cedet/srecode/mode.el
@@ -195,7 +195,7 @@ MENU-DEF is the menu to bind this into."
   ;;(srecode-load-tables-for-mode major-mode)
 
   (let* ((modetable (srecode-get-mode-table major-mode))
-         (subtab (when modetable (oref modetable :tables)))
+         (subtab (when modetable (oref modetable tables)))
          (context nil)
          (active nil)
          (ltab nil)
@@ -318,17 +318,17 @@ Template is chosen based on the mode of the starting buffer."
       (if (not temp)
           (error "No Template named %s" template-name))
       ;; We need a template specific table, since tables chain.
-      (let ((tab (oref temp :table))
+      (let ((tab (oref temp table))
             (names nil)
             )
-        (find-file (oref tab :file))
-        (setq names (semantic-find-tags-by-name (oref temp :object-name)
+        (find-file (oref tab file))
+        (setq names (semantic-find-tags-by-name (oref temp object-name)
                                                 (current-buffer)))
         (cond ((= (length names) 1)
                (semantic-go-to-tag (car names))
                (semantic-momentary-highlight-tag (car names)))
               ((> (length names) 1)
-               (let* ((ctxt (semantic-find-tags-by-name (oref temp :context)
+               (let* ((ctxt (semantic-find-tags-by-name (oref temp context)
                                                         (current-buffer)))
                       (cls (semantic-find-tags-by-class 'context ctxt))
                       )
diff --git a/lisp/cedet/srecode/semantic.el b/lisp/cedet/srecode/semantic.el
index ea11b0e4838..1e1a60e0245 100644
--- a/lisp/cedet/srecode/semantic.el
+++ b/lisp/cedet/srecode/semantic.el
@@ -63,10 +63,9 @@ If FUNCTION is non-nil, then FUNCTION is somehow applied to an
 aspect of the compound value."
   (if (not function)
       ;; Just format it in some handy dandy way.
-      (semantic-format-tag-prototype (oref cp :prime))
+      (semantic-format-tag-prototype (oref cp prime))
     ;; Otherwise, apply the function to the tag itself.
-    (funcall function (oref cp :prime))
-    ))
+    (funcall function (oref cp prime))))
 
 
 ;;; Managing the `current' tag
@@ -106,7 +105,7 @@ variable default values, and other things."
   (srecode-dictionary-set-value dict "TAG" tagobj)
 
   ;; Pull out the tag for the individual pieces.
-  (let ((tag (oref tagobj :prime)))
+  (let ((tag (oref tagobj prime)))
 
     (srecode-dictionary-set-value dict "NAME" (semantic-tag-name tag))
     (srecode-dictionary-set-value dict "TYPE" (semantic-format-tag-type tag nil))
diff --git a/lisp/cedet/srecode/srt-mode.el b/lisp/cedet/srecode/srt-mode.el
index 6bf2d51ab41..a4c8cbd1d01 100644
--- a/lisp/cedet/srecode/srt-mode.el
+++ b/lisp/cedet/srecode/srt-mode.el
@@ -502,10 +502,10 @@ section or ? for an ask variable."
                  )
             (when inserter
               (let ((base
-                     (cons (oref inserter :object-name)
+                     (cons (oref inserter object-name)
                            (if (and (slot-boundp inserter :secondname)
-                                    (oref inserter :secondname))
-                               (split-string (oref inserter :secondname)
+                                    (oref inserter secondname))
+                               (split-string (oref inserter secondname)
                                              ":")
                              nil)))
                     (key (oref inserter key)))
@@ -627,7 +627,7 @@ section or ? for an ask variable."
   srecode-template-mode (context)
   "Return a list of possible completions based on NONTEXT."
   (with-current-buffer (oref context buffer)
-    (let* ((prefix (car (last (oref context :prefix))))
+    (let* ((prefix (car (last (oref context prefix))))
            (prefixstr (cond ((stringp prefix)
                              prefix)
                             ((semantic-tag-p prefix)
@@ -638,7 +638,7 @@ section or ? for an ask variable."
 ;                               prefix)
 ;                              ((stringp (car prefix))
 ;                               (car prefix))))
-           (argtype (car (oref context :argument)))
+           (argtype (car (oref context argument)))
            (matches nil))
 
       ;; Depending on what the analyzer is, we have different ways
diff --git a/lisp/cedet/srecode/table.el b/lisp/cedet/srecode/table.el
index 95d8bfa1bc5..7a0600c3f81 100644
--- a/lisp/cedet/srecode/table.el
+++ b/lisp/cedet/srecode/table.el
@@ -201,8 +201,8 @@ INIT are the initialization parameters for the new template table."
     ;; into the search table first, allowing lower priority items
     ;; to be the items found in the search table.
     (object-sort-list mt 'modetables (lambda (a b)
-                                       (> (oref a :priority)
-                                          (oref b :priority))))
+                                       (> (oref a priority)
+                                          (oref b priority))))
     ;; Return it.
     new))
 
@@ -239,9 +239,9 @@ Use PREDICATE is the same as for the `sort' function."
 (cl-defmethod srecode-dump ((tab srecode-mode-table))
   "Dump the contents of the SRecode mode table TAB."
   (princ "MODE TABLE FOR ")
-  (princ (oref tab :major-mode))
+  (princ (oref tab major-mode))
   (princ "\n--------------------------------------------\n\nNumber of tables: ")
-  (let ((subtab (oref tab :tables)))
+  (let ((subtab (oref tab tables)))
     (princ (length subtab))
     (princ "\n\n")
     (while subtab
@@ -254,17 +254,17 @@ Use PREDICATE is the same as for the `sort' function."
   (princ "Template Table for ")
   (princ (eieio-object-name-string tab))
   (princ "\nPriority: ")
-  (prin1 (oref tab :priority))
-  (when (oref tab :application)
+  (prin1 (oref tab priority))
+  (when (oref tab application)
     (princ "\nApplication: ")
-    (princ (oref tab :application)))
-  (when (oref tab :framework)
+    (princ (oref tab application)))
+  (when (oref tab framework)
     (princ "\nFramework: ")
-    (princ (oref tab :framework)))
-  (when (oref tab :project)
+    (princ (oref tab framework)))
+  (when (oref tab project)
     (require 'srecode/find) ; For srecode-template-table-in-project-p
     (princ "\nProject Directory: ")
-    (princ (oref tab :project))
+    (princ (oref tab project))
     (when (not (srecode-template-table-in-project-p tab))
       (princ "\n   ** Not Usable in this file. **")))
   (princ "\n\nVariables:\n")
diff --git a/lisp/cedet/srecode/texi.el b/lisp/cedet/srecode/texi.el
index 212b56c6ca0..bb2b7c91316 100644
--- a/lisp/cedet/srecode/texi.el
+++ b/lisp/cedet/srecode/texi.el
@@ -156,7 +156,7 @@ Adds the following:
       (error "No tag to insert for :texitag template argument"))
 
     ;; Extract the tag out of the compound object.
-    (setq tag (oref tag :prime))
+    (setq tag (oref tag prime))
 
     ;; Extract the doc string
     (setq doc (semantic-documentation-for-tag tag))