1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
(function (Prism) {
function literal(str) {
return function () {
return str;
};
}
var keyword =
/\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
var IDENTIFIER = '\\b(?!' + keyword.source + ')(?!\\d)\\w+\\b';
var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source;
var PREFIX_TYPE_OP =
/(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(
/<ALIGN>/g,
literal(ALIGN)
);
var SUFFIX_EXPR =
/(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(
/<ID>/g,
literal(IDENTIFIER)
);
var TYPE =
'(?!\\s)(?:!?\\s*(?:' + PREFIX_TYPE_OP + '\\s*)*' + SUFFIX_EXPR + ')+';
/*
* A simplified grammar for Zig compile time type literals:
*
* TypeExpr = ( "!"? PREFIX_TYPE_OP* SUFFIX_EXPR )+
*
* SUFFIX_EXPR = ( \b "promise" \b | ( \b "error" "." )? IDENTIFIER ( "." IDENTIFIER )* (?! \s+ IDENTIFIER ) )
*
* PREFIX_TYPE_OP = "?"
* | \b "promise" "->"
* | ( "[" [^\[\]]* "]" | "*" | "**" ) ( ALIGN | "const" \b | "volatile" \b | "allowzero" \b )*
*
* ALIGN = "align" "(" ( [^()] | "(" [^()]* ")" )* ")"
*
* IDENTIFIER = \b (?! KEYWORD ) [a-zA-Z_] \w* \b
*
*/
Prism.languages.zig = {
comment: [
{
pattern: /\/\/[/!].*/,
alias: 'doc-comment',
},
/\/{2}.*/,
],
string: [
{
// "string" and c"string"
pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/,
lookbehind: true,
greedy: true,
},
{
// multiline strings and c-strings
pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
lookbehind: true,
greedy: true,
},
],
char: {
// characters 'a', '\n', '\xFF', '\u{10FFFF}'
pattern:
/(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
lookbehind: true,
greedy: true,
},
builtin: /\B@(?!\d)\w+(?=\s*\()/,
label: {
pattern:
/(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
lookbehind: true,
},
'class-name': [
// const Foo = struct {};
/\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
{
// const x: i32 = 9;
// var x: Bar;
// fn foo(x: bool, y: f32) void {}
pattern: RegExp(
/(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source
.replace(/<TYPE>/g, literal(TYPE))
.replace(/<ALIGN>/g, literal(ALIGN))
),
lookbehind: true,
inside: null, // see below
},
{
// extern fn foo(x: f64) f64; (optional alignment)
pattern: RegExp(
/(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source
.replace(/<TYPE>/g, literal(TYPE))
.replace(/<ALIGN>/g, literal(ALIGN))
),
lookbehind: true,
inside: null, // see below
},
],
'builtin-type': {
pattern:
/\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
alias: 'keyword',
},
keyword: keyword,
function: /\b(?!\d)\w+(?=\s*\()/,
number:
/\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
boolean: /\b(?:false|true)\b/,
operator:
/\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
punctuation: /[.:,;(){}[\]]/,
};
Prism.languages.zig['class-name'].forEach(function (obj) {
if (obj.inside === null) {
obj.inside = Prism.languages.zig;
}
});
})(Prism);
|
