@codingame/monaco-editor-wrapper 1.4.3 → 1.7.0

package/dist/verilog-systemverilog.js

@@ -1,208 +1,395 @@
-var bit = {
-	prefix: "bit",
-	body: "bit ${1:bit_name} = ${2:value};"
+var assign = {
+	prefix: "assign",
+	body: [
+		"assign ${1:var} = ${2:value};$0"
+	],
+	description: "Snippet for an assignment"
 };
-var int = {
-	prefix: "int",
-	body: "int ${1:int_name} = ${2:value};"
+var force = {
+	prefix: "force",
+	body: [
+		"force ${1:var} = ${2:value};$0"
+	],
+	description: "Snippet for a force assignment"
 };
-var shortint = {
-	prefix: "shortint",
-	body: "shortint ${1:name} = ${2:value};"
+var always = {
+	prefix: "always",
+	body: [
+		"always @(${1:sensitivity_list})",
+		"begin",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
+	],
+	description: "Snippet for an always block"
 };
-var longint = {
-	prefix: "longint",
-	body: "longint ${1:name} = ${2:value};"
+var always_ff = {
+	prefix: "always_ff",
+	body: [
+		"always_ff @(posedge ${1:clk} or negedge ${2:rst_n})",
+		"begin",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
+	],
+	description: "Snippet for an always_ff block"
 };
-var byte = {
-	prefix: "byte",
-	body: "byte ${1:byte:_name} = ${2:value};"
+var always_latch = {
+	prefix: "always_latch",
+	body: [
+		"always_latch",
+		"begin",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
+	],
+	description: "Snippet for an always_latch block"
 };
-var logic = {
-	prefix: "logic",
-	body: "logic ${1:logic_name} = ${2:value};"
+var always_comb = {
+	prefix: "always_comb",
+	body: [
+		"always_comb",
+		"begin",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
+	],
+	description: "Snippet for an always_comb block"
+};
+var elseif = {
+	prefix: "else if",
+	body: [
+		"else if (${1:condition})",
+		"begin${2:: block_name}",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
+	],
+	description: "Snippet for an else if"
 };
-var packed = {
-	prefix: "packed",
-	body: "packed"
+var foreach = {
+	prefix: "foreach",
+	body: [
+		"foreach (${1:arr}[${2:i}])",
+		"begin",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
+	],
+	description: "Snippet for a foreach loop"
 };
 var task = {
 	prefix: "task",
 	body: [
-		"task ${1:automatic} ${2:taskName}(${3:arguments});",
-		"\t$0",
-		"endtask //$1"
+		"task ${1:name}(${2:port_list});",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endtask"
 	],
-	description: "task name; ... endtask"
+	description: "Snippet for a task definition"
 };
-var modport = {
-	prefix: "modport",
+var program = {
+	prefix: "program",
 	body: [
-		"modport ${1:identifier} (",
-		"input ${2:input_ports},",
-		"output ${3:output_ports}",
-		");"
+		"program ${1:name}(${2:port_list});",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endprogram"
 	],
-	description: "modport name (input ports_in, output ports_out); "
+	description: "Snippet for a program definition"
 };
-var display = {
-	prefix: "display",
+var module = {
+	prefix: "module",
 	body: [
-		"\\$display(\"$1\"$2);$0"
+		"module ${1:name} (",
+		"\t${2:port_list}",
+		");",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endmodule"
 	],
-	description: "$display(\"...\", params...)"
+	description: "Snippet for a module definition"
 };
-var queue = {
-	prefix: "queue",
-	body: "${1:data_type} ${2:queue_name}[\\$];",
-	description: "insert queue."
+var assert = {
+	prefix: "assert",
+	body: [
+		"${1:label}: assert (${2:test})",
+		"\telse \\$error(\"${0:Assertion ${1:label} failed!}\");"
+	],
+	description: "Snippet for an immediate assertion"
 };
-var mailbox = {
-	prefix: "mailbox",
+var property = {
+	prefix: "property",
 	body: [
-		"mailbox mbx",
-		"${1:mbx = new();}"
+		"property ${1:name};",
+		"\t@(posedge ${2:clk}) ${0:test}",
+		"endproperty"
 	],
-	description: "insert mailbox instance"
+	description: "Snippet for a property"
 };
-var assert = {
-	prefix: "assert",
+var generate = {
+	prefix: "generate",
+	body: [
+		"generate",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endgenerate"
+	],
+	description: "Snippet for a generate block"
+};
+var ternary = {
+	prefix: "ter",
+	body: [
+		"$1 ? $2 : $3"
+	],
+	description: "Snippet for a ternary operator expression"
+};
+var reg = {
+	prefix: "reg",
+	body: [
+		"reg $1;$0"
+	],
+	description: "Snippet for a register declaration"
+};
+var regarray = {
+	prefix: "rega",
+	body: [
+		"reg [$1:$2] $3;$0"
+	],
+	description: "Snippet for a multi-bit register declaration"
+};
+var regmemory = {
+	prefix: "regm",
+	body: [
+		"reg [$1:$2] $3 [$4:$5];$0"
+	],
+	description: "Snippet for a memory register declaration"
+};
+var wire = {
+	prefix: "wire",
+	body: [
+		"wire $1;$0"
+	],
+	description: "Snippet for a wire declaration"
+};
+var wirearray = {
+	prefix: "wirea",
+	body: [
+		"wire [$1:$2] $3;$0"
+	],
+	description: "Snippet for a multi-bit wire declaration"
+};
+var logic = {
+	prefix: "logic",
 	body: [
-		"assert (${1:condition}) $2",
-		"else   ${3:error_process}"
+		"logic $1;$0"
 	],
-	description: "insert assert() ... else ..."
+	description: "Snippet for a logic signal declaration"
+};
+var logicarray = {
+	prefix: "logica",
+	body: [
+		"logic [$1:$2] $3;$0"
+	],
+	description: "Snippet for a multi-bit logic signal declaration"
+};
+var array = {
+	prefix: "array",
+	body: "[${1:8}:${2:0}]$0",
+	description: "Snippet for a multi-bit register declaration"
+};
+var associative_array = {
+	prefix: "assoc",
+	body: "${1:type} ${2:name}[${3:index_type}];$0",
+	description: "Snippet for a associative array declaration"
+};
+var separator = {
+	prefix: "separator",
+	body: [
+		"// -------------------------------------------------------\n$0"
+	],
+	description: "Snippet for a separator"
+};
+var heading = {
+	prefix: "heading",
+	body: [
+		"// -------------------------------------------------------",
+		"// -- ${1:heading}",
+		"// -------------------------------------------------------\n$0"
+	],
+	description: "Snippet for a heading"
 };
 var verilogSystemverilog = {
-	"always_ff block": {
-	prefix: "always_ff",
+	assign: assign,
+	force: force,
+	always: always,
+	always_ff: always_ff,
+	always_latch: always_latch,
+	always_comb: always_comb,
+	"if": {
+	prefix: "if",
 	body: [
-		"always_ff @( ${1:clock} ) begin : ${2:blockName}",
-		"\t$0",
+		"if (${1:condition})",
+		"begin${2:: block_name}",
+		"\t${3:pass}",
 		"end"
 	],
-	description: "Insert an always_ff block"
+	description: "Snippet for an if statement"
 },
-	"always_comb block": {
-	prefix: "always_comb",
+	"if/else": {
+	prefix: "if/else",
 	body: [
-		"always_comb begin : ${1:blockName}",
-		"\t$0",
+		"if (${1:condition})",
+		"begin${2:: block_name}",
+		"\t${3:pass}",
+		"end",
+		"else",
+		"begin${4:: block_name}",
+		"\t${5:pass}",
 		"end"
 	],
-	description: "Insert an always_comb block"
+	description: "Snippet for an if statement with else"
 },
-	"always_latch block": {
-	prefix: "always_latch",
+	elseif: elseif,
+	"else": {
+	prefix: "else",
 	body: [
-		"always_latch begin : ${1:blockName}",
-		"\t$0",
+		"else",
+		"begin${1:: block_name}",
+		"\t${0:${TM_SELECTED_TEXT}}",
 		"end"
 	],
-	description: "Insert an always_latch block"
+	description: "Snippet for an else"
 },
-	bit: bit,
-	int: int,
-	shortint: shortint,
-	longint: longint,
-	byte: byte,
-	logic: logic,
-	packed: packed,
-	"this": {
-	prefix: "this",
-	body: "this"
+	"case": {
+	prefix: "case",
+	body: [
+		"case (${1:variable})",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endcase"
+	],
+	description: "Snippet for a case statement"
 },
-	"typedef struct packed": {
-	prefix: "typedef struct packed",
+	"case/default": {
+	prefix: "case/default",
 	body: [
-		"typedef struct packed {",
-		"\t$0",
-		"} ${1:struct_name};"
+		"case (${1:variable})",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"\tdefault:",
+		"\tbegin${2:: block_name}",
+		"\t\t${3:default_case}",
+		"\tend",
+		"endcase"
 	],
-	description: "typedef struct packed { ... } name"
+	description: "Snippet for a case statement with default"
 },
-	"class": {
-	prefix: "class",
+	"while": {
+	prefix: "while",
 	body: [
-		"class ${1:className};",
-		"\tfunction new();",
-		"\t\t$0",
-		"\tendfunction //new()",
-		"endclass //$1"
+		"while (${1:expression})",
+		"begin",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
 	],
-	description: "class name; ... endclass"
+	description: "Snippet for a while loop"
 },
-	"class extends": {
-	prefix: "class extends",
+	"for": {
+	prefix: "for",
 	body: [
-		"class ${1:className} extends ${2:superClass};",
-		"\tfunction new();",
-		"\t\t$0",
-		"\tendfunction //new()",
-		"endclass //$1 extends $2"
+		"for (int ${1:i}=0; ${1:i}<${2:MAX}; ++${1:i})",
+		"begin${3:: block_name}",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"end"
 	],
-	description: "class name extends super; ... endclass"
+	description: "Snippet for a for loop"
 },
-	task: task,
-	"package": {
-	prefix: "package",
+	foreach: foreach,
+	"function": {
+	prefix: "function",
 	body: [
-		"package ${1:package_name}",
-		"\t$2",
-		"endpackage"
+		"function ${1:return_value} ${2:name}(${3:port_list});",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endfunction"
 	],
-	description: "package name; ... endpackage"
+	description: "Snippet for a function definition"
 },
-	"import": {
-	prefix: "import",
-	body: "import ${1:name}::${2:scope};",
-	description: "import name::scope"
+	task: task,
+	"class": {
+	prefix: "class",
+	body: [
+		"class ${1:name};",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endclass"
+	],
+	description: "Snippet for a class definition"
 },
-	"interface": {
-	prefix: "interface",
+	"class/extends": {
+	prefix: "class/extends",
 	body: [
-		"interface ${1:interfacename};",
-		"\t$0",
-		"endinterface //$1"
+		"class ${1:name} extends ${2:super};",
+		"\tfunction new();",
+		"\t\t${0:${TM_SELECTED_TEXT}}",
+		"\tendfunction",
+		"endclass"
 	],
-	description: "interface name; ... endinterface"
+	description: "Snippet for a class definition with extends"
 },
-	modport: modport,
-	display: display,
-	"typedef enum": {
-	prefix: "typedef enum",
+	program: program,
+	module: module,
+	"module#(param)": {
+	prefix: "module #(",
 	body: [
-		"typedef enum ${1:data_type} { $0 } ${2:name};"
+		"module ${1:name} #(",
+		"\t${2:parameters}",
+		") (",
+		"\t${3:port_list}",
+		");",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endmodule"
 	],
-	description: "typedef enum (data_type) { ... } name"
+	description: "Snippet for a parameterized module definition"
 },
-	"enum": {
-	prefix: [
-		"en",
-		"enum"
+	assert: assert,
+	property: property,
+	generate: generate,
+	"typedef/struct": {
+	prefix: "typedef/struct",
+	body: [
+		"typedef struct packed {",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"} ${1:name};"
 	],
+	description: "Snippet for a structure type definition"
+},
+	"typedef/enum": {
+	prefix: "typedef/enum",
 	body: [
-		"enum ${1:data_type} { $0 } ${2:name}"
+		"typedef enum ${1:type} { ${0:${TM_SELECTED_TEXT}} } ${2:name};"
 	],
-	description: "enum (data_type) { ... } name"
+	description: "Snippet for a enumeration type definition"
 },
-	queue: queue,
-	mailbox: mailbox,
-	"associative array": {
-	prefix: "AA",
-	body: "${1:data_type} ${2:name}[${3:index_type}];$0",
-	description: "insert Associative array(AA)."
+	"interface": {
+	prefix: "interface",
+	body: [
+		"interface ${1:name};",
+		"\t${0:${TM_SELECTED_TEXT}}",
+		"endinterface"
+	],
+	description: "Snippet for an interface definition"
 },
-	assert: assert,
-	"fork-join": {
-	prefix: "fork join",
+	ternary: ternary,
+	reg: reg,
+	regarray: regarray,
+	regmemory: regmemory,
+	wire: wire,
+	wirearray: wirearray,
+	logic: logic,
+	logicarray: logicarray,
+	array: array,
+	associative_array: associative_array,
+	separator: separator,
+	heading: heading,
+	"heading+description": {
+	prefix: "heading+description",
 	body: [
-		"fork",
-		"\t$0",
-		"join"
+		"// -------------------------------------------------------",
+		"// -- ${1:heading}",
+		"// -------------------------------------------------------",
+		"// ${2:description}",
+		"// -------------------------------------------------------\n$0"
 	],
-	description: "fork ... join"
+	description: "Snippet for a heading with a block for description"
 }
 };
 
-export { assert, bit, byte, verilogSystemverilog as default, display, int, logic, longint, mailbox, modport, packed, queue, shortint, task };
+export { always, always_comb, always_ff, always_latch, array, assert, assign, associative_array, verilogSystemverilog as default, elseif, force, foreach, generate, heading, logic, logicarray, module, program, property, reg, regarray, regmemory, separator, task, ternary, wire, wirearray };

package/dist/verilog.js

@@ -23,7 +23,7 @@ var brackets = [
 		"end"
 	],
 	[
-		"case",
+		"randcase",
 		"endcase"
 	],
 	[
@@ -34,14 +34,46 @@ var brackets = [
 		"casez",
 		"endcase"
 	],
+	[
+		"case",
+		"endcase"
+	],
+	[
+		"checker",
+		"endchecker"
+	],
+	[
+		"class",
+		"endclass"
+	],
+	[
+		"clocking",
+		"endclocking"
+	],
 	[
 		"config",
 		"endconfig"
 	],
+	[
+		"coverage",
+		"endcoverage"
+	],
+	[
+		"covergroup",
+		"endgroup"
+	],
 	[
 		"fork",
 		"join"
 	],
+	[
+		"fork",
+		"join_any"
+	],
+	[
+		"fork",
+		"join_none"
+	],
 	[
 		"function",
 		"endfunction"
@@ -50,6 +82,10 @@ var brackets = [
 		"generate",
 		"endgenerate"
 	],
+	[
+		"interface",
+		"endinterface"
+	],
 	[
 		"macromodule",
 		"endmodule"
@@ -58,14 +94,30 @@ var brackets = [
 		"module",
 		"endmodule"
 	],
+	[
+		"package",
+		"endpackage"
+	],
 	[
 		"primitive",
 		"endprimitive"
 	],
+	[
+		"program",
+		"endprogram"
+	],
+	[
+		"property",
+		"endproperty"
+	],
 	[
 		"specify",
 		"endspecify"
 	],
+	[
+		"sequence",
+		"endsequence"
+	],
 	[
 		"table",
 		"endtable"
@@ -96,10 +148,40 @@ var autoClosingPairs = [
 		]
 	}
 ];
+var surroundingPairs = [
+	[
+		"{",
+		"}"
+	],
+	[
+		"[",
+		"]"
+	],
+	[
+		"(",
+		")"
+	],
+	[
+		"'",
+		"'"
+	],
+	[
+		"\"",
+		"\""
+	]
+];
+var folding = {
+	markers: {
+		start: "^[ \\t\\n]*(?://[ \\t\\n]*#?region|`(?:ifdef|ifndef|elsif|else)\\b|\\b(?:(?:macro)?module|class)\\b)",
+		end: "^[ \\t\\n]*(?://[ \\t\\n]*#?endregion|`(?:elsif|else|endif)\\b|\\b(?:endmodule|endclass)\\b)"
+	}
+};
 var verilog = {
 	comments: comments,
 	brackets: brackets,
-	autoClosingPairs: autoClosingPairs
+	autoClosingPairs: autoClosingPairs,
+	surroundingPairs: surroundingPairs,
+	folding: folding
 };
 
-export { autoClosingPairs, brackets, comments, verilog as default };
+export { autoClosingPairs, brackets, comments, verilog as default, folding, surroundingPairs };