All standalone versions until release 1.1 (including) had activation method that was different from method for CEDET bundled into GNU Emacs. In new versions activation of package is performed by adding of symbols for selected sub-modes into special list, and then activating semantic-mode. While in the "old" versions, functionality was activated by calling one of the functions, each of them activated some specific set of features. So in the "new" version, it's enough to do following:

(semantic-mode 1)

And set of enabled features will depend on what will be put into list semantic-default-submodes, that can contain following symbols (it's better to populate this list before enabling semantic-mode):

global-semanticdb-minor-mode

enables global support for Semanticdb;

global-semantic-mru-bookmark-mode

enables automatic bookmarking of tags that you edited, so you can return to them later with the semantic-mrub-switch-tags command;

global-cedet-m3-minor-mode

activates CEDET's context menu that is bound to right mouse button;

global-semantic-highlight-func-mode

activates highlighting of first line for current tag (function, class, etc.);

global-semantic-stickyfunc-mode

activates mode when name of current tag will be shown in top line of buffer;

global-semantic-decoration-mode

activates use of separate styles for tags decoration (depending on tag's class). These styles are defined in the semantic-decoration-styles list;

global-semantic-idle-local-symbol-highlight-mode

activates highlighting of local names that are the same as name of tag under cursor;

global-semantic-idle-scheduler-mode

activates automatic parsing of source code in the idle time;

global-semantic-idle-completions-mode

activates displaying of possible name completions in the idle time. Requires that global-semantic-idle-scheduler-mode was enabled;

global-semantic-idle-summary-mode

activates displaying of information about current tag in the idle time. Requires that global-semantic-idle-scheduler-mode was enabled.

Following sub-modes are usually useful when you develop and/or debug CEDET:

global-semantic-show-unmatched-syntax-mode

shows which elements weren't processed by current parser's rules;

global-semantic-show-parser-state-mode

shows current parser state in the modeline;

global-semantic-highlight-edits-mode

shows changes in the text that weren't processed by incremental parser yet.

This approach allows to make Semantic's customization more flexible, as user can switch on only necessary features. You can also use functions with the same names to enable/disable corresponding sub-modes for current Emacs session. And you can also enable/disable these modes on the per-buffer basis (usually this is done from hook): names of corresponding variables you can find in description of global-semantic-* functions.

To enable more advanced functionality for name completion, etc., you can load the semantic/ia with following command:

(require 'semantic/ia)

After loading of this package, you'll get access to commands, described below.

To normal work with system-wide libraries, Semantic should has access to system include files, that contain information about functions & data types, implemented by these libraries.

If you're using GCC for programming in C & C++, then Semantic can automatically find directory, where system include files are stored. Just load semantic/bovine/gcc package with following command:

(require 'semantic/bovine/gcc)

You can also explicitly specify additional directories for searching of include files (and these directories also could be different for specific modes). To add some directory to list of system include paths, you can use the semantic-add-system-include command --- it accepts two parameters: string with path to include files, and symbol, representing name of major mode, for which this path will be used. For example, to add Boost header files for C++ mode, you need to add following code:

(semantic-add-system-include "~/exp/include/boost_1_37" 'c++-mode)

Although I want to say, that customization for Boost support is more complex, and requires to specify where Semantic can find files with constant's definitions, etc.

To optimize work with tags, you can use several techniques:

• limit search by using an EDE project, as described below;
• explicitly specify a list of root directories for your projects, so Semantic will use limited number of databases with syntactic information;
• explicitly generate tags databases for often used directories (/usr/include, /usr/local/include, etc.). You can use commands semanticdb-create-ebrowse-database or semanticdb-create-cscope-database;
• limit search by customization of the semanticdb-find-default-throttle variable for concrete modes --- for example, don't use information from system include files, by removing system symbol from list of objects to search for c-mode:

(setq-mode-local c-mode semanticdb-find-default-throttle
 '(project unloaded system recursive))

Semantic extracts syntactic information when Emacs is idle. You can customize the semantic-idle-scheduler-idle-time variable to specify idle time (in seconds), if you don't want to use default value (1 second).

The Semantic package can be integrated with the imenu package. This lead to creation of a menu with a list of functions, variables, and other tags. To enable this feature you need to add following code into your initialization file:

(defun my-semantic-hook ()
 (imenu-add-to-menubar "TAGS"))
(add-hook 'semantic-init-hooks 'my-semantic-hook)

To enable Semanticdb you need to add the global-semanticdb-minor-mode symbol into the semantic-default-submodes list. And you can specify some customization variables to control behaviour of Semanticdb --- for example, where to save data, etc. These variables could be set via semanticdb customization group.

Semanticdb can also use databases generated by external utilities: gtags (from GNU Global), exubertant ctags, ebrowse & cscope. To activate this functionality you can use following code (please, note that these commands may fail if you have no utilities installed, or have an incorrect versions of them --- that's why they a wrapped into when):

;; if you want to enable support for gnu global
(when (cedet-gnu-global-version-check t)
 (semanticdb-enable-gnu-global-databases 'c-mode)
 (semanticdb-enable-gnu-global-databases 'c++-mode))

;; enable ctags for some languages:
;; Unix Shell, Perl, Pascal, Tcl, Fortran, Asm
(when (cedet-ectag-version-check t)
 (semantic-load-enable-primary-exuberent-ctags-support))

If you plan to use projects, then you need to enable corresponding mode, implemented by the EDE package:

(global-ede-mode t)

There are several types of projects supported by EDE, and I want to describe here only some of them.

Text completion for names of functions, variables & classes is pretty often used feature when you work with source code. There are two packages inside Semantic that implement this functionality --- semantic/ia and Senator (it doesn't included into GNU Emacs). You need to take into account, that in the new versions it's recommended to use Semantic only as source of information, and perform names completion using other packages, such as auto-complete. You see example below.

Commands, implemented by semantic/ia use the semantic-analyze-possible-completions function to create a list of all possible names completion, and this function takes into account many parameters (plus it can be augmented by user's code to provide more precise list of names). At the same time, commands from Senator package use simpler methods to create a list of all possibles completions (usually they use information only about definitions in the current file), and this sometime lead to wrong names completion.

If you execute the semantic-ia-complete-symbol command when you're typing code, then this will lead to completion of corresponding name --- name of function, variable, or class member, depending on the current context. If there are several possible variants, then this name will be completed to most common part, and if you'll call this command second time, then buffer with all possible completions will be shown. User can also use the semantic-ia-complete-symbol-menu command --- it also performs analysis of current context, but will display list of possible completions as a graphical menu, from which the required name should be selected. Besides this, there is semantic-ia-complete-tip command, that displays list of possible completions as tooltip.

As was mentioned above, the Senator package, also provides commands for names completion. It work very fast, but with less precision (as they use few parameters during computation of variants for completions). The senator-complete-symbol command (C-c , TAB) completes name for current tag, and insert first found completion as result. If it inserts wrong name, then you can insert second name from completion list by repeating this command, and so on. If there are a lot of the possible variants, or you want to see full list of functions and variables for some class, then it's better to use the senator-completion-menu-popup command (C-c , SPC) --- it displays list of all possible completions as a graphical menu.

Besides these commands, user can use special mode (only for some languages) --- semantic-idle-completions-mode (or enable it globally by adding global-semantic-idle-completions-mode symbol into semantic-default-submodes list) --- in this mode names completions are shown automatically if user stops its work for a some time (idle time). By default, only first possible completion is shown, and user can use the TAB key to navigate through list of possible completions.

For C-like languages, user can use the semantic-complete-self-insert command, bound to the . and/or > keys, as this shown below:

(defun my-c-mode-cedet-hook ()
 (local-set-key "." 'semantic-complete-self-insert)
 (local-set-key ">" 'semantic-complete-self-insert))
(add-hook 'c-mode-common-hook 'my-c-mode-cedet-hook)

Evaluation of this code will lead to execution of the semantic-complete-self-insert command when user will press . or > after variables, that are instances of some data structure, and displaying a list of possible completions for given class or structure.

If you're programming in C & C++, then you can also get name completions using information from Clang (versions 2.9 & above). To do this, you need to load the semantic/bovine/clang package, and call the semantic-clang-activate function. After that, Semantic will start to call Clang, and use its code analyzer to calculate list of possible names completions.

The semantic/ia package provides several commands, that allow to get information about classes, functions & variables (including documentation from Doxygen-style comments). Currently following commands are implemented:

semantic-ia-show-doc

shows documentation for function or variable, whose names is under point. Documentation is shown in separate buffer. For variables this command shows their declaration, including type of variable, and documentation string (if it's available). For functions, prototype of the function is shown, including documentation for arguments and returning value (if comments are available);

semantic-ia-show-summary

shows documentation for name under point, but information is shown in the mini-buffer, so user will see only variable's declaration or function's prototype;

semantic-ia-describe-class

asks user for a name of the class, and return list of functions & variables, defined in given class, plus all its parent classes.

One of the most useful commands for navigation in source code is the semantic-ia-fast-jump command, that allows to jump to declaration of variable or function, whose name is under point. You can return back by using the semantic-mrub-switch-tag command (C-x B), that is available when you enable the semantic-mru-bookmark-mode minor mode.

Semantic also provides two additional commands for jumping to function or variable: defined in current file --- semantic-complete-jump-local (C-c , j), or defined in current project --- semantic-complete-jump (C-c , J). Both commands allow to enter name of function or variable (including local variables inside functions) and jump to given definition (you can use name completion when entering the name).

The main difference between semantic-ia-fast-jump & semantic-complete-jump commands is that the first properly handles complex names, like this::that->foo(), while the second, can find only simple names, like foo.

The semantic-analyze-proto-impl-toggle command allows to switch between function's declaration and its implementation in languages, that allow to have separate declaration and implementation of functions. Another useful command is semantic-decoration-include-visit, that allows to jump to include file, whose name is under cursor.

Senator provides several commands for navigation in source code. This is senator-next-tag (C-c , n) and senator-previous-tag (C-c , p) commands, that move cursor to next or previous tag. There is also the senator-go-to-up-reference command (C-c , u), that moves cursor to the "parent" tag (for example, for class member function, "parent" tag is class declaration).

Semantic also has very useful command --- semantic-symref, that allows to find places, where symbol (whose name is under point) is used in your project. If you want to find use of symbol with arbitrary name, then you can use the semantic-symref-symbol command, that allows to enter name of the symbol to lookup.

If references to given name weren't found in corresponding database (GNU Global, etc.), then these commands will try to find them using the find-grep command. As result of execution of these commands, a new buffer with results will be created, and user can jump to found places:

As Semantic has almost complete syntactic information about source code, this allows it to implement folding functionality, similar to functionality implemented by hideshow package. To enable this feature, you need to perform customization of the global-semantic-tag-folding-mode variable. When you'll enable it, this will lead to displaying of small triangles at the fringle field, and you will able to fold and unfold pieces of code by clicking on them (this should work not only for source code, but also for comments, and other objects).

Senator also has similar functionality, but it's usually used for top-level objects --- functions, class declarations, etc. You can fold piece of code with the senator-fold-tag command (C-c , -), and unfold it with senator-unfold-tag (C-c , +).

The Senator package provides number of commands for work with tags, that allow user to cut or copy tag, and insert it in another place. To cut current tag (usually this is declaration of some function, or its implementation) the senator-kill-tag command (C-c , C-w) should be used. You can insert complete tag with standard key binding C-y, while the senator-yank-tag command (C-c , C-y) inserts only tag declaration, without body. Another useful command is senator-copy-tag (C-c , M-w), that copies current tag --- this is very handy when, for example, you want to insert declaration of function into include file.

Senator allows to change behaviour of standard search commands (re-search-forward, isearch-forward and other), when you work with source code, such way, so they will perform search only in the given tags. To enable this mode you can use the senator-isearch-toggle-semantic-mode command(C-c , i), and with the senator-search-set-tag-class-filter command (C-c , f) you can limit search to given tag types --- function for functions, variable for variables, etc.

You can also perform tags search without enabling this mode --- you just need to call corresponding command: senator-search-forward or senator-search-backward.

The eassist package provides several commands, that use information obtained from Semantic. By default, these commands have no predefined key bindings, so you need to select them yourself.

The eassist-list-methods command, executed in the file with source code, will show you a list of functions, defined in current buffer, and will allow you to perform quick jump to selected function.

If you develop code in C and/or C++ languages, then the eassist-switch-h-cpp command, could be very useful to you --- it jumps between header file and file, that contains implementation (if they have same names, but different extensions).

Last change: 12.03.2014 07:58