Mercurial
comparison .cms/lib/codemirror/mode/verilog/verilog.js @ 0:78edf6b517a0 draft
24.10
author | Coffee CMS <info@coffee-cms.ru> |
---|---|
date | Fri, 11 Oct 2024 22:40:23 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:78edf6b517a0 |
---|---|
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others | |
2 // Distributed under an MIT license: https://codemirror.net/5/LICENSE | |
3 | |
4 (function(mod) { | |
5 if (typeof exports == "object" && typeof module == "object") // CommonJS | |
6 mod(require("../../lib/codemirror")); | |
7 else if (typeof define == "function" && define.amd) // AMD | |
8 define(["../../lib/codemirror"], mod); | |
9 else // Plain browser env | |
10 mod(CodeMirror); | |
11 })(function(CodeMirror) { | |
12 "use strict"; | |
13 | |
14 CodeMirror.defineMode("verilog", function(config, parserConfig) { | |
15 | |
16 var indentUnit = config.indentUnit, | |
17 statementIndentUnit = parserConfig.statementIndentUnit || indentUnit, | |
18 dontAlignCalls = parserConfig.dontAlignCalls, | |
19 // compilerDirectivesUseRegularIndentation - If set, Compiler directive | |
20 // indentation follows the same rules as everything else. Otherwise if | |
21 // false, compiler directives will track their own indentation. | |
22 // For example, `ifdef nested inside another `ifndef will be indented, | |
23 // but a `ifdef inside a function block may not be indented. | |
24 compilerDirectivesUseRegularIndentation = parserConfig.compilerDirectivesUseRegularIndentation, | |
25 noIndentKeywords = parserConfig.noIndentKeywords || [], | |
26 multiLineStrings = parserConfig.multiLineStrings, | |
27 hooks = parserConfig.hooks || {}; | |
28 | |
29 function words(str) { | |
30 var obj = {}, words = str.split(" "); | |
31 for (var i = 0; i < words.length; ++i) obj[words[i]] = true; | |
32 return obj; | |
33 } | |
34 | |
35 /** | |
36 * Keywords from IEEE 1800-2012 | |
37 */ | |
38 var keywords = words( | |
39 "accept_on alias always always_comb always_ff always_latch and assert assign assume automatic before begin bind " + | |
40 "bins binsof bit break buf bufif0 bufif1 byte case casex casez cell chandle checker class clocking cmos config " + | |
41 "const constraint context continue cover covergroup coverpoint cross deassign default defparam design disable " + | |
42 "dist do edge else end endcase endchecker endclass endclocking endconfig endfunction endgenerate endgroup " + | |
43 "endinterface endmodule endpackage endprimitive endprogram endproperty endspecify endsequence endtable endtask " + | |
44 "enum event eventually expect export extends extern final first_match for force foreach forever fork forkjoin " + | |
45 "function generate genvar global highz0 highz1 if iff ifnone ignore_bins illegal_bins implements implies import " + | |
46 "incdir include initial inout input inside instance int integer interconnect interface intersect join join_any " + | |
47 "join_none large let liblist library local localparam logic longint macromodule matches medium modport module " + | |
48 "nand negedge nettype new nexttime nmos nor noshowcancelled not notif0 notif1 null or output package packed " + | |
49 "parameter pmos posedge primitive priority program property protected pull0 pull1 pulldown pullup " + | |
50 "pulsestyle_ondetect pulsestyle_onevent pure rand randc randcase randsequence rcmos real realtime ref reg " + | |
51 "reject_on release repeat restrict return rnmos rpmos rtran rtranif0 rtranif1 s_always s_eventually s_nexttime " + | |
52 "s_until s_until_with scalared sequence shortint shortreal showcancelled signed small soft solve specify " + | |
53 "specparam static string strong strong0 strong1 struct super supply0 supply1 sync_accept_on sync_reject_on " + | |
54 "table tagged task this throughout time timeprecision timeunit tran tranif0 tranif1 tri tri0 tri1 triand trior " + | |
55 "trireg type typedef union unique unique0 unsigned until until_with untyped use uwire var vectored virtual void " + | |
56 "wait wait_order wand weak weak0 weak1 while wildcard wire with within wor xnor xor"); | |
57 | |
58 /** Operators from IEEE 1800-2012 | |
59 unary_operator ::= | |
60 + | - | ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~ | |
61 binary_operator ::= | |
62 + | - | * | / | % | == | != | === | !== | ==? | !=? | && | || | ** | |
63 | < | <= | > | >= | & | | | ^ | ^~ | ~^ | >> | << | >>> | <<< | |
64 | -> | <-> | |
65 inc_or_dec_operator ::= ++ | -- | |
66 unary_module_path_operator ::= | |
67 ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~ | |
68 binary_module_path_operator ::= | |
69 == | != | && | || | & | | | ^ | ^~ | ~^ | |
70 */ | |
71 var isOperatorChar = /[\+\-\*\/!~&|^%=?:<>]/; | |
72 var isBracketChar = /[\[\]{}()]/; | |
73 | |
74 var unsignedNumber = /\d[0-9_]*/; | |
75 var decimalLiteral = /\d*\s*'s?d\s*\d[0-9_]*/i; | |
76 var binaryLiteral = /\d*\s*'s?b\s*[xz01][xz01_]*/i; | |
77 var octLiteral = /\d*\s*'s?o\s*[xz0-7][xz0-7_]*/i; | |
78 var hexLiteral = /\d*\s*'s?h\s*[0-9a-fxz?][0-9a-fxz?_]*/i; | |
79 var realLiteral = /(\d[\d_]*(\.\d[\d_]*)?E-?[\d_]+)|(\d[\d_]*\.\d[\d_]*)/i; | |
80 | |
81 var closingBracketOrWord = /^((`?\w+)|[)}\]])/; | |
82 var closingBracket = /[)}\]]/; | |
83 var compilerDirectiveRegex = new RegExp( | |
84 "^(`(?:ifdef|ifndef|elsif|else|endif|undef|undefineall|define|include|begin_keywords|celldefine|default|" + | |
85 "nettype|end_keywords|endcelldefine|line|nounconnected_drive|pragma|resetall|timescale|unconnected_drive))\\b"); | |
86 var compilerDirectiveBeginRegex = /^(`(?:ifdef|ifndef|elsif|else))\b/; | |
87 var compilerDirectiveEndRegex = /^(`(?:elsif|else|endif))\b/; | |
88 | |
89 var curPunc; | |
90 var curKeyword; | |
91 | |
92 // Block openings which are closed by a matching keyword in the form of ("end" + keyword) | |
93 // E.g. "task" => "endtask" | |
94 var blockKeywords = words( | |
95 "case checker class clocking config function generate interface module package " + | |
96 "primitive program property specify sequence table task" | |
97 ); | |
98 | |
99 // Opening/closing pairs | |
100 var openClose = {}; | |
101 for (var keyword in blockKeywords) { | |
102 openClose[keyword] = "end" + keyword; | |
103 } | |
104 openClose["begin"] = "end"; | |
105 openClose["casex"] = "endcase"; | |
106 openClose["casez"] = "endcase"; | |
107 openClose["do" ] = "while"; | |
108 openClose["fork" ] = "join;join_any;join_none"; | |
109 openClose["covergroup"] = "endgroup"; | |
110 openClose["macro_begin"] = "macro_end"; | |
111 | |
112 for (var i in noIndentKeywords) { | |
113 var keyword = noIndentKeywords[i]; | |
114 if (openClose[keyword]) { | |
115 openClose[keyword] = undefined; | |
116 } | |
117 } | |
118 | |
119 // Keywords which open statements that are ended with a semi-colon | |
120 var statementKeywords = words("always always_comb always_ff always_latch assert assign assume else export for foreach forever if import initial repeat while extern typedef"); | |
121 | |
122 function tokenBase(stream, state) { | |
123 var ch = stream.peek(), style; | |
124 if (hooks[ch] && (style = hooks[ch](stream, state)) != false) return style; | |
125 if (hooks.tokenBase && (style = hooks.tokenBase(stream, state)) != false) | |
126 return style; | |
127 | |
128 if (/[,;:\.]/.test(ch)) { | |
129 curPunc = stream.next(); | |
130 return null; | |
131 } | |
132 if (isBracketChar.test(ch)) { | |
133 curPunc = stream.next(); | |
134 return "bracket"; | |
135 } | |
136 // Macros (tick-defines) | |
137 if (ch == '`') { | |
138 stream.next(); | |
139 if (stream.eatWhile(/[\w\$_]/)) { | |
140 var cur = stream.current(); | |
141 curKeyword = cur; | |
142 // Macros that end in _begin, are start of block and end with _end | |
143 if (cur.startsWith("`uvm_") && cur.endsWith("_begin")) { | |
144 var keywordClose = curKeyword.substr(0,curKeyword.length - 5) + "end"; | |
145 openClose[cur] = keywordClose; | |
146 curPunc = "newblock"; | |
147 } else { | |
148 stream.eatSpace(); | |
149 if (stream.peek() == '(') { | |
150 // Check if this is a block | |
151 curPunc = "newmacro"; | |
152 } | |
153 var withSpace = stream.current(); | |
154 // Move the stream back before the spaces | |
155 stream.backUp(withSpace.length - cur.length); | |
156 } | |
157 return "def"; | |
158 } else { | |
159 return null; | |
160 } | |
161 } | |
162 // System calls | |
163 if (ch == '$') { | |
164 stream.next(); | |
165 if (stream.eatWhile(/[\w\$_]/)) { | |
166 return "meta"; | |
167 } else { | |
168 return null; | |
169 } | |
170 } | |
171 // Time literals | |
172 if (ch == '#') { | |
173 stream.next(); | |
174 stream.eatWhile(/[\d_.]/); | |
175 return "def"; | |
176 } | |
177 // Event | |
178 if (ch == '@') { | |
179 stream.next(); | |
180 stream.eatWhile(/[@]/); | |
181 return "def"; | |
182 } | |
183 // Strings | |
184 if (ch == '"') { | |
185 stream.next(); | |
186 state.tokenize = tokenString(ch); | |
187 return state.tokenize(stream, state); | |
188 } | |
189 // Comments | |
190 if (ch == "/") { | |
191 stream.next(); | |
192 if (stream.eat("*")) { | |
193 state.tokenize = tokenComment; | |
194 return tokenComment(stream, state); | |
195 } | |
196 if (stream.eat("/")) { | |
197 stream.skipToEnd(); | |
198 return "comment"; | |
199 } | |
200 stream.backUp(1); | |
201 } | |
202 | |
203 // Numeric literals | |
204 if (stream.match(realLiteral) || | |
205 stream.match(decimalLiteral) || | |
206 stream.match(binaryLiteral) || | |
207 stream.match(octLiteral) || | |
208 stream.match(hexLiteral) || | |
209 stream.match(unsignedNumber) || | |
210 stream.match(realLiteral)) { | |
211 return "number"; | |
212 } | |
213 | |
214 // Operators | |
215 if (stream.eatWhile(isOperatorChar)) { | |
216 curPunc = stream.current(); | |
217 return "meta"; | |
218 } | |
219 | |
220 // Keywords / plain variables | |
221 if (stream.eatWhile(/[\w\$_]/)) { | |
222 var cur = stream.current(); | |
223 if (keywords[cur]) { | |
224 if (openClose[cur]) { | |
225 curPunc = "newblock"; | |
226 if (cur === "fork") { | |
227 // Fork can be a statement instead of block in cases of: | |
228 // "disable fork;" and "wait fork;" (trailing semicolon) | |
229 stream.eatSpace() | |
230 if (stream.peek() == ';') { | |
231 curPunc = "newstatement"; | |
232 } | |
233 stream.backUp(stream.current().length - cur.length); | |
234 } | |
235 } | |
236 if (statementKeywords[cur]) { | |
237 curPunc = "newstatement"; | |
238 } | |
239 curKeyword = cur; | |
240 return "keyword"; | |
241 } | |
242 return "variable"; | |
243 } | |
244 | |
245 stream.next(); | |
246 return null; | |
247 } | |
248 | |
249 function tokenString(quote) { | |
250 return function(stream, state) { | |
251 var escaped = false, next, end = false; | |
252 while ((next = stream.next()) != null) { | |
253 if (next == quote && !escaped) {end = true; break;} | |
254 escaped = !escaped && next == "\\"; | |
255 } | |
256 if (end || !(escaped || multiLineStrings)) | |
257 state.tokenize = tokenBase; | |
258 return "string"; | |
259 }; | |
260 } | |
261 | |
262 function tokenComment(stream, state) { | |
263 var maybeEnd = false, ch; | |
264 while (ch = stream.next()) { | |
265 if (ch == "/" && maybeEnd) { | |
266 state.tokenize = tokenBase; | |
267 break; | |
268 } | |
269 maybeEnd = (ch == "*"); | |
270 } | |
271 return "comment"; | |
272 } | |
273 | |
274 function Context(indented, column, type, scopekind, align, prev) { | |
275 this.indented = indented; | |
276 this.column = column; | |
277 this.type = type; | |
278 this.scopekind = scopekind; | |
279 this.align = align; | |
280 this.prev = prev; | |
281 } | |
282 function pushContext(state, col, type, scopekind) { | |
283 var indent = state.indented; | |
284 var c = new Context(indent, col, type, scopekind ? scopekind : "", null, state.context); | |
285 return state.context = c; | |
286 } | |
287 function popContext(state) { | |
288 var t = state.context.type; | |
289 if (t == ")" || t == "]" || t == "}") { | |
290 state.indented = state.context.indented; | |
291 } | |
292 return state.context = state.context.prev; | |
293 } | |
294 | |
295 function isClosing(text, contextClosing) { | |
296 if (text == contextClosing) { | |
297 return true; | |
298 } else { | |
299 // contextClosing may be multiple keywords separated by ; | |
300 var closingKeywords = contextClosing.split(";"); | |
301 for (var i in closingKeywords) { | |
302 if (text == closingKeywords[i]) { | |
303 return true; | |
304 } | |
305 } | |
306 return false; | |
307 } | |
308 } | |
309 | |
310 function isInsideScopeKind(ctx, scopekind) { | |
311 if (ctx == null) { | |
312 return false; | |
313 } | |
314 if (ctx.scopekind === scopekind) { | |
315 return true; | |
316 } | |
317 return isInsideScopeKind(ctx.prev, scopekind); | |
318 } | |
319 | |
320 function buildElectricInputRegEx() { | |
321 // Reindentation should occur on any bracket char: {}()[] | |
322 // or on a match of any of the block closing keywords, at | |
323 // the end of a line | |
324 var allClosings = []; | |
325 for (var i in openClose) { | |
326 if (openClose[i]) { | |
327 var closings = openClose[i].split(";"); | |
328 for (var j in closings) { | |
329 allClosings.push(closings[j]); | |
330 } | |
331 } | |
332 } | |
333 var re = new RegExp("[{}()\\[\\]]|(" + allClosings.join("|") + ")$"); | |
334 return re; | |
335 } | |
336 | |
337 // Interface | |
338 return { | |
339 | |
340 // Regex to force current line to reindent | |
341 electricInput: buildElectricInputRegEx(), | |
342 | |
343 startState: function(basecolumn) { | |
344 var state = { | |
345 tokenize: null, | |
346 context: new Context((basecolumn || 0) - indentUnit, 0, "top", "top", false), | |
347 indented: 0, | |
348 compilerDirectiveIndented: 0, | |
349 startOfLine: true | |
350 }; | |
351 if (hooks.startState) hooks.startState(state); | |
352 return state; | |
353 }, | |
354 | |
355 token: function(stream, state) { | |
356 var ctx = state.context; | |
357 if (stream.sol()) { | |
358 if (ctx.align == null) ctx.align = false; | |
359 state.indented = stream.indentation(); | |
360 state.startOfLine = true; | |
361 } | |
362 if (hooks.token) { | |
363 // Call hook, with an optional return value of a style to override verilog styling. | |
364 var style = hooks.token(stream, state); | |
365 if (style !== undefined) { | |
366 return style; | |
367 } | |
368 } | |
369 if (stream.eatSpace()) return null; | |
370 curPunc = null; | |
371 curKeyword = null; | |
372 var style = (state.tokenize || tokenBase)(stream, state); | |
373 if (style == "comment" || style == "meta" || style == "variable") { | |
374 if (((curPunc === "=") || (curPunc === "<=")) && !isInsideScopeKind(ctx, "assignment")) { | |
375 // '<=' could be nonblocking assignment or lessthan-equals (which shouldn't cause indent) | |
376 // Search through the context to see if we are already in an assignment. | |
377 // '=' could be inside port declaration with comma or ')' afterward, or inside for(;;) block. | |
378 pushContext(state, stream.column() + curPunc.length, "assignment", "assignment"); | |
379 if (ctx.align == null) ctx.align = true; | |
380 } | |
381 return style; | |
382 } | |
383 if (ctx.align == null) ctx.align = true; | |
384 | |
385 var isClosingAssignment = ctx.type == "assignment" && | |
386 closingBracket.test(curPunc) && ctx.prev && ctx.prev.type === curPunc; | |
387 if (curPunc == ctx.type || isClosingAssignment) { | |
388 if (isClosingAssignment) { | |
389 ctx = popContext(state); | |
390 } | |
391 ctx = popContext(state); | |
392 if (curPunc == ")") { | |
393 // Handle closing macros, assuming they could have a semicolon or begin/end block inside. | |
394 if (ctx && (ctx.type === "macro")) { | |
395 ctx = popContext(state); | |
396 while (ctx && (ctx.type == "statement" || ctx.type == "assignment")) ctx = popContext(state); | |
397 } | |
398 } else if (curPunc == "}") { | |
399 // Handle closing statements like constraint block: "foreach () {}" which | |
400 // do not have semicolon at end. | |
401 if (ctx && (ctx.type === "statement")) { | |
402 while (ctx && (ctx.type == "statement")) ctx = popContext(state); | |
403 } | |
404 } | |
405 } else if (((curPunc == ";" || curPunc == ",") && (ctx.type == "statement" || ctx.type == "assignment")) || | |
406 (ctx.type && isClosing(curKeyword, ctx.type))) { | |
407 ctx = popContext(state); | |
408 while (ctx && (ctx.type == "statement" || ctx.type == "assignment")) ctx = popContext(state); | |
409 } else if (curPunc == "{") { | |
410 pushContext(state, stream.column(), "}"); | |
411 } else if (curPunc == "[") { | |
412 pushContext(state, stream.column(), "]"); | |
413 } else if (curPunc == "(") { | |
414 pushContext(state, stream.column(), ")"); | |
415 } else if (ctx && ctx.type == "endcase" && curPunc == ":") { | |
416 pushContext(state, stream.column(), "statement", "case"); | |
417 } else if (curPunc == "newstatement") { | |
418 pushContext(state, stream.column(), "statement", curKeyword); | |
419 } else if (curPunc == "newblock") { | |
420 if (curKeyword == "function" && ctx && (ctx.type == "statement" || ctx.type == "endgroup")) { | |
421 // The 'function' keyword can appear in some other contexts where it actually does not | |
422 // indicate a function (import/export DPI and covergroup definitions). | |
423 // Do nothing in this case | |
424 } else if (curKeyword == "task" && ctx && ctx.type == "statement") { | |
425 // Same thing for task | |
426 } else if (curKeyword == "class" && ctx && ctx.type == "statement") { | |
427 // Same thing for class (e.g. typedef) | |
428 } else { | |
429 var close = openClose[curKeyword]; | |
430 pushContext(state, stream.column(), close, curKeyword); | |
431 } | |
432 } else if (curPunc == "newmacro" || (curKeyword && curKeyword.match(compilerDirectiveRegex))) { | |
433 if (curPunc == "newmacro") { | |
434 // Macros (especially if they have parenthesis) potentially have a semicolon | |
435 // or complete statement/block inside, and should be treated as such. | |
436 pushContext(state, stream.column(), "macro", "macro"); | |
437 } | |
438 if (curKeyword.match(compilerDirectiveEndRegex)) { | |
439 state.compilerDirectiveIndented -= statementIndentUnit; | |
440 } | |
441 if (curKeyword.match(compilerDirectiveBeginRegex)) { | |
442 state.compilerDirectiveIndented += statementIndentUnit; | |
443 } | |
444 } | |
445 | |
446 state.startOfLine = false; | |
447 return style; | |
448 }, | |
449 | |
450 indent: function(state, textAfter) { | |
451 if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass; | |
452 if (hooks.indent) { | |
453 var fromHook = hooks.indent(state); | |
454 if (fromHook >= 0) return fromHook; | |
455 } | |
456 var ctx = state.context, firstChar = textAfter && textAfter.charAt(0); | |
457 if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev; | |
458 var closing = false; | |
459 var possibleClosing = textAfter.match(closingBracketOrWord); | |
460 if (possibleClosing) | |
461 closing = isClosing(possibleClosing[0], ctx.type); | |
462 if (!compilerDirectivesUseRegularIndentation && textAfter.match(compilerDirectiveRegex)) { | |
463 if (textAfter.match(compilerDirectiveEndRegex)) { | |
464 return state.compilerDirectiveIndented - statementIndentUnit; | |
465 } | |
466 return state.compilerDirectiveIndented; | |
467 } | |
468 if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit); | |
469 else if ((closingBracket.test(ctx.type) || ctx.type == "assignment") | |
470 && ctx.align && !dontAlignCalls) return ctx.column + (closing ? 0 : 1); | |
471 else if (ctx.type == ")" && !closing) return ctx.indented + statementIndentUnit; | |
472 else return ctx.indented + (closing ? 0 : indentUnit); | |
473 }, | |
474 | |
475 blockCommentStart: "/*", | |
476 blockCommentEnd: "*/", | |
477 lineComment: "//", | |
478 fold: "indent" | |
479 }; | |
480 }); | |
481 | |
482 CodeMirror.defineMIME("text/x-verilog", { | |
483 name: "verilog" | |
484 }); | |
485 | |
486 CodeMirror.defineMIME("text/x-systemverilog", { | |
487 name: "verilog" | |
488 }); | |
489 | |
490 | |
491 | |
492 // TL-Verilog mode. | |
493 // See tl-x.org for language spec. | |
494 // See the mode in action at makerchip.com. | |
495 // Contact: steve.hoover@redwoodeda.com | |
496 | |
497 // TLV Identifier prefixes. | |
498 // Note that sign is not treated separately, so "+/-" versions of numeric identifiers | |
499 // are included. | |
500 var tlvIdentifierStyle = { | |
501 "|": "link", | |
502 ">": "property", // Should condition this off for > TLV 1c. | |
503 "$": "variable", | |
504 "$$": "variable", | |
505 "?$": "qualifier", | |
506 "?*": "qualifier", | |
507 "-": "hr", | |
508 "/": "property", | |
509 "/-": "property", | |
510 "@": "variable-3", | |
511 "@-": "variable-3", | |
512 "@++": "variable-3", | |
513 "@+=": "variable-3", | |
514 "@+=-": "variable-3", | |
515 "@--": "variable-3", | |
516 "@-=": "variable-3", | |
517 "%+": "tag", | |
518 "%-": "tag", | |
519 "%": "tag", | |
520 ">>": "tag", | |
521 "<<": "tag", | |
522 "<>": "tag", | |
523 "#": "tag", // Need to choose a style for this. | |
524 "^": "attribute", | |
525 "^^": "attribute", | |
526 "^!": "attribute", | |
527 "*": "variable-2", | |
528 "**": "variable-2", | |
529 "\\": "keyword", | |
530 "\"": "comment" | |
531 }; | |
532 | |
533 // Lines starting with these characters define scope (result in indentation). | |
534 var tlvScopePrefixChars = { | |
535 "/": "beh-hier", | |
536 ">": "beh-hier", | |
537 "-": "phys-hier", | |
538 "|": "pipe", | |
539 "?": "when", | |
540 "@": "stage", | |
541 "\\": "keyword" | |
542 }; | |
543 var tlvIndentUnit = 3; | |
544 var tlvTrackStatements = false; | |
545 var tlvIdentMatch = /^([~!@#\$%\^&\*-\+=\?\/\\\|'"<>]+)([\d\w_]*)/; // Matches an identifier. | |
546 // Note that ':' is excluded, because of it's use in [:]. | |
547 var tlvFirstLevelIndentMatch = /^[! ] /; | |
548 var tlvLineIndentationMatch = /^[! ] */; | |
549 var tlvCommentMatch = /^\/[\/\*]/; | |
550 | |
551 | |
552 // Returns a style specific to the scope at the given indentation column. | |
553 // Type is one of: "indent", "scope-ident", "before-scope-ident". | |
554 function tlvScopeStyle(state, indentation, type) { | |
555 // Begin scope. | |
556 var depth = indentation / tlvIndentUnit; // TODO: Pass this in instead. | |
557 return "tlv-" + state.tlvIndentationStyle[depth] + "-" + type; | |
558 } | |
559 | |
560 // Return true if the next thing in the stream is an identifier with a mnemonic. | |
561 function tlvIdentNext(stream) { | |
562 var match; | |
563 return (match = stream.match(tlvIdentMatch, false)) && match[2].length > 0; | |
564 } | |
565 | |
566 CodeMirror.defineMIME("text/x-tlv", { | |
567 name: "verilog", | |
568 | |
569 hooks: { | |
570 | |
571 electricInput: false, | |
572 | |
573 | |
574 // Return undefined for verilog tokenizing, or style for TLV token (null not used). | |
575 // Standard CM styles are used for most formatting, but some TL-Verilog-specific highlighting | |
576 // can be enabled with the definition of cm-tlv-* styles, including highlighting for: | |
577 // - M4 tokens | |
578 // - TLV scope indentation | |
579 // - Statement delimitation (enabled by tlvTrackStatements) | |
580 token: function(stream, state) { | |
581 var style = undefined; | |
582 var match; // Return value of pattern matches. | |
583 | |
584 // Set highlighting mode based on code region (TLV or SV). | |
585 if (stream.sol() && ! state.tlvInBlockComment) { | |
586 // Process region. | |
587 if (stream.peek() == '\\') { | |
588 style = "def"; | |
589 stream.skipToEnd(); | |
590 if (stream.string.match(/\\SV/)) { | |
591 state.tlvCodeActive = false; | |
592 } else if (stream.string.match(/\\TLV/)){ | |
593 state.tlvCodeActive = true; | |
594 } | |
595 } | |
596 // Correct indentation in the face of a line prefix char. | |
597 if (state.tlvCodeActive && stream.pos == 0 && | |
598 (state.indented == 0) && (match = stream.match(tlvLineIndentationMatch, false))) { | |
599 state.indented = match[0].length; | |
600 } | |
601 | |
602 // Compute indentation state: | |
603 // o Auto indentation on next line | |
604 // o Indentation scope styles | |
605 var indented = state.indented; | |
606 var depth = indented / tlvIndentUnit; | |
607 if (depth <= state.tlvIndentationStyle.length) { | |
608 // not deeper than current scope | |
609 | |
610 var blankline = stream.string.length == indented; | |
611 var chPos = depth * tlvIndentUnit; | |
612 if (chPos < stream.string.length) { | |
613 var bodyString = stream.string.slice(chPos); | |
614 var ch = bodyString[0]; | |
615 if (tlvScopePrefixChars[ch] && ((match = bodyString.match(tlvIdentMatch)) && | |
616 tlvIdentifierStyle[match[1]])) { | |
617 // This line begins scope. | |
618 // Next line gets indented one level. | |
619 indented += tlvIndentUnit; | |
620 // Style the next level of indentation (except non-region keyword identifiers, | |
621 // which are statements themselves) | |
622 if (!(ch == "\\" && chPos > 0)) { | |
623 state.tlvIndentationStyle[depth] = tlvScopePrefixChars[ch]; | |
624 if (tlvTrackStatements) {state.statementComment = false;} | |
625 depth++; | |
626 } | |
627 } | |
628 } | |
629 // Clear out deeper indentation levels unless line is blank. | |
630 if (!blankline) { | |
631 while (state.tlvIndentationStyle.length > depth) { | |
632 state.tlvIndentationStyle.pop(); | |
633 } | |
634 } | |
635 } | |
636 // Set next level of indentation. | |
637 state.tlvNextIndent = indented; | |
638 } | |
639 | |
640 if (state.tlvCodeActive) { | |
641 // Highlight as TLV. | |
642 | |
643 var beginStatement = false; | |
644 if (tlvTrackStatements) { | |
645 // This starts a statement if the position is at the scope level | |
646 // and we're not within a statement leading comment. | |
647 beginStatement = | |
648 (stream.peek() != " ") && // not a space | |
649 (style === undefined) && // not a region identifier | |
650 !state.tlvInBlockComment && // not in block comment | |
651 //!stream.match(tlvCommentMatch, false) && // not comment start | |
652 (stream.column() == state.tlvIndentationStyle.length * tlvIndentUnit); // at scope level | |
653 if (beginStatement) { | |
654 if (state.statementComment) { | |
655 // statement already started by comment | |
656 beginStatement = false; | |
657 } | |
658 state.statementComment = | |
659 stream.match(tlvCommentMatch, false); // comment start | |
660 } | |
661 } | |
662 | |
663 var match; | |
664 if (style !== undefined) { | |
665 // Region line. | |
666 style += " " + tlvScopeStyle(state, 0, "scope-ident") | |
667 } else if (((stream.pos / tlvIndentUnit) < state.tlvIndentationStyle.length) && | |
668 (match = stream.match(stream.sol() ? tlvFirstLevelIndentMatch : /^ /))) { | |
669 // Indentation | |
670 style = // make this style distinct from the previous one to prevent | |
671 // codemirror from combining spans | |
672 "tlv-indent-" + (((stream.pos % 2) == 0) ? "even" : "odd") + | |
673 // and style it | |
674 " " + tlvScopeStyle(state, stream.pos - tlvIndentUnit, "indent"); | |
675 // Style the line prefix character. | |
676 if (match[0].charAt(0) == "!") { | |
677 style += " tlv-alert-line-prefix"; | |
678 } | |
679 // Place a class before a scope identifier. | |
680 if (tlvIdentNext(stream)) { | |
681 style += " " + tlvScopeStyle(state, stream.pos, "before-scope-ident"); | |
682 } | |
683 } else if (state.tlvInBlockComment) { | |
684 // In a block comment. | |
685 if (stream.match(/^.*?\*\//)) { | |
686 // Exit block comment. | |
687 state.tlvInBlockComment = false; | |
688 if (tlvTrackStatements && !stream.eol()) { | |
689 // Anything after comment is assumed to be real statement content. | |
690 state.statementComment = false; | |
691 } | |
692 } else { | |
693 stream.skipToEnd(); | |
694 } | |
695 style = "comment"; | |
696 } else if ((match = stream.match(tlvCommentMatch)) && !state.tlvInBlockComment) { | |
697 // Start comment. | |
698 if (match[0] == "//") { | |
699 // Line comment. | |
700 stream.skipToEnd(); | |
701 } else { | |
702 // Block comment. | |
703 state.tlvInBlockComment = true; | |
704 } | |
705 style = "comment"; | |
706 } else if (match = stream.match(tlvIdentMatch)) { | |
707 // looks like an identifier (or identifier prefix) | |
708 var prefix = match[1]; | |
709 var mnemonic = match[2]; | |
710 if (// is identifier prefix | |
711 tlvIdentifierStyle.hasOwnProperty(prefix) && | |
712 // has mnemonic or we're at the end of the line (maybe it hasn't been typed yet) | |
713 (mnemonic.length > 0 || stream.eol())) { | |
714 style = tlvIdentifierStyle[prefix]; | |
715 if (stream.column() == state.indented) { | |
716 // Begin scope. | |
717 style += " " + tlvScopeStyle(state, stream.column(), "scope-ident") | |
718 } | |
719 } else { | |
720 // Just swallow one character and try again. | |
721 // This enables subsequent identifier match with preceding symbol character, which | |
722 // is legal within a statement. (E.g., !$reset). It also enables detection of | |
723 // comment start with preceding symbols. | |
724 stream.backUp(stream.current().length - 1); | |
725 style = "tlv-default"; | |
726 } | |
727 } else if (stream.match(/^\t+/)) { | |
728 // Highlight tabs, which are illegal. | |
729 style = "tlv-tab"; | |
730 } else if (stream.match(/^[\[\]{}\(\);\:]+/)) { | |
731 // [:], (), {}, ;. | |
732 style = "meta"; | |
733 } else if (match = stream.match(/^[mM]4([\+_])?[\w\d_]*/)) { | |
734 // m4 pre proc | |
735 style = (match[1] == "+") ? "tlv-m4-plus" : "tlv-m4"; | |
736 } else if (stream.match(/^ +/)){ | |
737 // Skip over spaces. | |
738 if (stream.eol()) { | |
739 // Trailing spaces. | |
740 style = "error"; | |
741 } else { | |
742 // Non-trailing spaces. | |
743 style = "tlv-default"; | |
744 } | |
745 } else if (stream.match(/^[\w\d_]+/)) { | |
746 // alpha-numeric token. | |
747 style = "number"; | |
748 } else { | |
749 // Eat the next char w/ no formatting. | |
750 stream.next(); | |
751 style = "tlv-default"; | |
752 } | |
753 if (beginStatement) { | |
754 style += " tlv-statement"; | |
755 } | |
756 } else { | |
757 if (stream.match(/^[mM]4([\w\d_]*)/)) { | |
758 // m4 pre proc | |
759 style = "tlv-m4"; | |
760 } | |
761 } | |
762 return style; | |
763 }, | |
764 | |
765 indent: function(state) { | |
766 return (state.tlvCodeActive == true) ? state.tlvNextIndent : -1; | |
767 }, | |
768 | |
769 startState: function(state) { | |
770 state.tlvIndentationStyle = []; // Styles to use for each level of indentation. | |
771 state.tlvCodeActive = true; // True when we're in a TLV region (and at beginning of file). | |
772 state.tlvNextIndent = -1; // The number of spaces to autoindent the next line if tlvCodeActive. | |
773 state.tlvInBlockComment = false; // True inside /**/ comment. | |
774 if (tlvTrackStatements) { | |
775 state.statementComment = false; // True inside a statement's header comment. | |
776 } | |
777 } | |
778 | |
779 } | |
780 }); | |
781 }); |