Gecko [ www.vortexaion.com ]

Name	Size	Permission	Date
ada.xml	3.5 KB	-rw-rw-rw-	2022-11-29 20:53
asm.xml	1.32 KB	-rw-rw-rw-	2021-05-27 00:57
autoit.xml	1.8 KB	-rw-rw-rw-	2021-05-27 00:57
baanc.xml	8.31 KB	-rw-rw-rw-	2021-05-27 00:57
bash.xml	2.93 KB	-rw-rw-rw-	2021-05-27 00:57
batch.xml	1.88 KB	-rw-rw-rw-	2021-05-27 00:57
c.xml	4.04 KB	-rw-rw-rw-	2021-05-27 00:57
cobol-free.xml	1.73 KB	-rw-rw-rw-	2021-05-27 00:57
cobol.xml	1.34 KB	-rw-rw-rw-	2021-05-27 00:57
cpp.xml	18.08 KB	-rw-rw-rw-	2021-05-27 00:57
cs.xml	1.79 KB	-rw-rw-rw-	2021-05-27 00:57
fortran.xml	1.95 KB	-rw-rw-rw-	2021-05-27 00:57
fortran77.xml	1.58 KB	-rw-rw-rw-	2021-05-27 00:57
gdscript.xml	1.05 KB	-rw-rw-rw-	2023-03-14 23:45
haskell.xml	2.42 KB	-rw-rw-rw-	2021-05-27 00:57
hollywood.xml	959 B	-rw-rw-rw-	2023-03-28 12:47
ini.xml	952 B	-rw-rw-rw-	2021-05-27 00:57
inno.xml	4.3 KB	-rw-rw-rw-	2021-05-27 00:57
java.xml	9.11 KB	-rw-rw-rw-	2021-05-27 00:57
javascript.js.xml	1.12 KB	-rw-rw-rw-	2021-05-27 00:57
krl.xml	2.97 KB	-rw-rw-rw-	2021-05-27 00:57
lua.xml	4.3 KB	-rw-rw-rw-	2021-12-05 05:28
nppexec.xml	2.03 KB	-rw-rw-rw-	2022-11-28 15:26
nsis.xml	6.96 KB	-rw-rw-rw-	2021-05-27 00:57
overrideMap.xml	6.5 KB	-rw-rw-rw-	2023-03-28 12:47
pascal.xml	10.69 KB	-rw-rw-rw-	2023-02-10 23:57
perl.xml	1.47 KB	-rw-rw-rw-	2021-05-27 00:57
php.xml	9.77 KB	-rw-rw-rw-	2021-05-27 00:57
powershell.xml	1.35 KB	-rw-rw-rw-	2021-05-27 00:57
python.xml	1.07 KB	-rw-rw-rw-	2021-06-10 14:27
ruby.xml	1.06 KB	-rw-rw-rw-	2021-05-27 00:57
rust.xml	1.8 KB	-rw-rw-rw-	2021-05-27 00:57
sinumerik.xml	1003 B	-rw-rw-rw-	2021-05-27 00:57
sql.xml	1.28 KB	-rw-rw-rw-	2022-12-13 20:01
typescript.xml	1.12 KB	-rw-rw-rw-	2021-08-15 22:16
universe_basic.xml	1.97 KB	-rw-rw-rw-	2021-05-27 00:57
vhdl.xml	1.58 KB	-rw-rw-rw-	2021-05-27 00:57
xml.xml	2.18 KB	-rw-rw-rw-	2021-05-27 00:57

Rename

<?xml version="1.0" encoding="UTF-8" ?>

<NotepadPlus>
	<functionList>
		
		<parser
			displayName="C++"
			id         ="cplusplus_syntax"
			commentExpr="(?s:/\*.*?\*/)|(?m-s://.*?$)"
		>
			<classRange
				mainExpr="(?x)                                                                 # use inline comments
					^[\t\x20]*                                                                 # leading whitespace
					(template\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?               # template parameters
					(class|struct)                                                             # class/struct definition keyword
					[\t\x20]+                                                                  # following whitespace
					((\w+|\[\[[^\r\n]*\]\])[\t\x20]+)*                                         # type attributes
					(
						\w+                                                                    # namespace identifier
						(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?                   # template parameters
						\s*::\s*                                                               # namespace separator
					)*
					\w+                                                                        # class/struct identifier
					(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?                       # template parameters
					(\s*final\s*)?                                                             # final specifier
					(
						\s*:\s*                                                                # inheritance separator
						((private|protected|public|virtual)\s+)*                               # visibility/virtual specifier
						(
							\w+                                                                # namespace identifier
							(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?               # template parameters
							\s*::\s*                                                           # namespace separator
						)*
						\w+                                                                    # parent class/struct identifier
						(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?                   # template parameters
						(
							\s*,\s*                                                            # multiple inheritance separator
							((private|protected|public|virtual)\s+)*                           # visibility/virtual specifier
							(
								\w+                                                            # namespace identifier
								(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?           # template parameters
								\s*::\s*                                                       # namespace separator
							)*
							\w+                                                                # parent class/struct identifier
							(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?               # template parameters
						)*
					)?
					\s*                                                                        # trailing whitespace
					\{                                                                         # class/struct body
				"
				openSymbole ="\{"
				closeSymbole="\}"
			>
				<className>
					<nameExpr
						expr="(?x)                                                             # use inline comments
							(class|struct)                                                     # class/struct definition keyword
							[\t\x20]+                                                          # following whitespace
							((\w+|\[\[[^\r\n]*\]\])[\t\x20]+)*                                 # type attributes
							(\w+\s*::\s*)*                                                     # namespace specifier
							\w+                                                                # class/struct identifier
							(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?               # template parameters
							(\s*final\s*)?                                                     # final specifier
							\s*                                                                # trailing whitespace
							(:\s*\w+|\{)                                                       # inheritance separator | class/struct body
						"
					/>
					<nameExpr
						expr="(?x)                                                             # use inline comments
							(\w+\s*::\s*)*                                                     # namespace specifier
							\w+                                                                # class/struct identifier
							(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?               # template parameters
							(\s*final\s*)?                                                     # final specifier
							\s*                                                                # trailing whitespace
							(:\s*\w+|\{)                                                       # inheritance separator | class/struct body
						"
					/>
					<nameExpr
						expr="(?x)                                                             # use inline comments
							(\w+\s*::\s*)*                                                     # namespace specifier
							\w+                                                                # class/struct identifier
						"
					/>
				</className>
				<function
					mainExpr="(?x)                                                             # use inline comments
						^[\t\x20]*                                                             # leading whitespace
						(template\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?           # template parameters
						((consteval|constexpr|explicit|friend|inline|static|virtual)\s+)*      # left function definition keywords
						(
							(                                                                  # conversion operator definition
								(
									\w+                                                        # namespace identifier
									(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?       # template parameters
									\s*::\s*                                                   # namespace separator
								)*
								operator\s+                                                    # operator keyword
								((const|long|signed|unsigned|volatile)\s+)*                    # type definition keyword
								(                                                              # operator type definition
									(
										\w+                                                    # namespace identifier
										(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?   # template parameters
										\s*::\s*                                               # namespace separator
									)*
									\w+                                                        # operator type identifier
									(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?       # template parameters
								)*
								(\s*(\*|\*\*|&amp;)\s*)?                                       # type pointer/reference
							)
						|	(
								((const|long|signed|unsigned|volatile)\s+)*                    # type definition keyword
								(                                                              # return type definition
									(
										\w+                                                    # namespace identifier
										(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?   # template parameters
										\s*::\s*                                               # namespace separator
									)*
									\w+                                                        # return type identifier
									(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?       # template parameters
								)
								(                                                              # type pointer/reference
									\s+
								|	(\*|\*\*|&amp;)\s+
								|	\s+(\*|\*\*|&amp;)
								|	\s+(\*|\*\*|&amp;)\s+
								)
								(
									\w+                                                        # namespace identifier
									(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?       # template parameters
									\s*::\s*                                                   # namespace separator
								)*
								(
									(                                                          # function definition
										(?!(if|while|for|switch)\s*$)                         # exclude block/loop definition
										\w+                                                    # function identifier
									)
								|	(                                                          # operator definition
										operator\($                                           # parenthesis operator
									|	operator                                               # operator keyword
										[\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+                  # operator symbol
									)
								)
							)
						)
						\s*                                                                    # following whitespace
						$
							[^$$]*                                                           # function parameters
							(\([^$$]*$[^\)$]*)*                                            # functors as parameter
						$
						(\s*(const|final|noexcept|override|volatile)\s*)*                      # right function definition keywords
						\s*                                                                    # trailing whitespace
						\{                                                                     # function body
					"
				>
					<functionName>
						<funcNameExpr
							expr="(?x)                                                         # use inline comments
								(
									operator                                               # parenthesis operator
								|	operator                                                   # operator keyword
									[\w\t\x20\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+              # operator symbol | conversion operator
								|	(?!(if|while|for|switch)\s*$)                             # exclude block/loop definition
									\w+                                                        # function identifier
								)
								\s*                                                            # following whitespace
								\(                                                             # function parameters
							"
						/>
						<funcNameExpr
							expr="(?x)                                                         # use inline comments
								(
									operator\($                                               # parenthesis operator
								|	operator                                                   # operator keyword
									[\w\t\x20\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+              # operator symbol | conversion operator
								|	(?!(if|while|for|switch)\s*$)                             # exclude block/loop definition
									\w+                                                        # function identifier
								)
							"
						/>
					</functionName>
				</function>
			</classRange>
			<function
				mainExpr="(?x)                                                                 # use inline comments
					^[\t\x20]*                                                                 # leading whitespace
					(template\s*&lt;\s*[\w\t\x20\($\=\.:,&lt;&gt;]*\s*&gt;\s*)?               # template parameters
					((consteval|constexpr|explicit|friend|inline|static|virtual)\s+)*          # left function definition keywords
					(
						(                                                                      # conversion operator definition
							(
								\w+                                                            # namespace identifier
								(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?           # template parameters
								\s*::\s*                                                       # namespace separator
							)*
							operator\s+                                                        # operator keyword
							((const|long|signed|unsigned|volatile)\s+)*                        # type definition keyword
							(                                                                  # operator type definition
								(
									\w+                                                        # namespace identifier
									(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?       # template parameters
									\s*::\s*                                                   # namespace separator
								)*
								\w+                                                            # operator type identifier
								(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?           # template parameters
							)*
							(\s*(\*|\*\*|&amp;)\s*)?                                           # type pointer/reference
						)
					|	(
							((const|long|signed|unsigned|volatile)\s+)*                        # type definition keyword
							(                                                                  # return type definition
								(
									\w+                                                        # namespace identifier
									(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?       # template parameters
									\s*::\s*                                                   # namespace separator
								)*
								\w+                                                            # return type identifier
								(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?           # template parameters
							)
							(                                                                  # type pointer/reference
								\s+
							|	(\*|\*\*|&amp;)\s+
							|	\s+(\*|\*\*|&amp;)
							|	\s+(\*|\*\*|&amp;)\s+
							)
							(
								\w+                                                            # namespace identifier
								(\s*&lt;\s*[\w\t\x20\=\.:,&lt;&gt;]*\s*&gt;\s*)?           # template parameters
								\s*::\s*                                                       # namespace separator
							)*
							(
								(                                                              # function definition
									(?!(if|while|for|switch)\s*$)                             # exclude block/loop definition
									\w+                                                        # function identifier
								)
							|	(                                                              # operator definition
									operator\($                                               # operator parenthesis
								|	operator                                                   # operator keyword
									[\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+                      # operator symbol
								)
							)
						)
					)
					\s*                                                                        # following whitespace
					$
						[^$$]*                                                               # function parameters
						(\([^$$]*$[^\)$]*)*                                                # functors as parameter
					$
					(\s*(const|final|noexcept|override|volatile)\s*)*                          # right function definition keywords
					\s*                                                                        # trailing whitespace
					\{                                                                         # function body
				"
			>
				<functionName>
					<nameExpr
						expr="(?x)                                                             # use inline comments
							(
								operator                                                   # parenthesis operator
							|	operator                                                       # operator keyword
								[\w\t\x20\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+                  # operator symbol | conversion operator
							|	(?!(if|while|for|switch)\s*$)                                 # exclude block/loop definition
								\w+                                                            # function identifier
							)
							\s*                                                                # following whitespace
							\(                                                                 # function parameters
						"
					/>
					<nameExpr
						expr="(?x)                                                             # use inline comments
							(
								operator\($                                                   # parenthesis operator
							|	operator                                                       # operator keyword
								[\w\t\x20\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+                  # operator symbol | conversion operator
							|	(?!(if|while|for|switch)\s*$)                                 # exclude block/loop definition
								\w+                                                            # function identifier
							)
						"
					/>
				</functionName>
				<className>
					<nameExpr expr="(?x)                                                       # use inline comments
						\w+                                                                    # namespace identifier
						(?=
							(\s*&lt;\s*[\w\t\x20\($\=\.:,]*\s*&gt;\s*)?                       # template parameters
							\s*::\s*                                                           # namespace separator
							(
								operator                                                   # parenthesis operator
							|	operator                                                       # operator keyword
								[\w\t\x20\[\]\*\=\+\-\~\|\^%!,&amp;&lt;&gt;]+                  # operator symbol | conversion operator
							|	\w+                                                            # function identifier
							)
							\(                                                                 # function parameters
						)
					" />
				</className>
			</function>
		</parser>
	</functionList>
</NotepadPlus>