Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission
localization	[ DIR ]	drwxrwxrwx
plugins	[ DIR ]	drwxrwxrwx
themes	[ DIR ]	drwxrwxrwx
updater	[ DIR ]	drwxrwxrwx
.mad-root	0 B	-rw-rw-rw-
SciLexer.dll	1.37 MB	-rw-rw-rw-
change.log	626 B	-rw-rw-rw-
config.xml	5.49 KB	-rw-rw-rw-
contextMenu.xml	3.51 KB	-rw-rw-rw-
doLocalConf.xml	0 B	-rw-rw-rw-
functionList.xml	56.53 KB	-rw-rw-rw-
langs.model.xml	275.28 KB	-rw-rw-rw-
langs.xml	275.28 KB	-rw-rw-rw-
notepad++.exe	2.83 MB	-rwxrwxrwx
readme.txt	1.42 KB	-rw-rw-rw-
session.xml	2.43 KB	-rw-rw-rw-
shortcuts.xml	1.55 KB	-rw-rw-rw-
stylers.model.xml	114.89 KB	-rw-rw-rw-
stylers.xml	114.89 KB	-rw-rw-rw-

Code Editor : functionList.xml

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

<NotepadPlus>
	<functionList>
		<associationMap>
		<!--
			langID:

Don't use L_JS (19) use L_JAVASCRIPT (58) instead!
			Don't use L_USER and L_EXTERNAL, use extension or UDL name association instead!

if langID cannot be found above, you can set the file extensions ...

and for User Defined Languages (UDL's) use ...

Note(s):
				Not required, just a guide.
				Suffix		Indicates
				~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				_class		parser has a class part only
				_function	parser has a function part only
				_syntax		parser has both a class and function part
		-->
			
			
			
			<association id=         "php_syntax"     langID= "1"                          />
			<association id=           "c_function"   langID= "2"                          />
			<association id=   "cplusplus_syntax"     langID= "3"                          />
			<association id=      "csharp_class"      langID= "4"                          />
			<association id=        "java_syntax"     langID= "6"                          />
			<association id=         "xml_node"       langID= "9"                          />

			<association id=       "batch_label"      langID="12"                          />
			<association id=         "ini_section"    langID="13"                          />
			<association id=        "perl_function"   langID="21"                          />
			<association id=      "python_syntax"     langID="22"                          />
			<association id=        "bash_function"   langID="26"                          />
			<association id=        "nsis_syntax"     langID="28"                          />
			<association id=    "assembly_subroutine" langID="32"                          />
			<association id=        "ruby_syntax"     langID="36"                          />
			<association id=     "autoit3_function"   langID="40"                          />
			<association id=   "innosetup_syntax"     langID="46"                          />
			<association id=  "powershell_function"   langID="53"                          />
			<association id=  "javascript_function"   langID="58"                          />
			
			<association id=         "krl_function"   userDefinedLangName="KRL"            />
			<association id=         "krl_function"   ext=".src"                           />
			<association id=         "krl_function"   ext=".sub"                           />
			
			<association id=   "sinumerik_function"   userDefinedLangName="Sinumerik"      />
			<association id=   "sinumerik_function"   ext=".arc"                           />
			
			<association id=    "universe_basic"      userDefinedLangName="UniVerse BASIC" />
			<association id=    "universe_basic"      ext=".bas"                           />
			
		</associationMap>
		<parsers>

<parser
				displayName="C#"
				id         ="csharp_class"
				commentExpr="(?s:/\*.*?\*/)|(?m-s://.*?$)"
			>
				<classRange
					mainExpr    ="^[\t\x20]*((public|protected|private|internal)\s+)?(\w+\s*)?(class|struct|interface)[\t\x20]+[^\{]+\{"
					openSymbole ="\{"
					closeSymbole="\}"
				>
					<className>
						<nameExpr expr="(class|struct|interface)[\t\x20]+\w+" />
						<nameExpr expr="[\t\x20]+\w+" />
						<nameExpr expr="\w+" />
					</className>
					<function
						mainExpr="^[^\S\r\n]*(?&lt;modifier1&gt;(?:public|protected|internal|private)\s*)?(?&lt;modifier2&gt;(?:new|static|virtual|sealed|override|abstract|extern)\s*)?(partial\s*)?(?&lt;type&gt;(?!(return|if|else))\w+(?&lt;genericType&gt;&lt;[\w,\s&lt;&gt;]+&gt;)?\s+)(?&lt;name&gt;\w+(?&lt;genericNameType&gt;&lt;[\w,\s&lt;&gt;]+&gt;)?\s?)$(?&lt;params&gt;[\w\s,&lt;&gt;\[\]\:=\.]*)$(?&lt;ctorChain&gt;\s*\:\s*(?:base|this)\s*$(?&lt;ctorParams&gt;[\w\s,&lt;&gt;\[\]\:=\.]*)$)?[\w\s&lt;&gt;\:,\[\]]*(?:\{|;)"
					>
						<functionName>
							<funcNameExpr expr="(\w+(&lt;[\w,\s&lt;&gt;]+&gt;)?\s?)\(" />
							<funcNameExpr expr="(\w+(&lt;[\w,\s&lt;&gt;]+&gt;)?\s?)" />
						</functionName>
					</function>
				</classRange>
			</parser>

<parser
				displayName="Java"
				id         ="java_syntax"
			>
				<classRange
					mainExpr    ="(?x)                                          # Utilize inline comments (see `RegEx - Pattern Modifiers`)
							(?m)^[\t\x20]*                                      # leading whitespace
							(?:
								(?-i:
									abstract
								|	final
								|	native
								|	p(?:rivate|rotected|ublic)
								|	s(?:tatic|trictfp|ynchronized)
								|	transient
								|	volatile
								|	@[A-Za-z_]\w*                               # qualified identifier
									(?:                                         # consecutive names...
										\.                                      # ...are dot separated
										[A-Za-z_]\w*
									)*
								)
								\s+
							)*
							(?-i:class|enum|@?interface)
							\s+
							(?'DECLARATOR'
								(?'VALID_ID'                                    # valid identifier, use as subroutine
									\b(?!(?-i:
										a(?:bstract|ssert)
									|	b(?:oolean|reak|yte)
									|	c(?:ase|atch|har|lass|on(?:st|tinue))
									|	d(?:efault|o(?:uble)?)
									|	e(?:lse|num|xtends)
									|	f(?:inal(?:ly)?|loat|or)
									|	goto
									|	i(?:f|mp(?:lements|ort)|nstanceof|nt(?:erface)?)
									|	long
									|	n(?:ative|ew)
									|	p(?:ackage|rivate|rotected|ublic)
									|	return
									|	s(?:hort|tatic|trictfp|uper|witch|ynchronized)
									|	th(?:is|rows?)|tr(?:ansient|y)
									|	vo(?:id|latile)
									|	while
									)\b)                                        # keywords, not to be used as identifier
									[A-Za-z_]\w*                                # valid character combination for identifiers
								)
								(?:
									\s*\x3C                                     # start-of-template indicator...
									(?'GENERIC'                                 # ...match first generic, use as subroutine
										\s*
										(?:
											(?&amp;DECLARATOR)                  # use named generic
										|	\?                                  # or unknown
										)
										(?:                                     # optional type extension
											\s+(?-i:extends|super)
											\s+(?&amp;DECLARATOR)
											(?:                                 # multiple bounds...
												\s+\x26                         # ...are ampersand separated
												\s+(?&amp;DECLARATOR)
											)*
										)?
										(?:                                     # match consecutive generics objects...
											\s*,                                # ...are comma separated
											(?&amp;GENERIC)
										)?
									)
									\s*\x3E                                     # end-of-template indicator
								)?
								(?:                                             # package and|or nested classes...
									\.                                          # ...are dot separated
									(?&amp;DECLARATOR)
								)?
							)
							(?:                                                 # optional object extension
								\s+(?-i:extends)
								\s+(?&amp;DECLARATOR)
								(?:                                             # consecutive objects...
									\s*,                                        # ...are comma separated
									\s*(?&amp;DECLARATOR)
								)*
							)?
							(?:                                                 # optional object implementation
								\s+(?-i:implements)
								\s+(?&amp;DECLARATOR)
								(?:                                             # consecutive objects...
									\s*,                                        # ...are comma separated
									\s*(?&amp;DECLARATOR)
								)*
							)?
							\s*\{                                               # whatever, up till start-of-body indicator
						"
					openSymbole ="\{"
					closeSymbole="\}"
				>
					<className>
						<nameExpr expr="(?-i:class|enum|@?interface)\s+\K\w+(?:\s*\x3C.*?\x3E)?" />
					</className>
					<function
						mainExpr="(?x)                                          # Utilize inline comments (see `RegEx - Pattern Modifiers`)
								^[\t\x20]*                                      # leading whitespace
								(?:
									(?-i:
										abstract
									|	final
									|	native
									|	p(?:rivate|rotected|ublic)
									|	s(?:tatic|trictfp|ynchronized)
									|	transient
									|	volatile
									|	@[A-Za-z_]\w*                           # qualified identifier
										(?:                                     # consecutive names...
											\.                                  # ...are dot separated
											[A-Za-z_]\w*
										)*
									)
									\s+
								)*
								(?:
									\s*\x3C                                     # start-of-template indicator
									(?&amp;GENERIC)
									\s*\x3E                                     # end-of-template indicator
								)?
								\s*
								(?'DECLARATOR'
									[A-Za-z_]\w*                                # (parent) type name
									(?:                                         # consecutive sibling type names...
										\.                                      # ...are dot separated
										[A-Za-z_]\w*
									)*
									(?:
										\s*\x3C                                 # start-of-template indicator
										(?'GENERIC'                             # match first generic, use as subroutine
											\s*
											(?:
												(?&amp;DECLARATOR)              # use named generic
											|	\?                              # or unknown
											)
											(?:                                 # optional type extension
												\s+(?-i:extends|super)
												\s+(?&amp;DECLARATOR)
												(?:                             # multiple bounds...
													\s+\x26                     # ...are ampersand separated
													\s+(?&amp;DECLARATOR)
												)*
											)?
											(?:                                 # consecutive generics objects...
												\s*,                            # ...are comma separated
												(?&amp;GENERIC)
											)?
										)
										\s*\x3E                                 # end-of-template indicator
									)?
									(?:                                         # package and|or nested classes...
										\.                                      # ...are dot separated
										(?&amp;DECLARATOR)
									)?
									(?:                                         # optional compound type...
										\s*\[                                   # ...start-of-compound indicator
										\s*\]                                   # ...end-of-compound indicator
									)*
								)
								\s+
								(?'VALID_ID'                                    # valid identifier, use as subroutine
									\b(?!(?-i:
										a(?:bstract|ssert)
									|	b(?:oolean|reak|yte)
									|	c(?:ase|atch|har|lass|on(?:st|tinue))
									|	d(?:efault|o(?:uble)?)
									|	e(?:lse|num|xtends)
									|	f(?:inal(?:ly)?|loat|or)
									|	goto
									|	i(?:f|mp(?:lements|ort)|nstanceof|nt(?:erface)?)
									|	long
									|	n(?:ative|ew)
									|	p(?:ackage|rivate|rotected|ublic)
									|	return
									|	s(?:hort|tatic|trictfp|uper|witch|ynchronized)
									|	th(?:is|rows?)|tr(?:ansient|y)
									|	vo(?:id|latile)
									|	while
									)\b)                                        # keywords, not to be used as identifier
									[A-Za-z_]\w*                                # valid character combination for identifiers
								)
								\s*$                                           # start-of-parameters indicator
								(?'PARAMETER'                                   # match first parameter, use as subroutine
									\s*(?-i:final\s+)?
									(?&amp;DECLARATOR)
									\s+(?&amp;VALID_ID)                         # parameter name
									(?:                                         # consecutive parameters...
										\s*,                                    # ...are comma separated
										(?&amp;PARAMETER)
									)?
								)?
								$                                              # end-of-parameters indicator
								(?:                                             # optional exceptions
									\s*(?-i:throws)
									\s+(?&amp;VALID_ID)                         # first exception name
									(?:                                         # consecutive exception names...
										\s*,                                    # ...are comma separated
										\s*(?&amp;VALID_ID)
									)*
								)?
								[^{;]*\{                                        # start-of-function-body indicator
							"
					>
						<functionName>
							<funcNameExpr expr="\w+(?=\s*\()" />
						</functionName>
					</function>
				</classRange>
			</parser>

<parser
				displayName="AutoIt3"
				id         ="autoit3_function"
				commentExpr="(?x)                                               # Utilize inline comments (see `RegEx - Pattern Modifiers`)
								(?is:\x23cs.*?\x23ce)                           # Multi Line Comment
							|	(?m-s:^\h*;.*?$)                                # Single Line Comment
							"
			>
				<function
					mainExpr="(?x)                                              # Utilize inline comments (see `RegEx - Pattern Modifiers`)
							(?m)^\h*                                            # optional leading whitespace
							(?i:FUNC\s+)                                        # start-of-function indicator
							\K                                                  # keep the text matched so far, out of the overall match
							[A-Za-z_]\w*                                        # valid character combination for identifiers
							\s*$[^()]*?$                                      # parentheses required, parameters optional
						"
				>
					
					<functionName>
						<nameExpr expr="[A-Za-z_]\w*" />
					</functionName>
				</function>
			</parser>

<parser
				displayName="KRL"
				id         ="krl_function"
				commentExpr="(?x)                                               # Utilize inline comments (see `RegEx - Pattern Modifiers`)
								(?m-s:;.*$)                                     # Single Line Comment
							"
			>
				<function
					mainExpr="(?x)                                              # Utilize inline comments (see `RegEx - Pattern Modifiers`)
							(?i:
								(?:GLOBAL\h+)?
								DEF                                             # start-of-procedure indicator, possible extended to...
								(?:
									FCT                                         # ...start-of-function indicator
									\h+
									(?:BOOL|CHAR|INT|REAL|(?&amp;VALID_ID))     # returning a primitive type or a user-defined-type...
									(?:                                         # ...optionally as an array
										\h*\[
										\h*(?:\d+|\x27(?:H[0-9A-Fa-f]+|B[01]+)\x27)?
										\h*\]
									)?
								)?
							)
							\h+
							\K                                                  # keep the text matched so far, out of the overall match
							(?'VALID_ID'                                        # valid identifier, use as subroutine
								\b(?!(?i:
									AN(?:D|IN|OUT)
								|	B(?:OOL|RAKE|_(?:AND|EXOR|NOT|OR))
								|	C(?:ASE|AST_(?:FROM|TO)|HAR|IRC(?:_REL)?|ON(?:ST|TINUE)|_(?:DIS|ORI|PTP|VEL))
								|	D(?:ECL|EF(?:AULT|DAT|FCT)|ELAY|O)
								|	E(?:LSE|ND(?:DAT|FCT|FOR|IF|LOOP|SWITCH|WHILE)?|NUM|X(?:IT|OR|T(?:FCT)?))
								|	F(?:ALSE|OR)
								|	G(?:LOBAL|OTO)
								|	HALT
								|	I(?:[FS]|MPORT|NT(?:ERRUPT)?)
								|	L(?:IN(?:_REL)?|OOP)
								|	M(?:AXI|INI)MUM
								|	NOT
								|	OR
								|	P(?:RIO|TP(?:_REL)?|UBLIC)
								|	RE(?:AL|PEAT|SUME|TURN)
								|	S(?:EC|IGNAL|TRUC|WITCH)
								|	T(?:HEN|O|RIGGER|RUE)
								|	UNTIL
								|	W(?:AIT|HEN|HILE)
								)\b)                                            # keywords, not to be used as identifier
								[$A-Za-z_\x7F-\xFF][$\w\x7F-\xFF]{0,23}         # valid character combination for identifiers
							)
							\h*$[^)]*$
						"
				>
					
					<functionName>
						<nameExpr expr="[$A-Za-z_\x7F-\xFF][$\w\x7F-\xFF]{0,23}" />
					</functionName>
				</function>
			</parser>

<parser
				displayName="Sinumerik"
				id         ="sinumerik_function"
				commentExpr="(?m-s:;(?!\$PATH).*?$)"
			>
				<function
					mainExpr="(?m)^%_N_\K[A-Za-z_]\w*"
				/>
			</parser>

<parser
				displayName="UniVerse BASIC"
				id         ="universe_basic"
				commentExpr="(?x)                                               # Utilize inline comments (see `RegEx - Pattern Modifiers`)
								(?m-s:
									(?:^|;)                                     # at start-of-line or after end-of-statement
									\h*                                         # optional leading whitespace
									(?-i:REM\b|\x24\x2A|[\x21\x2A])             # Single Line Comment 1..4
									.*$                                         # whatever, until end-of-line
								)
							|	(?:\x22[^\x22\r\n]*\x22)                        # String Literal - Double Quoted
							|	(?:\x27[^\x27\r\n]*\x27)                        # String Literal - Single Quoted
							|	(?:\x5C[^\x5C\r\n]*\x5C)                        # String Literal - Backslash Quoted
							"
			>
				<function
					mainExpr="(?x)                                              # Utilize inline comments (see `RegEx - Pattern Modifiers`)
							(?m-i)^                                             # case-sensitive, NO leading whitespace
							(?:
								\d+\b(?=:?)                                     # completely numeric label, colon optional + discarded
							|	[A-Za-z_][\w.$%]*(?=:)                          # alphanumeric label, colon required + discarded
							)
						"
				/>
			</parser>

</parsers>
	</functionList>
</NotepadPlus>

${this.title}

Code Editor : functionList.xml