ctrl+shift+p filters: :st2 :st3 :win :osx :linux
Browse

C Improved

by abusalimov ST2/ST3

Improved syntax for C/C++/Objective-C, with a special support for sources of Linux kernel, CPython, etc.

Details

Installs

  • Total 57K
  • Win 26K
  • OS X 11K
  • Linux 20K
Oct 20 Oct 19 Oct 18 Oct 17 Oct 16 Oct 15 Oct 14 Oct 13 Oct 12 Oct 11 Oct 10 Oct 9 Oct 8 Oct 7 Oct 6 Oct 5 Oct 4 Oct 3 Oct 2 Oct 1 Sep 30 Sep 29 Sep 28 Sep 27 Sep 26 Sep 25 Sep 24 Sep 23 Sep 22 Sep 21 Sep 20 Sep 19 Sep 18 Sep 17 Sep 16 Sep 15 Sep 14 Sep 13 Sep 12 Sep 11 Sep 10 Sep 9 Sep 8 Sep 7 Sep 6 Sep 5
Windows 34 41 38 46 43 37 32 40 45 27 36 31 41 32 52 20 30 34 40 33 32 37 59 44 46 35 43 44 37 37 37 44 42 36 41 46 60 52 34 29 25 19 30 38 40 42
OS X 11 14 14 20 14 8 12 15 15 13 11 7 17 11 12 11 8 18 10 13 12 19 14 15 22 13 13 14 13 15 22 22 12 14 10 13 25 19 11 2 4 9 4 18 8 11
Linux 10 27 22 29 28 20 27 40 32 16 28 16 24 28 23 20 23 26 21 41 31 30 32 34 42 29 18 28 26 31 24 39 32 19 21 35 48 34 24 16 16 13 19 30 24 31

Readme

Source
raw.​githubusercontent.​com

Sublime C Improved

This package provides better support of C/C++/Objective-C languages in Sublime Text.

It is primarily focused on pure C overriding a standard syntax definition shipped with Sublime Text, though once installed it affects other C-family languages as well. Note that C Improved per se provides only the syntax definition among with some symbol indexing settings, nothing more. That is, it is not a self-sustained package, but only an addition (improvement) to the standard C++ package.

What is improved?

Most of C Improved features tend to facilitate everyday C development experience. This varies from enabling highlighting of operators to more complex enhancements listed below.

Preprocessor issues

C preprocessor directives are relatively simple to parse (even with regular expressions, to some extent). And so related issues were addressed first of all.

Macro highlighting and error handling

Macro parameters (including variadic arguments) and argument stringification now have proper highlighting with handling of some common syntax errors.

Here is an example of two more or less complex multi-line macros.

Standard C C Improved
Standard C macros C Improved macros

And below is a result of commenting out a msg... vararg (but missing a preceding comma outside the comment) and accidentally putting tabs after some line continuation backslashes.

Standard C C Improved
Standard C macros C Improved macros

Both errors are ignored by the standard package, while C Improved highlights a premature closing paren in the first case as an error, and warns about trailing whitespaces after the backslashes (the second one is immediately followed by an error complaining about an unexpected EOL within macro parameters). See an issue about space-after-continuation highlighting.

Macro innards

A macro body (with proper line continuations, if needed) is not able to contribute to the symbol index anymore, nor it can interfere with a code surrounding the macro, or anyhow break syntax highlighting.

Standard C C Improved
Standard C macro symbols C Improved macro symbols

In this example the standard C package recognizes check_range(...) inside a macro as a function definition though it is actually a function call. This leads to incorrect highlighting and also adds a bogus symbol into the symbol list. Moreover, a function declaration which follows the macro (int irq_attach(...)) is not recognized at all.

Scopes for preprocessor directives

All preprocessor directives provide a proper scope now (meta.preprocessor), which means that you can select a whole macro with ctrl+shift+space or ++space. It also allows, for instance, the whole macro body to be styled differently (this is up to a color scheme though).

Support for significant projects

The standard C package provides a special support for functions from C standard library and POSIX. For example, a printf function is highlighted differently.

However, most of major software projects implemented in C have their own internal libraries/frameworks and use some established patterns and idioms all across their sources. This includes not only a set of commonly used functions and types; there could be a handful macro for defining some object, a special kind of function attribute/annotation, etc.

If you use Sublime Text for developing some of the following projects, you should find these improvements rather useful.

Linux kernel source

This adds a special handling of some common macros widely used across the kernel source code, like EXPORT_SYMBOL, LIST_HEAD or DEFINE_XXX, which would otherwise be recognized as functions thus polluting a symbol index and an outline.

Standard C C Improved
Standard C linux support C Improved linux support

Windows drivers

Provides special highlighting for SAL function annotations listed here (related issue).

CPython interpreter source

This includes:

  • Highlighing of Python-related constants (like PyTrue or PyFalse) and main data structures (PyObject, PyTypeObject, PyListObject, etc.)
  • Widely used PyMODINIT_FUNC, PyAPI_FUNC(...) and Py_LOCAL(...) function annotation. This sanitizes higlighting of annotated functions and the symbol index
  • Special highlighting of PyId_xxx interned static string literals defined with _Py_IDENTIFIER(...) macro
  • Well-marked highlighting of macros involving transfer of control (like Py_RETURN_NONE).
Standard C C Improved
Standard C CPython support C Improved CPython support

Customizable indexing of types/functions/macros

You can adjust which symbols are available for navigation and visible in a symbol index or in an outline.

The following scopes and default preferences are provided:

Scope name Description Outline
ctrl+R
Index (ST3) F12
ctrl+shift+R
entity.name.type compound type visible visible
entity.name.type.declaration forward declaration of a type visible hidden
entity.name.type.typedef type alias (typedef) visible visible
entity.name.function function definition visible visible
entity.name.function.declaration function declaration visible hidden
entity.name.function.preprocessor function-like macro visible visible
entity.name.constant.preprocessor object-like macro visible visible

These settings can be changed through .tmPreferences files, see Packages/C Improved/Symbol Index (*).tmPreferences.

Dropped features

#if 1 ... #else conditionals

The standard syntax highlights recognizes #else part after #if 1 conditional as a comment. This is a really nice feature, however it is rather fragile and has many issues, e.g. with unterminated blocks (opening/closing brace inside a preprocessor conditional). So for sake of simplicity it was decided to remove it at all, leaving only a plain #if 0 handling, which is more or less stable and has pretty straightforward implementation.

You may however checkout a preprocessor-cond-scopes branch which doesn't have this limitation.

Local variable declaration/initialization

C can be quite complicated to parse in some parts, for example related to pointer declarations (what is t * v? Is it a simple multiplication, or a declaration of a pointer to type t called v?). Needless to say, it is just impossible to parse C using regular expressions. Therefore, C Improved doesn't try to recognize variable declarations, so there is no distinct scope/highlighting for them.

Some discussion on this can be found in a related issue.

Installation

Package Control

With Package Control installed:

  • Open Command Palette (ctrl+shift+P or ++P)
  • Select Package Control: Install Package (pkginst)
  • Search for C Improved (cimp) package and install it

Manual

Locate Sublime Text Packages directory (Preferences → Browse Packages…) and clone this repository into C Improved:

git clone https://github.com/abusalimov/SublimeCImproved.git "C Improved"

Usage

Once installed C Improved will be used instead of the standard C syntax when opening .c and .h files, unless you have forcibly bound these extensions to something else. In the latter case you can rebind them to be handled by C Improved through View → Syntax → Open all with current extension as… → C Improved.

Other languages derived from C (like C++ and Objective C) don't need their syntaxes to be changed to something special: they usually extend source.c under the hood, which is now provided by C Improved syntax.