static/highlight/es/languages/c.js

   1 /*! `c` grammar compiled for Highlight.js 11.11.1 */
   2 var hljsGrammar = (function () {
   3   'use strict';
   4
   5   /*
   6   Language: C
   7   Category: common, system
   8   Website: https://en.wikipedia.org/wiki/C_(programming_language)
   9   */
  10
  11   /** @type LanguageFn */
  12   function c(hljs) {
  13     const regex = hljs.regex;
  14     // added for historic reasons because `hljs.C_LINE_COMMENT_MODE` does
  15     // not include such support nor can we be sure all the grammars depending
  16     // on it would desire this behavior
  17     const C_LINE_COMMENT_MODE = hljs.COMMENT('//', '$', { contains: [ { begin: /\\\n/ } ] });
  18     const DECLTYPE_AUTO_RE = 'decltype\\(auto\\)';
  19     const NAMESPACE_RE = '[a-zA-Z_]\\w*::';
  20     const TEMPLATE_ARGUMENT_RE = '<[^<>]+>';
  21     const FUNCTION_TYPE_RE = '('
  22       + DECLTYPE_AUTO_RE + '|'
  23       + regex.optional(NAMESPACE_RE)
  24       + '[a-zA-Z_]\\w*' + regex.optional(TEMPLATE_ARGUMENT_RE)
  25     + ')';
  26
  27
  28     const TYPES = {
  29       className: 'type',
  30       variants: [
  31         { begin: '\\b[a-z\\d_]*_t\\b' },
  32         { match: /\batomic_[a-z]{3,6}\b/ }
  33       ]
  34
  35     };
  36
  37     // https://en.cppreference.com/w/cpp/language/escape
  38     // \\ \x \xFF \u2837 \u00323747 \374
  39     const CHARACTER_ESCAPES = '\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)';
  40     const STRINGS = {
  41       className: 'string',
  42       variants: [
  43         {
  44           begin: '(u8?|U|L)?"',
  45           end: '"',
  46           illegal: '\\n',
  47           contains: [ hljs.BACKSLASH_ESCAPE ]
  48         },
  49         {
  50           begin: '(u8?|U|L)?\'(' + CHARACTER_ESCAPES + "|.)",
  51           end: '\'',
  52           illegal: '.'
  53         },
  54         hljs.END_SAME_AS_BEGIN({
  55           begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
  56           end: /\)([^()\\ ]{0,16})"/
  57         })
  58       ]
  59     };
  60
  61     const NUMBERS = {
  62       className: 'number',
  63       variants: [
  64         { match: /\b(0b[01']+)/ },
  65         { match: /(-?)\b([\d']+(\.[\d']*)?|\.[\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)/ },
  66         { match: /(-?)\b(0[xX][a-fA-F0-9]+(?:'[a-fA-F0-9]+)*(?:\.[a-fA-F0-9]*(?:'[a-fA-F0-9]*)*)?(?:[pP][-+]?[0-9]+)?(l|L)?(u|U)?)/ },
  67         { match: /(-?)\b\d+(?:'\d+)*(?:\.\d*(?:'\d*)*)?(?:[eE][-+]?\d+)?/ }
  68     ],
  69       relevance: 0
  70     };
  71
  72     const PREPROCESSOR = {
  73       className: 'meta',
  74       begin: /#\s*[a-z]+\b/,
  75       end: /$/,
  76       keywords: { keyword:
  77           'if else elif endif define undef warning error line '
  78           + 'pragma _Pragma ifdef ifndef elifdef elifndef include' },
  79       contains: [
  80         {
  81           begin: /\\\n/,
  82           relevance: 0
  83         },
  84         hljs.inherit(STRINGS, { className: 'string' }),
  85         {
  86           className: 'string',
  87           begin: /<.*?>/
  88         },
  89         C_LINE_COMMENT_MODE,
  90         hljs.C_BLOCK_COMMENT_MODE
  91       ]
  92     };
  93
  94     const TITLE_MODE = {
  95       className: 'title',
  96       begin: regex.optional(NAMESPACE_RE) + hljs.IDENT_RE,
  97       relevance: 0
  98     };
  99
 100     const FUNCTION_TITLE = regex.optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\(';
 101
 102     const C_KEYWORDS = [
 103       "asm",
 104       "auto",
 105       "break",
 106       "case",
 107       "continue",
 108       "default",
 109       "do",
 110       "else",
 111       "enum",
 112       "extern",
 113       "for",
 114       "fortran",
 115       "goto",
 116       "if",
 117       "inline",
 118       "register",
 119       "restrict",
 120       "return",
 121       "sizeof",
 122       "typeof",
 123       "typeof_unqual",
 124       "struct",
 125       "switch",
 126       "typedef",
 127       "union",
 128       "volatile",
 129       "while",
 130       "_Alignas",
 131       "_Alignof",
 132       "_Atomic",
 133       "_Generic",
 134       "_Noreturn",
 135       "_Static_assert",
 136       "_Thread_local",
 137       // aliases
 138       "alignas",
 139       "alignof",
 140       "noreturn",
 141       "static_assert",
 142       "thread_local",
 143       // not a C keyword but is, for all intents and purposes, treated exactly like one.
 144       "_Pragma"
 145     ];
 146
 147     const C_TYPES = [
 148       "float",
 149       "double",
 150       "signed",
 151       "unsigned",
 152       "int",
 153       "short",
 154       "long",
 155       "char",
 156       "void",
 157       "_Bool",
 158       "_BitInt",
 159       "_Complex",
 160       "_Imaginary",
 161       "_Decimal32",
 162       "_Decimal64",
 163       "_Decimal96",
 164       "_Decimal128",
 165       "_Decimal64x",
 166       "_Decimal128x",
 167       "_Float16",
 168       "_Float32",
 169       "_Float64",
 170       "_Float128",
 171       "_Float32x",
 172       "_Float64x",
 173       "_Float128x",
 174       // modifiers
 175       "const",
 176       "static",
 177       "constexpr",
 178       // aliases
 179       "complex",
 180       "bool",
 181       "imaginary"
 182     ];
 183
 184     const KEYWORDS = {
 185       keyword: C_KEYWORDS,
 186       type: C_TYPES,
 187       literal: 'true false NULL',
 188       // TODO: apply hinting work similar to what was done in cpp.js
 189       built_in: 'std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream '
 190         + 'auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set '
 191         + 'unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos '
 192         + 'asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp '
 193         + 'fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper '
 194         + 'isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow '
 195         + 'printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp '
 196         + 'strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan '
 197         + 'vfprintf vprintf vsprintf endl initializer_list unique_ptr',
 198     };
 199
 200     const EXPRESSION_CONTAINS = [
 201       PREPROCESSOR,
 202       TYPES,
 203       C_LINE_COMMENT_MODE,
 204       hljs.C_BLOCK_COMMENT_MODE,
 205       NUMBERS,
 206       STRINGS
 207     ];
 208
 209     const EXPRESSION_CONTEXT = {
 210       // This mode covers expression context where we can't expect a function
 211       // definition and shouldn't highlight anything that looks like one:
 212       // `return some()`, `else if()`, `(x*sum(1, 2))`
 213       variants: [
 214         {
 215           begin: /=/,
 216           end: /;/
 217         },
 218         {
 219           begin: /\(/,
 220           end: /\)/
 221         },
 222         {
 223           beginKeywords: 'new throw return else',
 224           end: /;/
 225         }
 226       ],
 227       keywords: KEYWORDS,
 228       contains: EXPRESSION_CONTAINS.concat([
 229         {
 230           begin: /\(/,
 231           end: /\)/,
 232           keywords: KEYWORDS,
 233           contains: EXPRESSION_CONTAINS.concat([ 'self' ]),
 234           relevance: 0
 235         }
 236       ]),
 237       relevance: 0
 238     };
 239
 240     const FUNCTION_DECLARATION = {
 241       begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+)+' + FUNCTION_TITLE,
 242       returnBegin: true,
 243       end: /[{;=]/,
 244       excludeEnd: true,
 245       keywords: KEYWORDS,
 246       illegal: /[^\w\s\*&:<>.]/,
 247       contains: [
 248         { // to prevent it from being confused as the function title
 249           begin: DECLTYPE_AUTO_RE,
 250           keywords: KEYWORDS,
 251           relevance: 0
 252         },
 253         {
 254           begin: FUNCTION_TITLE,
 255           returnBegin: true,
 256           contains: [ hljs.inherit(TITLE_MODE, { className: "title.function" }) ],
 257           relevance: 0
 258         },
 259         // allow for multiple declarations, e.g.:
 260         // extern void f(int), g(char);
 261         {
 262           relevance: 0,
 263           match: /,/
 264         },
 265         {
 266           className: 'params',
 267           begin: /\(/,
 268           end: /\)/,
 269           keywords: KEYWORDS,
 270           relevance: 0,
 271           contains: [
 272             C_LINE_COMMENT_MODE,
 273             hljs.C_BLOCK_COMMENT_MODE,
 274             STRINGS,
 275             NUMBERS,
 276             TYPES,
 277             // Count matching parentheses.
 278             {
 279               begin: /\(/,
 280               end: /\)/,
 281               keywords: KEYWORDS,
 282               relevance: 0,
 283               contains: [
 284                 'self',
 285                 C_LINE_COMMENT_MODE,
 286                 hljs.C_BLOCK_COMMENT_MODE,
 287                 STRINGS,
 288                 NUMBERS,
 289                 TYPES
 290               ]
 291             }
 292           ]
 293         },
 294         TYPES,
 295         C_LINE_COMMENT_MODE,
 296         hljs.C_BLOCK_COMMENT_MODE,
 297         PREPROCESSOR
 298       ]
 299     };
 300
 301     return {
 302       name: "C",
 303       aliases: [ 'h' ],
 304       keywords: KEYWORDS,
 305       // Until differentiations are added between `c` and `cpp`, `c` will
 306       // not be auto-detected to avoid auto-detect conflicts between C and C++
 307       disableAutodetect: true,
 308       illegal: '</',
 309       contains: [].concat(
 310         EXPRESSION_CONTEXT,
 311         FUNCTION_DECLARATION,
 312         EXPRESSION_CONTAINS,
 313         [
 314           PREPROCESSOR,
 315           {
 316             begin: hljs.IDENT_RE + '::',
 317             keywords: KEYWORDS
 318           },
 319           {
 320             className: 'class',
 321             beginKeywords: 'enum class struct union',
 322             end: /[{;:<>=]/,
 323             contains: [
 324               { beginKeywords: "final class struct" },
 325               hljs.TITLE_MODE
 326             ]
 327           }
 328         ]),
 329       exports: {
 330         preprocessor: PREPROCESSOR,
 331         strings: STRINGS,
 332         keywords: KEYWORDS
 333       }
 334     };
 335   }
 336
 337   return c;
 338
 339 })();
 340 ;
 341 export default hljsGrammar;