1041 lines
34 KiB
YAML
1041 lines
34 KiB
YAML
%YAML 1.2
|
|
---
|
|
# http://www.sublimetext.com/docs/syntax.html
|
|
name: VHDL
|
|
comment: VHDL Bundle by Brian Padalino (ocnqnyvab@tznvy.pbz)
|
|
file_extensions:
|
|
- vhd
|
|
- vhdl
|
|
- vho
|
|
scope: source.vhdl
|
|
contexts:
|
|
main:
|
|
- include: block_processing
|
|
- include: cleanup
|
|
architecture_pattern:
|
|
- match: |-
|
|
(?x)
|
|
|
|
# The word architecture $1
|
|
\b((?i:architecture))\s+
|
|
|
|
# Followed up by a valid $3 or invalid identifier $4
|
|
(([a-zA-z][a-zA-z0-9_]*)|(.+))(?=\s)\s+
|
|
|
|
# The word of $5
|
|
((?i:of))\s+
|
|
|
|
# Followed by a valid $7 or invalid identifier $8
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))(?=\s*(?i:is))\b
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.type.architecture.begin.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
5: keyword.language.vhdl
|
|
7: entity.name.type.entity.reference.vhdl
|
|
8: invalid.illegal.invalid.identifier.vhdl
|
|
push:
|
|
- meta_scope: meta.block.architecture
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))
|
|
|
|
# Optional word architecture $3
|
|
(\s+((?i:architecture)))?
|
|
|
|
# Optional same identifier $6 or illegal identifier $7
|
|
(\s+((\3)|(.+?)))?
|
|
|
|
# This will cause the previous to capture until just before the ; or $
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
6: entity.name.type.architecture.end.vhdl
|
|
7: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: function_definition_pattern
|
|
- include: procedure_definition_pattern
|
|
- include: component_pattern
|
|
- include: if_pattern
|
|
- include: process_pattern
|
|
- include: type_pattern
|
|
- include: record_pattern
|
|
- include: for_pattern
|
|
- include: entity_instantiation_pattern
|
|
- include: component_instantiation_pattern
|
|
- include: cleanup
|
|
attribute_list:
|
|
- match: \'\(
|
|
captures:
|
|
0: punctuation.vhdl
|
|
push:
|
|
- meta_scope: meta.block.attribute_list
|
|
- match: \)
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
- include: cleanup
|
|
block_processing:
|
|
- include: package_pattern
|
|
- include: package_body_pattern
|
|
- include: entity_pattern
|
|
- include: architecture_pattern
|
|
case_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# Beginning of line ...
|
|
^\s*
|
|
|
|
# Optional identifier ... $3 or invalid identifier $4
|
|
(
|
|
(
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|(.+?)
|
|
)
|
|
\s*:\s*
|
|
)?
|
|
|
|
# The word case $5
|
|
\b((?i:case))\b
|
|
|
|
captures:
|
|
3: entity.name.tag.case.begin.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
5: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.case.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))\s*
|
|
|
|
# The word case $4 or invalid word $5
|
|
(\s+(((?i:case))|(.*?)))
|
|
|
|
# Optional identifier from before $8 or illegal $9
|
|
(\s+((\2)|(.*?)))?
|
|
|
|
# Ending with a semicolon
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
4: keyword.language.vhdl
|
|
5: invalid.illegal.case.required.vhdl
|
|
8: entity.name.tag.case.end.vhdl
|
|
9: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: control_patterns
|
|
- include: cleanup
|
|
cleanup:
|
|
- include: comments
|
|
- include: constants_numeric
|
|
- include: strings
|
|
- include: attribute_list
|
|
- include: syntax_highlighting
|
|
comments:
|
|
- match: '--.*$\n?'
|
|
scope: comment.line.double-dash.vhdl
|
|
component_instantiation_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line ...
|
|
^\s*
|
|
|
|
# Match a valid identifier $1
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|
|
# Colon! $2
|
|
\s*(:)\s*
|
|
|
|
# Another valid identifier $3
|
|
([a-zA-Z][a-zA-Z0-9_]*)\b
|
|
|
|
# Make sure we are just the other word, or the beginning of
|
|
# a generic or port mapping
|
|
(?=\s*($|generic|port))
|
|
|
|
captures:
|
|
1: entity.name.section.component_instantiation.vhdl
|
|
2: punctuation.vhdl
|
|
3: entity.name.tag.component.reference.vhdl
|
|
push:
|
|
- meta_scope: meta.block.component_instantiation.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
- include: cleanup
|
|
component_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line ...
|
|
^\s*
|
|
|
|
# The word component $1
|
|
\b((?i:component))\s+
|
|
|
|
# A valid identifier $3 or invalid identifier $4
|
|
(([a-zA-Z_][a-zA-Z0-9_]*)\s*|(.+?))(?=\b(?i:is|port)\b|$|--)
|
|
|
|
# Optional word is $6
|
|
(\b((?i:is\b)))?
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.type.component.begin.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
6: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.component.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))\s+
|
|
|
|
# The word component $3 or illegal word $4
|
|
(((?i:component\b))|(.+?))(?=\s*|;)
|
|
|
|
# Optional identifier $7 or illegal mismatched $8
|
|
(\s+((\3)|(.+?)))?(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
4: invalid.illegal.component.keyword.required.vhdl
|
|
7: entity.name.type.component.end.vhdl
|
|
8: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: generic_list_pattern
|
|
- include: port_list_pattern
|
|
- include: comments
|
|
constants_numeric:
|
|
- match: '\b([+\-]?[\d_]+\.[\d_]+([eE][+\-]?[\d_]+)?)\b'
|
|
scope: constant.numeric.floating_point.vhdl
|
|
- match: '\b\d+#[\h_]+#\b'
|
|
scope: constant.numeric.base_pound_number_pound.vhdl
|
|
- match: '\b[\d_]+([eE][\d_]+)?\b'
|
|
scope: constant.numeric.integer.vhdl
|
|
- match: '[xX]"[0-9a-fA-F_uUxXzZwWlLhH\-]+"'
|
|
scope: constant.numeric.quoted.double.string.hex.vhdl
|
|
- match: '[oO]"[0-7_uUxXzZwWlLhH\-]+"'
|
|
scope: constant.numeric.quoted.double.string.octal.vhdl
|
|
- match: '[bB]?"[01_uUxXzZwWlLhH\-]+"'
|
|
scope: constant.numeric.quoted.double.string.binary.vhdl
|
|
- match: '([bBoOxX]".+?")'
|
|
scope: constant.numeric.quoted.double.string.illegal.vhdl
|
|
captures:
|
|
1: invalid.illegal.quoted.double.string.vhdl
|
|
- match: '''[01uUxXzZwWlLhH\-]'''
|
|
scope: constant.numeric.quoted.single.std_logic
|
|
control_patterns:
|
|
- include: case_pattern
|
|
- include: if_pattern
|
|
- include: for_pattern
|
|
- include: while_pattern
|
|
entity_instantiation_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
# Component identifier or illegal identifier $1
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|
|
# Colon! $2
|
|
\s*(:)\s*
|
|
|
|
# Optional word use $4
|
|
(((?i:use))\s+)?
|
|
|
|
# Required word entity $5
|
|
((?i:entity))\s+
|
|
|
|
# Optional library unit identifier $8 for invalid identifier $9 followed by a dot $10
|
|
(
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))
|
|
(\.)
|
|
)?
|
|
|
|
# Entity name reference $12 or illegal identifier $13
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))
|
|
|
|
# Check to see if we are being followed by either open paren, end of line, or port or generic words
|
|
(?=\s*(\(|$|(?i:port|generic)))
|
|
|
|
# Optional architecture elaboration
|
|
(
|
|
# Open paren $16
|
|
\s*(\()\s*
|
|
|
|
# Arch identifier $18 or invalid identifier $19
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))(?=\s*\))
|
|
|
|
# Close paren $21
|
|
\s*(\))
|
|
)?
|
|
|
|
captures:
|
|
1: entity.name.section.entity_instantiation.vhdl
|
|
2: punctuation.vhdl
|
|
4: keyword.language.vhdl
|
|
5: keyword.language.vhdl
|
|
8: entity.name.tag.library.reference.vhdl
|
|
9: invalid.illegal.invalid.identifier.vhdl
|
|
10: punctuation.vhdl
|
|
12: entity.name.tag.entity.reference.vhdl
|
|
13: invalid.illegal.invalid.identifier.vhdl
|
|
16: punctuation.vhdl
|
|
18: entity.name.tag.architecture.reference.vhdl
|
|
19: invalid.illegal.invalid.identifier.vhdl
|
|
21: punctuation.vhdl
|
|
push:
|
|
- meta_scope: meta.block.entity_instantiation.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
- include: cleanup
|
|
entity_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line ...
|
|
^\s*
|
|
|
|
# The word entity $1
|
|
((?i:entity\b))\s+
|
|
|
|
# The identifier $3 or an invalid identifier $4
|
|
(([a-zA-Z][a-zA-Z\d_]*)|(.+?))(?=\s)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.type.entity.begin.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
push:
|
|
- meta_scope: meta.block.entity.vhdl
|
|
- match: |-
|
|
(?x)
|
|
|
|
# The word end $1
|
|
\b((?i:end\b))
|
|
|
|
# Optional word entity $3
|
|
(\s+((?i:entity)))?
|
|
|
|
# Optional identifier match $6 or indentifier mismatch $7
|
|
(\s+((\3)|(.+?)))?
|
|
|
|
# Make sure there is a semicolon following
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
6: entity.name.type.entity.end.vhdl
|
|
7: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: comments
|
|
- include: generic_list_pattern
|
|
- include: port_list_pattern
|
|
- include: cleanup
|
|
for_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
(
|
|
# Check for an identifier $2
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|
|
# Followed by a colon $3
|
|
\s*(:)\s*
|
|
)?
|
|
|
|
# Make sure the next word is not wait
|
|
(?!(?i:wait\s*))
|
|
|
|
# The for keyword $4
|
|
\b((?i:for))\b
|
|
|
|
# Make sure the next word is not all
|
|
(?!\s*(?i:all))
|
|
|
|
|
|
captures:
|
|
2: entity.name.tag.for.generate.begin.vhdl
|
|
3: punctuation.vhdl
|
|
4: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.for.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))\s+
|
|
(
|
|
# Followed by generate or loop $3
|
|
((?i:generate|loop))
|
|
|
|
# But it really is required $4
|
|
|(\S+)
|
|
)\b
|
|
|
|
# The matching identifier $7 or an invalid identifier $8
|
|
(\s+((\2)|(.+?)))?
|
|
|
|
# Only space and a semicolon left
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
4: invalid.illegal.loop.or.generate.required.vhdl
|
|
7: entity.name.tag.for.generate.end.vhdl
|
|
8: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: control_patterns
|
|
- include: entity_instantiation_pattern
|
|
- include: component_pattern
|
|
- include: component_instantiation_pattern
|
|
- include: process_pattern
|
|
- include: cleanup
|
|
function_definition_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
# The word function $1
|
|
((?i:function))\s+
|
|
|
|
(
|
|
# A valid normal identifier $3
|
|
([a-zA-Z][a-zA-Z\d_]*)
|
|
# A valid string quoted identifier $4
|
|
|("\S+")
|
|
# A valid backslash escaped identifier $5
|
|
|(\\.+\\)
|
|
# An invalid identifier $5
|
|
|(.+?)
|
|
)
|
|
|
|
# Check to make sure we have a list or we return
|
|
(?=\s*
|
|
(
|
|
\(
|
|
|(?i:\breturn\b)
|
|
)
|
|
)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.function.function.begin.vhdl
|
|
4: entity.name.function.function.begin.vhdl
|
|
5: entity.name.function.function.begin.vhdl
|
|
6: invalid.illegal.invalid.identifier.vhdl
|
|
push:
|
|
- meta_scope: meta.block.function_definition.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
# The word end $1
|
|
((?i:end))
|
|
|
|
# Optional word function $3
|
|
(\s+((?i:function)))?
|
|
|
|
# Optional matched identifier $6 or mismatched identifier $7
|
|
(\s+((\3|\4|\5)|(.+?)))?
|
|
|
|
# Ending with whitespace and semicolon
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
6: entity.name.function.function.end.vhdl
|
|
7: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: control_patterns
|
|
- include: parenthetical_list
|
|
- include: type_pattern
|
|
- include: record_pattern
|
|
- include: cleanup
|
|
function_prototype_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
# The word function $1
|
|
((?i:function))\s+
|
|
|
|
|
|
(
|
|
# A valid normal identifier $3
|
|
([a-zA-Z][a-zA-Z\d_]*)
|
|
# A valid quoted identifier $4
|
|
|("\S+")
|
|
# A valid backslash escaped identifier $5
|
|
|(\\.+\\)
|
|
# An invalid identifier $6
|
|
|(.+?)
|
|
)
|
|
|
|
# Check to make sure we have a list or we return
|
|
(?=\s*
|
|
(
|
|
\(
|
|
|(?i:\breturn\b)
|
|
)
|
|
)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.function.function.prototype.vhdl
|
|
4: entity.name.function.function.prototype.vhdl
|
|
5: entity.name.function.function.prototype.vhdl
|
|
6: invalid.illegal.function.name.vhdl
|
|
push:
|
|
- meta_scope: meta.block.function_prototype.vhdl
|
|
- match: (?<=;)
|
|
pop: true
|
|
- match: '\b(?i:return)(?=\s+[^;]+\s*;)'
|
|
captures:
|
|
0: keyword.language.vhdl
|
|
push:
|
|
- match: \;
|
|
captures:
|
|
0: punctuation.terminator.function_prototype.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
- include: cleanup
|
|
- include: parenthetical_list
|
|
- include: cleanup
|
|
generic_list_pattern:
|
|
- match: \b(?i:generic)\b
|
|
captures:
|
|
0: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.generic_list.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
if_pattern:
|
|
- match: |-
|
|
(?x)
|
|
(
|
|
# Optional identifier $2
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|
|
# Followed by a colon $3
|
|
\s*(:)\s*
|
|
)?
|
|
|
|
# Keyword if $4
|
|
\b((?i:if))\b
|
|
|
|
captures:
|
|
2: entity.name.tag.if.generate.begin.vhdl
|
|
3: punctuation.vhdl
|
|
4: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.if.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))\s+
|
|
|
|
(
|
|
(
|
|
# Optional generate or if keyword $4
|
|
((?i:generate|if))
|
|
|
|
# Keyword if or generate required $5
|
|
|(\S+)
|
|
)\b
|
|
(
|
|
\s+
|
|
(
|
|
# Optional matching identifier $8
|
|
(\2)
|
|
|
|
# Mismatched identifier $9
|
|
|(.+?)
|
|
)
|
|
)?
|
|
)?
|
|
|
|
# Followed by a semicolon
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
4: keyword.language.vhdl
|
|
5: invalid.illegal.if.or.generate.required.vhdl
|
|
8: entity.name.tag.if.generate.end.vhdl
|
|
9: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: control_patterns
|
|
- include: process_pattern
|
|
- include: entity_instantiation_pattern
|
|
- include: component_pattern
|
|
- include: component_instantiation_pattern
|
|
- include: cleanup
|
|
keywords:
|
|
- match: '''(?i:active|ascending|base|delayed|driving|event|high|image|instance|last|left|leftof|length|low|path|pos|pred|quiet|range|reverse|right|rightof|simple|stable|succ|transaction|val|value)\b'
|
|
scope: keyword.attributes.vhdl
|
|
- match: \b(?i:abs|access|after|alias|all|and|architecture|array|assert|attribute|begin|block|body|buffer|bus|case|component|configuration|constant|disconnect|downto|else|elsif|end|entity|exit|file|for|function|generate|generic|group|guarded|if|impure|in|inertial|inout|is|label|library|linkage|literal|loop|map|mod|nand|new|next|nor|not|null|of|on|open|or|others|out|package|port|postponed|procedure|process|pure|range|record|register|reject|rem|report|return|rol|ror|select|severity|shared|signal|sla|sll|sra|srl|subtype|then|to|transport|type|unaffected|units|until|use|variable|wait|when|while|with|xnor|xor)\b
|
|
scope: keyword.language.vhdl
|
|
- match: '(\+|\-|<=|=|=>|:=|>=|>|<|/|\||&|(\*{1,2}))'
|
|
scope: keyword.operator.vhdl
|
|
package_body_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# The word package $1
|
|
\b((?i:package))\s+
|
|
|
|
# ... but we want to be a package body $2
|
|
((?i:body))\s+
|
|
|
|
# The valid identifier $4 or the invalid one $5
|
|
(([a-zA-Z][a-zA-Z\d_]*)|(.+?))\s+
|
|
|
|
# ... and we end it with an is $6
|
|
((?i:is))\b
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
2: keyword.language.vhdl
|
|
4: entity.name.section.package_body.begin.vhdl
|
|
5: invalid.illegal.invalid.identifier.vhdl
|
|
6: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.package_body.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end\b))
|
|
|
|
# Optional word package $3 body $4
|
|
(\s+((?i:package))\s+((?i:body)))?
|
|
|
|
# Optional identifier $7 or mismatched identifier $8
|
|
(\s+((\4)|(.+?)))?(?=\s*;)
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
4: keyword.language.vhdl
|
|
7: entity.name.section.package_body.end.vhdl
|
|
8: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: function_definition_pattern
|
|
- include: procedure_definition_pattern
|
|
- include: type_pattern
|
|
- include: subtype_pattern
|
|
- include: record_pattern
|
|
- include: cleanup
|
|
package_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# The word package $1
|
|
\b((?i:package))\s+
|
|
|
|
# ... but we do not want to be a package body
|
|
(?!(?i:body))
|
|
|
|
# The valid identifier $3 or the invalid one $4
|
|
(([a-zA-Z][a-zA-Z\d_]*)|(.+?))\s+
|
|
|
|
# ... and we end it with an is $5
|
|
((?i:is))\b
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.section.package.begin.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
5: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.package.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end\b))
|
|
|
|
# Optional word package $3
|
|
(\s+((?i:package)))?
|
|
|
|
# Optional identifier $6 or mismatched identifier $7
|
|
(\s+((\2)|(.+?)))?(?=\s*;)
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
6: entity.name.section.package.end.vhdl
|
|
7: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: function_prototype_pattern
|
|
- include: procedure_prototype_pattern
|
|
- include: type_pattern
|
|
- include: subtype_pattern
|
|
- include: record_pattern
|
|
- include: component_pattern
|
|
- include: cleanup
|
|
parenthetical_list:
|
|
- match: \(
|
|
captures:
|
|
0: punctuation.vhdl
|
|
push:
|
|
- meta_scope: meta.block.parenthetical_list.vhdl
|
|
- match: (?<=\))
|
|
pop: true
|
|
- match: '(?=[''"a-zA-Z0-9])'
|
|
push:
|
|
- meta_scope: meta.list.element.vhdl
|
|
- match: (;|\)|,)
|
|
captures:
|
|
0: meta.item.stopping.character.vhdl
|
|
pop: true
|
|
- include: comments
|
|
- include: parenthetical_pair
|
|
- include: cleanup
|
|
- match: \)
|
|
scope: invalid.illegal.unexpected.parenthesis.vhdl
|
|
- include: cleanup
|
|
parenthetical_pair:
|
|
- match: \(
|
|
captures:
|
|
0: punctuation.vhdl
|
|
push:
|
|
- meta_scope: meta.block.parenthetical_pair.vhdl
|
|
- match: \)
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: parenthetical_pair
|
|
- include: cleanup
|
|
port_list_pattern:
|
|
- match: \b(?i:port)\b
|
|
captures:
|
|
0: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.port_list.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
procedure_definition_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
# The word function $1
|
|
((?i:procedure))\s+
|
|
|
|
(
|
|
# A valid normal identifier $3
|
|
([a-zA-Z][a-zA-Z\d_]*)
|
|
# A valid quoted identifier $4
|
|
|("\S+")
|
|
# An invalid identifier $5
|
|
|(.+?)
|
|
)
|
|
|
|
# Check to make sure we have a list is
|
|
(?=\s*(\(|(?i:is)))
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.function.procedure.begin.vhdl
|
|
4: entity.name.function.procedure.begin.vhdl
|
|
5: invalid.illegal.invalid.identifier.vhdl
|
|
push:
|
|
- meta_scope: meta.block.procedure_definition.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
# The word end $1
|
|
((?i:end))
|
|
|
|
# Optional word function $3
|
|
(\s+((?i:procedure)))?
|
|
|
|
# Optional matched identifier $6 or mismatched identifier $7
|
|
(\s+((\3|\4)|(.+?)))?
|
|
|
|
# Ending with whitespace and semicolon
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
6: entity.name.function.procedure.end.vhdl
|
|
7: invalid.illegal.mismatched.identifier.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
- include: control_patterns
|
|
- include: type_pattern
|
|
- include: record_pattern
|
|
- include: cleanup
|
|
procedure_prototype_pattern:
|
|
- match: |-
|
|
(?x)
|
|
\b((?i:procedure))\s+
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))
|
|
(?=\s*(\(|;))
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.function.procedure.begin.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
push:
|
|
- meta_scope: meta.block.procedure_prototype.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctual.vhdl
|
|
pop: true
|
|
- include: parenthetical_list
|
|
process_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
|
|
(
|
|
# Optional identifier $2
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|
|
# Colon $3
|
|
\s*(:)\s*
|
|
)?
|
|
|
|
# The word process #4
|
|
((?i:process\b))
|
|
|
|
captures:
|
|
2: entity.name.section.process.begin.vhdl
|
|
3: punctuation.vhdl
|
|
4: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.process.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
((?i:end))
|
|
|
|
# Optional word process $3
|
|
(\s+((?i:process)))
|
|
|
|
# Optional identifier $6 or invalid identifier $7
|
|
(\s+((\2)|(.+?)))?
|
|
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
6: entity.name.section.process.end.vhdl
|
|
7: invalid.illegal.invalid.identifier.vhdl
|
|
pop: true
|
|
- include: control_patterns
|
|
- include: cleanup
|
|
punctuation:
|
|
- match: (\.|,|:|;|\(|\))
|
|
scope: punctuation.vhdl
|
|
record_pattern:
|
|
- match: \b(?i:record)\b
|
|
captures:
|
|
0: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.record.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))
|
|
|
|
# The word record $2
|
|
\s+((?i:record))
|
|
|
|
# Optional identifier $5 or invalid identifier $6
|
|
(\s+(([a-zA-Z][a-zA-Z\d_]*)|(.*?)))?
|
|
|
|
# Only whitespace and semicolons can be left
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
2: keyword.language.vhdl
|
|
5: entity.name.type.record.vhdl
|
|
6: invalid.illegal.invalid.identifier.vhdl
|
|
pop: true
|
|
- include: cleanup
|
|
- include: cleanup
|
|
strings:
|
|
- match: "'.'"
|
|
scope: string.quoted.single.vhdl
|
|
- match: '"'
|
|
push:
|
|
- meta_scope: string.quoted.double.vhdl
|
|
- match: '"'
|
|
pop: true
|
|
- match: \\.
|
|
scope: constant.character.escape.vhdl
|
|
- match: \\
|
|
push:
|
|
- meta_scope: string.other.backslash.vhdl
|
|
- match: \\
|
|
pop: true
|
|
subtype_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# The word subtype $1
|
|
\b((?i:subtype))\s+
|
|
|
|
# Valid identifier $3 or invalid identifier $4
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))\s+
|
|
|
|
# The word is $5
|
|
((?i:is))\b
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.type.subtype.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
5: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.subtype.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: cleanup
|
|
support_constants:
|
|
- match: \b(?i:math_1_over_e|math_1_over_pi|math_1_over_sqrt_2|math_2_pi|math_3_pi_over_2|math_deg_to_rad|math_e|math_log10_of_e|math_log2_of_e|math_log_of_10|math_log_of_2|math_pi|math_pi_over_2|math_pi_over_3|math_pi_over_4|math_rad_to_deg|math_sqrt_2|math_sqrt_pi)\b
|
|
scope: support.constant.ieee.math_real.vhdl
|
|
- match: \b(?i:math_cbase_1|math_cbase_j|math_czero|positive_real|principal_value)\b
|
|
scope: support.constant.ieee.math_complex.vhdl
|
|
- match: \b(?i:true|false)\b
|
|
scope: support.constant.std.standard.vhdl
|
|
support_functions:
|
|
- match: \b(?i:finish|stop|resolution_limit)\b
|
|
scope: support.function.std.env.vhdl
|
|
- match: \b(?i:readline|read|writeline|write|endfile|endline)\b
|
|
scope: support.function.std.textio.vhdl
|
|
- match: \b(?i:rising_edge|falling_edge|to_bit|to_bitvector|to_stdulogic|to_stdlogicvector|to_stdulogicvector|is_x)\b
|
|
scope: support.function.ieee.std_logic_1164.vhdl
|
|
- match: \b(?i:shift_left|shift_right|rotate_left|rotate_right|resize|to_integer|to_unsigned|to_signed)\b
|
|
scope: support.function.ieee.numeric_std.vhdl
|
|
- match: \b(?i:arccos(h?)|arcsin(h?)|arctan|arctanh|cbrt|ceil|cos|cosh|exp|floor|log10|log2|log|realmax|realmin|round|sign|sin|sinh|sqrt|tan|tanh|trunc)\b
|
|
scope: support.function.ieee.math_real.vhdl
|
|
- match: \b(?i:arg|cmplx|complex_to_polar|conj|get_principal_value|polar_to_complex)\b
|
|
scope: support.function.ieee.math_complex.vhdl
|
|
support_types:
|
|
- match: \b(?i:boolean|bit|character|severity_level|integer|real|time|delay_length|now|natural|positive|string|bit_vector|file_open_kind|file_open_status|fs|ps|ns|us|ms|sec|min|hr|severity_level|note|warning|error|failure)\b
|
|
scope: support.type.std.standard.vhdl
|
|
- match: \b(?i:line|text|side|width|input|output)\b
|
|
scope: support.type.std.textio.vhdl
|
|
- match: \b(?i:std_logic|std_ulogic|std_logic_vector|std_ulogic_vector)\b
|
|
scope: support.type.ieee.std_logic_1164.vhdl
|
|
- match: \b(?i:signed|unsigned)\b
|
|
scope: support.type.ieee.numeric_std.vhdl
|
|
- match: \b(?i:complex|complex_polar)\b
|
|
scope: support.type.ieee.math_complex.vhdl
|
|
syntax_highlighting:
|
|
- include: keywords
|
|
- include: punctuation
|
|
- include: support_constants
|
|
- include: support_types
|
|
- include: support_functions
|
|
type_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# The word type $1
|
|
\b((?i:type))\s+
|
|
|
|
# Valid identifier $3 or invalid identifier $4
|
|
(([a-zA-Z][a-zA-Z0-9_]*)|(.+?))
|
|
|
|
(
|
|
# A semicolon is coming up if we are incomplete
|
|
(?=\s*;)
|
|
|
|
# Or the word is comes up $7
|
|
|(\s+((?i:is)))
|
|
)\b
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: entity.name.type.type.vhdl
|
|
4: invalid.illegal.invalid.identifier.vhdl
|
|
7: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.type.vhdl
|
|
- match: ;
|
|
captures:
|
|
0: punctuation.vhdl
|
|
pop: true
|
|
- include: record_pattern
|
|
- include: cleanup
|
|
while_pattern:
|
|
- match: |-
|
|
(?x)
|
|
# From the beginning of the line
|
|
^\s*
|
|
(
|
|
# Check for an identifier $2
|
|
([a-zA-Z][a-zA-Z0-9_]*)
|
|
|
|
# Followed by a colon $3
|
|
\s*(:)\s*
|
|
)?
|
|
|
|
# The for keyword $4
|
|
\b((?i:while))\b
|
|
|
|
captures:
|
|
2: ''
|
|
3: punctuation.vhdl
|
|
4: keyword.language.vhdl
|
|
push:
|
|
- meta_scope: meta.block.while.vhdl
|
|
- match: |-
|
|
(?x)
|
|
# The word end $1
|
|
\b((?i:end))\s+
|
|
(
|
|
# Followed by keyword loop $3
|
|
((?i:loop))
|
|
|
|
# But it really is required $4
|
|
|(\S+)
|
|
)\b
|
|
|
|
# The matching identifier $7 or an invalid identifier $8
|
|
(\s+((\2)|(.+?)))?
|
|
|
|
# Only space and a semicolon left
|
|
(?=\s*;)
|
|
|
|
captures:
|
|
1: keyword.language.vhdl
|
|
3: keyword.language.vhdl
|
|
4: invalid.illegal.loop.keyword.required.vhdl
|
|
7: entity.name.tag.while.loop.vhdl
|
|
8: invalid.illegal.mismatched.identifier
|
|
pop: true
|
|
- include: control_patterns
|
|
- include: cleanup
|