1  /*! `erlang` grammar compiled for Highlight.js 11.10.0 */
  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',
 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  
 89      const BLOCK_STATEMENTS = {
 90        beginKeywords: 'fun receive if try case',
 91        end: 'end',
 92        keywords: ERLANG_RESERVED
 93      };
 94      BLOCK_STATEMENTS.contains = [
 95        COMMENT,
 96        NAMED_FUN,
 97        hljs.inherit(hljs.APOS_STRING_MODE, { className: '' }),
 98        BLOCK_STATEMENTS,
 99        FUNCTION_CALL,
100        hljs.QUOTE_STRING_MODE,
101        NUMBER,
102        TUPLE,
103        VAR1,
104        VAR2,
105        RECORD_ACCESS,
106        CHAR_LITERAL
107      ];
108  
109      const BASIC_MODES = [
110        COMMENT,
111        NAMED_FUN,
112        BLOCK_STATEMENTS,
113        FUNCTION_CALL,
114        hljs.QUOTE_STRING_MODE,
115        NUMBER,
116        TUPLE,
117        VAR1,
118        VAR2,
119        RECORD_ACCESS,
120        CHAR_LITERAL
121      ];
122      FUNCTION_CALL.contains[1].contains = BASIC_MODES;
123      TUPLE.contains = BASIC_MODES;
124      RECORD_ACCESS.contains[1].contains = BASIC_MODES;
125  
126      const DIRECTIVES = [
127        "-module",
128        "-record",
129        "-undef",
130        "-export",
131        "-ifdef",
132        "-ifndef",
133        "-author",
134        "-copyright",
135        "-doc",
136        "-vsn",
137        "-import",
138        "-include",
139        "-include_lib",
140        "-compile",
141        "-define",
142        "-else",
143        "-endif",
144        "-file",
145        "-behaviour",
146        "-behavior",
147        "-spec"
148      ];
149  
150      const PARAMS = {
151        className: 'params',
152        begin: '\\(',
153        end: '\\)',
154        contains: BASIC_MODES
155      };
156  
157      return {
158        name: 'Erlang',
159        aliases: [ 'erl' ],
160        keywords: ERLANG_RESERVED,
161        illegal: '(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))',
162        contains: [
163          {
164            className: 'function',
165            begin: '^' + BASIC_ATOM_RE + '\\s*\\(',
166            end: '->',
167            returnBegin: true,
168            illegal: '\\(|#|//|/\\*|\\\\|:|;',
169            contains: [
170              PARAMS,
171              hljs.inherit(hljs.TITLE_MODE, { begin: BASIC_ATOM_RE })
172            ],
173            starts: {
174              end: ';|\\.',
175              keywords: ERLANG_RESERVED,
176              contains: BASIC_MODES
177            }
178          },
179          COMMENT,
180          {
181            begin: '^-',
182            end: '\\.',
183            relevance: 0,
184            excludeEnd: true,
185            returnBegin: true,
186            keywords: {
187              $pattern: '-' + hljs.IDENT_RE,
188              keyword: DIRECTIVES.map(x => `${x}|1.5`).join(" ")
189            },
190            contains: [ PARAMS ]
191          },
192          NUMBER,
193          hljs.QUOTE_STRING_MODE,
194          RECORD_ACCESS,
195          VAR1,
196          VAR2,
197          TUPLE,
198          CHAR_LITERAL,
199          { begin: /\.$/ } // relevance booster
200        ]
201      };
202    }
203  
204    return erlang;
205  
206  })();
207  
208      hljs.registerLanguage('erlang', hljsGrammar);
209    })();