static/highlight/languages/erlang.js

   1 /*! `erlang` grammar compiled for Highlight.js 11.11.1 */
   2   (function(){
   3     var hljsGrammar = (function () {
   4   'use strict';
   5
   6   /*
   7   Language: Erlang
   8   Description: Erlang is a general-purpose functional language, with strict evaluation, single assignment, and dynamic typing.
   9   Author: Nikolay Zakharov <nikolay.desh@gmail.com>, Dmitry Kovega <arhibot@gmail.com>
  10   Website: https://www.erlang.org
  11   Category: functional
  12   */
  13
  14   /** @type LanguageFn */
  15   function erlang(hljs) {
  16     const BASIC_ATOM_RE = '[a-z\'][a-zA-Z0-9_\']*';
  17     const FUNCTION_NAME_RE = '(' + BASIC_ATOM_RE + ':' + BASIC_ATOM_RE + '|' + BASIC_ATOM_RE + ')';
  18     const ERLANG_RESERVED = {
  19       keyword:
  20         'after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if '
  21         + 'let not of orelse|10 query receive rem try when xor maybe else',
  22       literal:
  23         'false true'
  24     };
  25
  26     const COMMENT = hljs.COMMENT('%', '$');
  27     const NUMBER = {
  28       className: 'number',
  29       begin: '\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)',
  30       relevance: 0
  31     };
  32     const NAMED_FUN = { begin: 'fun\\s+' + BASIC_ATOM_RE + '/\\d+' };
  33     const FUNCTION_CALL = {
  34       begin: FUNCTION_NAME_RE + '\\(',
  35       end: '\\)',
  36       returnBegin: true,
  37       relevance: 0,
  38       contains: [
  39         {
  40           begin: FUNCTION_NAME_RE,
  41           relevance: 0
  42         },
  43         {
  44           begin: '\\(',
  45           end: '\\)',
  46           endsWithParent: true,
  47           returnEnd: true,
  48           relevance: 0
  49           // "contains" defined later
  50         }
  51       ]
  52     };
  53     const TUPLE = {
  54       begin: /\{/,
  55       end: /\}/,
  56       relevance: 0
  57       // "contains" defined later
  58     };
  59     const VAR1 = {
  60       begin: '\\b_([A-Z][A-Za-z0-9_]*)?',
  61       relevance: 0
  62     };
  63     const VAR2 = {
  64       begin: '[A-Z][a-zA-Z0-9_]*',
  65       relevance: 0
  66     };
  67     const RECORD_ACCESS = {
  68       begin: '#' + hljs.UNDERSCORE_IDENT_RE,
  69       relevance: 0,
  70       returnBegin: true,
  71       contains: [
  72         {
  73           begin: '#' + hljs.UNDERSCORE_IDENT_RE,
  74           relevance: 0
  75         },
  76         {
  77           begin: /\{/,
  78           end: /\}/,
  79           relevance: 0
  80           // "contains" defined later
  81         }
  82       ]
  83     };
  84     const CHAR_LITERAL = {
  85       scope: 'string',
  86       match: /\$(\\([^0-9]|[0-9]{1,3}|)|.)/,
  87     };
  88     const TRIPLE_QUOTE = {
  89       scope: 'string',
  90       match: /"""("*)(?!")[\s\S]*?"""\1/,
  91     };
  92
  93     const SIGIL = {
  94       scope: 'string',
  95       contains: [ hljs.BACKSLASH_ESCAPE ],
  96       variants: [
  97         {match: /~\w?"""("*)(?!")[\s\S]*?"""\1/},
  98         {begin: /~\w?\(/, end: /\)/},
  99         {begin: /~\w?\[/, end: /\]/},
 100         {begin: /~\w?{/, end: /}/},
 101         {begin: /~\w?</, end: />/},
 102         {begin: /~\w?\//, end: /\//},
 103         {begin: /~\w?\|/, end: /\|/},
 104         {begin: /~\w?'/, end: /'/},
 105         {begin: /~\w?"/, end: /"/},
 106         {begin: /~\w?`/, end: /`/},
 107         {begin: /~\w?#/, end: /#/},
 108       ],
 109     };
 110
 111     const BLOCK_STATEMENTS = {
 112       beginKeywords: 'fun receive if try case maybe',
 113       end: 'end',
 114       keywords: ERLANG_RESERVED
 115     };
 116     BLOCK_STATEMENTS.contains = [
 117       COMMENT,
 118       NAMED_FUN,
 119       hljs.inherit(hljs.APOS_STRING_MODE, { className: '' }),
 120       BLOCK_STATEMENTS,
 121       FUNCTION_CALL,
 122       SIGIL,
 123       TRIPLE_QUOTE,
 124       hljs.QUOTE_STRING_MODE,
 125       NUMBER,
 126       TUPLE,
 127       VAR1,
 128       VAR2,
 129       RECORD_ACCESS,
 130       CHAR_LITERAL
 131     ];
 132
 133     const BASIC_MODES = [
 134       COMMENT,
 135       NAMED_FUN,
 136       BLOCK_STATEMENTS,
 137       FUNCTION_CALL,
 138       SIGIL,
 139       TRIPLE_QUOTE,
 140       hljs.QUOTE_STRING_MODE,
 141       NUMBER,
 142       TUPLE,
 143       VAR1,
 144       VAR2,
 145       RECORD_ACCESS,
 146       CHAR_LITERAL
 147     ];
 148     FUNCTION_CALL.contains[1].contains = BASIC_MODES;
 149     TUPLE.contains = BASIC_MODES;
 150     RECORD_ACCESS.contains[1].contains = BASIC_MODES;
 151
 152     const DIRECTIVES = [
 153       "-module",
 154       "-record",
 155       "-undef",
 156       "-export",
 157       "-ifdef",
 158       "-ifndef",
 159       "-author",
 160       "-copyright",
 161       "-doc",
 162       "-moduledoc",
 163       "-vsn",
 164       "-import",
 165       "-include",
 166       "-include_lib",
 167       "-compile",
 168       "-define",
 169       "-else",
 170       "-endif",
 171       "-file",
 172       "-behaviour",
 173       "-behavior",
 174       "-spec",
 175       "-on_load",
 176       "-nifs",
 177     ];
 178
 179     const PARAMS = {
 180       className: 'params',
 181       begin: '\\(',
 182       end: '\\)',
 183       contains: BASIC_MODES
 184     };
 185
 186     return {
 187       name: 'Erlang',
 188       aliases: [ 'erl' ],
 189       keywords: ERLANG_RESERVED,
 190       illegal: '(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))',
 191       contains: [
 192         {
 193           className: 'function',
 194           begin: '^' + BASIC_ATOM_RE + '\\s*\\(',
 195           end: '->',
 196           returnBegin: true,
 197           illegal: '\\(|#|//|/\\*|\\\\|:|;',
 198           contains: [
 199             PARAMS,
 200             hljs.inherit(hljs.TITLE_MODE, { begin: BASIC_ATOM_RE })
 201           ],
 202           starts: {
 203             end: ';|\\.',
 204             keywords: ERLANG_RESERVED,
 205             contains: BASIC_MODES
 206           }
 207         },
 208         COMMENT,
 209         {
 210           begin: '^-',
 211           end: '\\.',
 212           relevance: 0,
 213           excludeEnd: true,
 214           returnBegin: true,
 215           keywords: {
 216             $pattern: '-' + hljs.IDENT_RE,
 217             keyword: DIRECTIVES.map(x => `${x}|1.5`).join(" ")
 218           },
 219           contains: [
 220             PARAMS,
 221             SIGIL,
 222             TRIPLE_QUOTE,
 223             hljs.QUOTE_STRING_MODE
 224           ]
 225         },
 226         NUMBER,
 227         SIGIL,
 228         TRIPLE_QUOTE,
 229         hljs.QUOTE_STRING_MODE,
 230         RECORD_ACCESS,
 231         VAR1,
 232         VAR2,
 233         TUPLE,
 234         CHAR_LITERAL,
 235         { begin: /\.$/ } // relevance booster
 236       ]
 237     };
 238   }
 239
 240   return erlang;
 241
 242 })();
 243
 244     hljs.registerLanguage('erlang', hljsGrammar);
 245   })();