static/highlight/es/languages/erlang.js

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