EasyClangComplete.sublime-settings

{
  // SETTINGS FOR EASY_CLANG_COMPLETE.

  // Every path variable in settings can contain wildcards (without the "").
  // Most commonly used:
  //  - "$project_base_path"  <-- replaced by the path to the root of the
  //                              project. This is usually specified under
  //                              "folder" within the sublime project file.
  //  - "$project_name"       <-- replaced by the name of the current project.
  //  - "$clang_version"      <-- replaced by the numeric version of used clang.
  //  - "~"                   <-- replaced by the path to user home directory.
  //  - "*"                   <-- and other glob wildcards available everywhere.
  //
  // In addition to these, you can use your environment variables:
  //  - OSX and Linux:  $variable_name or ${variable_name}
  //  - Windows:        $variable_name or ${variable_name} or %variable_name%
  //
  // Last but not least, you can use *any* Sublime Text variables defined here:
  // https://www.sublimetext.com/docs/3/build_systems.html#variables

  // Specify common flags that will be passed to clang for EVERY build.
  "common_flags" : [
    // some example includes
    "-I/usr/include",
    "-I$project_base_path/src",
    // this is needed to include the correct headers for clang
    "-I/usr/lib/clang/$clang_version/include",
    // For simple projects, you can add a folder where your current file is
    "-I$file_path",
  ],

  // Language-specific flags. Prepend common_flags for files of given language.
  // When adapting to your needs, make sure to keep all language keys.
  "lang_flags": {
    "C": ["-std=c11"],
    "CPP": ["-std=c++11"],
    "OBJECTIVE_C": ["-std=c11"],
    "OBJECTIVE_CPP": ["-std=c++11"],
  },

  // Define how we search needed flags. Prioritized from top to bottom.
  // Possible entries for "file":
  //  - "CMakeLists.txt"
  //  - "compile_commands.json"
  //  - ".clang_complete"
  //
  // Every entry has an option:
  //    "search_in": <path>  <-- a path to the folder containing the file.
  //
  // The entry with "CMakeLists.txt" entry has additional option to set flags.
  //  Note that if any variables from above or globbing symbols are encountered
  //  in the body of the flag, the flag will be treated as a path and these
  //  symbols will be expanded. Set these flags as follows:
  //    "flags": [<flags>]  <-- Flags to pass to cmake.
  "flags_sources": [
    {"file": "CMakeLists.txt"},
    {"file": "compile_commands.json"},
    {"file": "CppProperties.json"},
    {"file": "c_cpp_properties.json"},
    {"file": ".clang_complete"},
  ],

  // When getting flags from a compile_commands.json file defer parsing these
  // flags to the time when they are actually needed. This enables much faster
  // database loading and allows to work with huge compilation database files.
  // The downside is that there is no fallback option, so if your file is not in
  // the compilation database it will have no flags.
  "lazy_flag_parsing": true,

  // Show compile errors on file save or not.
  "show_errors": true,

  // Show gutter icon for highlighted errors on the side bar.
  // Possible styles: "color", "mono", "dot", "none"
  "gutter_style": "color",

  // Pick style of error line highlighting
  // - "outline"            : outline regions
  // - "fill"               : fill regions
  // - "solid_underline"    : draw a solid underline below regions
  // - "stippled_underline" : draw a stippled underline below regions
  // - "squiggly_underline" : draw a squiggly underline below regions
  // - "none"               : do not draw anything on error lines
  "linter_mark_style": "outline",

  // Maximum width and height for popups eg. declaration info.
  "popup_maximum_width": 1800,
  "popup_maximum_height": 800,

  // Triggers for auto-completion
  "triggers" : [ ".", "->", "::", " ", "	", "(", "[" ],

  // A dictionary that defines a mapping from language to an array of valid
  // syntaxes for it. The values here are good defaults, but feel free to
  // customize the list to your liking. When modifying this setting make sure
  // that all 4 languages have values.
  "valid_lang_syntaxes": {
    "C":              ["C", "C Improved", "C99"],
    "CPP":            ["C++", "C++11"],
    "OBJECTIVE_C":    ["Objective-C"],
    "OBJECTIVE_CPP":  ["Objective-C++"]
  },

  // Do not run the plugin for any files that match these paths. Use
  // glob/fnmatch shell-style filename expansion. In addition, you can still use
  // '~' to mark the home directory.
  "ignore_list": [
    "~/some_folder/*",
    "/some/absolute/file.ext",
    "$project_base_path/some/project/path/*",
  ],

  // Ignore all flags that match any of the following glob-style patterns. You
  // can use shell-style wildcard expansion as well as sublime variables and ~
  // for home director.
  "ignore_flags": [
    "some_flag_pattern*",
    "-W_other_pattern_$project_path*",
  ],

  // Use libclang.
  // If set to false will use clang_binary and parse the output of
  // `clang_binary -Xclang -code-complete-at...` instead.
  "use_libclang" : true,

  // Use default includes that we get from running the command:
  // `clang_binary -c /tmp/test.cc -v`
  "use_default_includes": true,

  // Use default -D definitions that we can get by running the command:
  // `clang_binary -c /tmp/test.cc -dM -E`
  "use_default_definitions": false,

  // Make the plugin verbose:
  "verbose" : false,

  // Pick the clang binary used by the plugin. This is used to determine the
  // version of the plugin and pick correct libclang bindings. Note that this
  // should either be a full (local or global) path to the binary or it should
  // be available in your PATH. You can use all wildcards apart from
  // $clang_version as it would not be available before we point to the correct
  // version of the clang binary.
  "clang_binary" : "clang++",

  // Pick the binary used for cmake. Please make sure the binary you provide is
  // accessible from the command line on your system. Note that this should
  // either be a full path to the binary or it should be available in your PATH.
  "cmake_binary" : "cmake",

  // Ignore triggers and try to complete after each character.
  // WARNING: can be very slow
  "autocomplete_all" : false,

  // Hide the completions generated by other plugins.
  "hide_default_completions": false,

  // Plugin uses smart caching to not load the data more times than needed.
  // Remove cache data older than specified time. Minimum value is 30 seconds.
  // Format: <hours>:<minutes>:<seconds>: "HH:MM:SS".
  "max_cache_age": "00:30:00",

  // Show additional information on hover over function call/variable etc.
  // This replaces default sublime on hover behaviour
  "show_type_info": true,

  // Show body of struct/class/typedef declaration.
  "show_type_body" : true,

  // We only can get declarations from clang AST. This will show references to
  // the symbol under cursor taking them from Sublime Text index.
  "show_index_references": true,

  // When an includes trigger is typed (" or <) a quick panel will appear that
  // will guide the user in picking their includes based on the current
  // compilation database' include flags.
  "autocomplete_includes": true,

  // If the libclang library cannot be found in standard places, the user can
  // provide a path to `libclang`. This path can either be a full path to the
  // libclang library, e.g. `/usr/lib/libclang.so` or a folder that contains
  // libclang library, e.g. `/usr/lib/`. This setting generally should not be
  // needed.
  "libclang_path": "<some_path_here>",

  // Pick the progress style. There are currently these styles available:
  // - "ColorSublime" : '⣾⣽⣻⢿⡿⣟⣯⣷'
  // - "Moon"         : '🌑🌒🌓🌔🌕🌖🌗🌘'
  // - "None"
  "progress_style": "Moon",

  // Controls if libclang will cache the results.
  // This works faster, but in rare cases can generate wrong completions.
  "use_libclang_caching": true,

  // Templates to find source files for headers in case we use a
  // compilation database: Such a DB does not contain the required
  // compile flags for header files. In order to find a best matching
  // source file instead, you can use templates. Such templates describe how
  // to find (relative to the header file) a source file which we can
  // use to get compile flags for.
  // In the simplest case, one can just use the (relative) path to where
  // the source files are relative to your header file. For example, if
  // your headers are in a subdirectory "inc" and your sources in a
  // subdirectory "src" next to the first one, then you can use
  // "../src/" as lookup.
  // If needed, you can also use finer granular lookup templates by using
  // UNIX style globbing patterns and placeholders. Placeholders are of the
  // form '{placeholdername}'. The following placeholders can be used:
  // - basename:  The base file name without the directory part.
  // - stamp:     Like "basename", but with the file name extension removed.
  // - ext:       The file name extension of the header file.
  "header_to_source_mapping": [
    // Look for related files in the header's directory:
    "./",

    // And in the "src" directory:
    "../src/",

    // And in the "source" directory:
    "../source/",

    // Example: Use flags but only from the source file
    // belonging to the header in question:
    // "{stamp}.cpp",

    // Example: Use flags from a file with an
    // "exotic" file name suffix:
    // "{stamp}.mycustomext
  ],

  // Controls if we try to retrieve built-in flags from a target compiler. This
  // option is used when we use a `compile_commands.json` file either directly or
  // indirectly e.g. via CMake. If a compiler is not `null`, we try to ask it for
  // the defines and include paths it sets implicitly and pass them to the clang
  // compiler which is used to generate the code completion. If your completions
  // require the knowledge about the toolchain, this option should improve the
  // quality of the completions, however, in some corner cases it might cause
  // completions to fail entirely.
  "target_compilers": {
    "C":              null,
    "CPP":            null,
    "OBJECTIVE_C":    null,
    "OBJECTIVE_CPP":  null
  },

  // If true, on Windows, the paths will have a '/' too.
  "force_unix_includes": true,
}