Function: srecode-semantic-apply-tag-to-dict-c-mode

srecode-semantic-apply-tag-to-dict-c-mode is a byte-compiled function defined in cpp.el.gz.

Signature

(srecode-semantic-apply-tag-to-dict-c-mode TAG-WRAPPER DICT)

Documentation

Apply C and C++ specific features from TAG-WRAPPER into DICT.

Calls srecode-semantic-apply-tag-to-dict-default first. Adds special behavior for tag of classes include, using and function.

This function cannot be split into C and C++ specific variants, as the way the tags are created from the parser does not distinguish either. The side effect is that you could get some C++ tag properties specified in a C file. Override srecode-semantic-apply-tag-to-dict in c-mode buffers.

Source Code

;; Defined in /usr/src/emacs/lisp/cedet/srecode/cpp.el.gz
(define-mode-local-override srecode-semantic-apply-tag-to-dict
  c-mode (tag-wrapper dict)
  "Apply C and C++ specific features from TAG-WRAPPER into DICT.
Calls `srecode-semantic-apply-tag-to-dict-default' first.  Adds
special behavior for tag of classes include, using and function.

This function cannot be split into C and C++ specific variants, as
the way the tags are created from the parser does not distinguish
either.  The side effect is that you could get some C++ tag properties
specified in a C file."

  ;; Use default implementation to fill in the basic properties.
  (srecode-semantic-apply-tag-to-dict-default tag-wrapper dict)

  ;; Pull out the tag for the individual pieces.
  (let* ((tag   (oref tag-wrapper prime))
	 (class (semantic-tag-class tag)))

    ;; Add additional information based on the class of the tag.
    (cond
     ;;
     ;; INCLUDE
     ;;
     ((eq class 'include)
      ;; For include tags, we have to discriminate between system-wide
      ;; and local includes.
      (if (semantic-tag-include-system-p tag)
	(srecode-dictionary-show-section dict "SYSTEM")
	(srecode-dictionary-show-section dict "LOCAL")))

     ;;
     ;; USING
     ;;
     ((eq class 'using)
      ;; Insert the subject (a tag) of the include statement as VALUE
      ;; entry into the dictionary.
      (let ((value-tag  (semantic-tag-get-attribute tag :value))
	    (value-dict (srecode-dictionary-add-section-dictionary
			 dict "VALUE")))
	(srecode-semantic-apply-tag-to-dict
	 (srecode-semantic-tag :prime value-tag)
	 value-dict))

      ;; Discriminate using statements referring to namespaces and
      ;; types.
      (when (eq (semantic-tag-get-attribute tag :kind) 'namespace)
	(srecode-dictionary-show-section dict "NAMESPACE")))

     ;;
     ;; FUNCTION
     ;;
     ((eq class 'function)
      ;; @todo It would be nice to distinguish member functions from
      ;; free functions and only apply the const and pure modifiers,
      ;; when they make sense. My best bet would be
      ;; (semantic-tag-function-parent tag), but it is not there, when
      ;; the function is defined in the scope of a class.
      (let (;; (member t)
	    (templates (semantic-tag-get-attribute tag :template))
	    (modifiers (semantic-tag-modifiers tag)))

	;; Mark constructors and destructors as such.
	(when (semantic-tag-function-constructor-p tag)
	  (srecode-dictionary-show-section dict "CONSTRUCTOR"))
	(when (semantic-tag-function-destructor-p tag)
	  (srecode-dictionary-show-section dict "DESTRUCTOR"))

	;; Add modifiers into the dictionary.
	(dolist (modifier modifiers)
	  (let ((modifier-dict (srecode-dictionary-add-section-dictionary
				dict "MODIFIERS")))
	    (srecode-dictionary-set-value modifier-dict "NAME" modifier)))

	;; Add templates into child dictionaries.
	(srecode-c-apply-templates dict templates)

	;; When the function is a member function, it can have
	;; additional modifiers.
	(when t ;; member

	  ;; For member functions, constness is called
	  ;; 'methodconst-flag'.
	  (when (semantic-tag-get-attribute tag :methodconst-flag)
	    (srecode-dictionary-show-section dict "CONST"))

	  ;; If the member function is pure virtual, add a dictionary
	  ;; entry.
	  (when (semantic-tag-get-attribute tag :pure-virtual-flag)
	    (srecode-dictionary-show-section dict "PURE")))))

     ;;
     ;; CLASS
     ;;
     ((eq class 'type)
      ;; For classes, add template parameters.
      (when (or (semantic-tag-of-type-p tag "class")
		(semantic-tag-of-type-p tag "struct"))

	;; Add templates into child dictionaries.
	(let ((templates (semantic-tag-get-attribute tag :template)))
	  (srecode-c-apply-templates dict templates))))
     ))
  )