tyler.durden
/
notepad-plus-plus
mirror of https://github.com/notepad-plus-plus/notepad-plus-plus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Split functionList.xml into multifile in "functionList" Folder 

New "functionList" will be added beside of notepad++.exe or "%APPDATA%\Notepad++\", according the installation mode. If the portable package is used, after removing "doLocalConf.xml", the "functionList" folder should be copied manually from Notepad++ installed directory to "%APPDATA%\Notepad++\" to make function list work again.

All splited files are localized in this folder with the explicit language name.

"overrideMap.xml" is optional for overriding the default functionList parse rule files, and for adding UDL parse rule files.

Close #4896
This commit is contained in:
Don HO 2020-10-11 02:24:15 +02:00
parent 0a20939334
commit c0c070abaf
No known key found for this signature in database
GPG Key ID: 6C429F1D8D84F46E
44 changed files with 2557 additions and 2057 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -69,6 +69,7 @@ PowerEditor/bin/backup/
PowerEditor/bin/localization/
PowerEditor/bin/plugins/
PowerEditor/bin/updater/
PowerEditor/bin/functionList/
PowerEditor/bin64/
PowerEditor/bin/themes/
PowerEditor/installer/bin/wingup/

12
PowerEditor/Test/FunctionList/bash/unitTest
View File

@ -1,5 +1,8 @@
#!/bin/sh
# bash parser should be fixed so we can use the content of "unitTest.expected.result.correct".
# Check the bug here:
# https://github.com/notepad-plus-plus/notepad-plus-plus/issues/9019
setenv()
@ -117,7 +120,6 @@ LIBIFSNAME="/QSYS.LIB/${TARGETLIB}.LIB"
# exit 0 (succeeds) if some action has to be taken, else 1.
action_needed()
{
[ ! -e "${1}" ] && return 0
[ "${2}" ] || return 1
@ -132,9 +134,7 @@ action_needed()
# - Absolute
# - No . or .. component.
canonicalize_path()
{
canonicalize_path(){
if expr "${1}" : '^/' > /dev/null
then P="${1}"
else P="`pwd`/${1}"
@ -167,9 +167,7 @@ canonicalize_path()
# As side effect, append the module name to variable MODULES.
# Set LINK to "YES" if the module has been compiled.
make_module()
{
make_module() {
MODULES="${MODULES} ${1}"
MODIFSNAME="${LIBIFSNAME}/${1}.MODULE"
action_needed "${MODIFSNAME}" "${2}" || return 0;

117
PowerEditor/Test/FunctionList/functionList.xsd
View File

@ -1,117 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<xs:schema
attributeFormDefault="unqualified"
elementFormDefault="qualified"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
>
<xs:element name="NotepadPlus" type="NotepadPlusType" />
<xs:simpleType name="extType">
<xs:restriction base="xs:string">
<xs:pattern value="\.([A-Za-z0-9_~!@#$%^&amp;+`=\-\(\)\{\}\[\];',])+(\.([A-Za-z0-9_~!@#$%^&amp;+`=\-\(\)\{\}\[\];',])+)*" />
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="versionType">
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{1,5}(\.[0-9]{1,5}){1,3}|[0-9]{4}[\-/]?[0-9]{2}[\-/]?[0-9]{2}" />
</xs:restriction>
</xs:simpleType>
<xs:complexType name="associationType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="id" type="xs:string" use="required" />
<xs:attribute name="langID" type="xs:byte" use="optional" />
<xs:attribute name="userDefinedLangName" type="xs:string" use="optional" />
<xs:attribute name="ext" type="extType" use="optional" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="associationMapType">
<xs:sequence>
<xs:element name="association" type="associationType" minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="nameExprType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="expr" type="xs:string" use="optional" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="classNameType">
<xs:sequence>
<xs:element name="nameExpr" type="nameExprType" minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="funcNameExprType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="expr" type="xs:string" use="optional" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="functionNameType">
<xs:sequence>
<xs:element name="funcNameExpr" type="funcNameExprType" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="nameExpr" type="nameExprType" minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="functionType" mixed="true">
<xs:sequence>
<xs:element name="functionName" type="functionNameType" minOccurs="0" />
<xs:element name="className" type="classNameType" minOccurs="0" />
</xs:sequence>
<xs:attribute name="mainExpr" type="xs:string" use="required"/>
</xs:complexType>
<xs:complexType name="classRangeType">
<xs:sequence>
<xs:element name="className" type="classNameType" />
<xs:element name="function" type="functionType" minOccurs="0" />
</xs:sequence>
<xs:attribute name="mainExpr" type="xs:string" use="required"/>
<xs:attribute name="openSymbole" type="xs:string" use="optional"/>
<xs:attribute name="closeSymbole" type="xs:string" use="optional"/>
<xs:attribute name="openSymbol" type="xs:string" use="optional"/>
<xs:attribute name="closeSymbol" type="xs:string" use="optional"/>
</xs:complexType>
<xs:complexType name="parserType" mixed="true">
<xs:sequence>
<xs:element name="classRange" type="classRangeType" minOccurs="0" />
<xs:element name="function" type="functionType" minOccurs="0" />
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required"/>
<xs:attribute name="displayName" type="xs:string" use="optional"/>
<xs:attribute name="commentExpr" type="xs:string" use="optional"/>
<xs:attribute name="version" type="versionType" use="optional"/>
</xs:complexType>
<xs:complexType name="parsersType" mixed="true">
<xs:sequence>
<xs:element name="parser" type="parserType" minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="functionListType">
<xs:sequence>
<xs:element name="associationMap" type="associationMapType" />
<xs:element name="parsers" type="parsersType" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="NotepadPlusType">
<xs:sequence>
<xs:element name="functionList" type="functionListType" />
</xs:sequence>
</xs:complexType>
</xs:schema>

6
PowerEditor/Test/FunctionList/unitTest.ps1
View File

@ -3,8 +3,10 @@
# .\unit-test.ps1 RELATIVE_PATH LANG
# It return 0 if result is OK
# -1 if result is KO
# -2 if exception
# 1 if unitTest file not found
$testRoot = ".\"
$dirName=$args[0]
@ -35,5 +37,5 @@ Try {
}
Catch
{
return -1
}
return -2
}

20
PowerEditor/Test/FunctionList/unitTestLauncher.ps1
View File

@ -6,7 +6,7 @@ Foreach-Object {
$dirName = (Get-Item $testRoot$_).Name
$langName = $dirName
$sw = [Diagnostics.Stopwatch]::StartNew()
$result = &.\unitTest.ps1 $dirName $langName
$result = & ".\unitTest.ps1" $dirName $langName
$sw.Stop()
"Test: " + $sw.Elapsed.TotalMilliseconds + " ms"
@ -19,11 +19,21 @@ Foreach-Object {
{
"$dirName ... unitTest file not found. Test skipped."
}
else
elseif ($result -eq -1)
{
"$dirName ... KO"
""
"There are some problems in your functionList.xml"
"result = $result"
"There are some problems in your $dirName.xml"
exit -1
}
elseif ($result -eq -2)
{
"Exception!"
exit -1
}
else
{
"It should not happen - check your script."
exit -1
}
@ -48,7 +58,7 @@ Foreach-Object {
{
"$dirName-$subDirName ... KO"
""
"There are some problems in your functionList.xml"
"There are some problems in your $dirName.xml"
exit -1
}
}

2
PowerEditor/gcc/makefile
View File

@ -217,7 +217,7 @@ SRC_RES = ./resources.rc
OBJ_RES = $(patsubst %.rc,%.res,$(SRC_RES))
# XML config files
SRC_XMLCFG = $(addprefix $(NPP_DIR)/,langs.model.xml stylers.model.xml shortcuts.xml functionList.xml contextMenu.xml)
SRC_XMLCFG = $(addprefix $(NPP_DIR)/,langs.model.xml stylers.model.xml shortcuts.xml contextMenu.xml)
DST_XMLCFG = $(subst $(NPP_DIR),../bin,$(SRC_XMLCFG))
DEPS = $(patsubst %.o,%.d,$(OBJS))

30
PowerEditor/installer/functionList/asm.xml Normal file
View File

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ==================================================== [ Assembly ] -->
<parser
displayName="Assembly"
id ="assembly_subroutine"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s:;.*$) # Single Line Comment
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m)^\h* # optional leading whitespace
\K # keep the text matched so far, out of the overall match
[A-Za-z_$][\w$]* # valid character combination for labels
(?=:) # up till the colon
"
/>
</parser>
</functionList>
</NotepadPlus>

41
PowerEditor/installer/functionList/autoit.xml Normal file
View File

@ -0,0 +1,41 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ===================================================== [ AutoIt3 ] -->
<!--
| Based on:
| https://sourceforge.net/p/notepad-plus/discussion/331753/thread/5d9bb881/#e86e
\-->
<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
"
>
<!-- comment out the following node to display the function with its parameters -->
<functionName>
<nameExpr expr="[A-Za-z_]\w*" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

183
PowerEditor/installer/functionList/baanc.xml Normal file
View File

@ -0,0 +1,183 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================= [ BaanC ] -->
<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Based on:
| https://notepad-plus-plus.org/community/topic/14494/functionlist-classrange-question
|
| Note(s):
| 1. Boost::Regex 1.58-1.59 do not correctly handle quantifiers on subroutine calls
| therefore the additional non-capturing group i.e. "(?:(?&amp;COMMENT))?" instead
| of simply "(?&amp;COMMENT)?"
\-->
<parser
displayName="BaanC Sections"
id ="baanc_section"
>
<classRange
mainExpr="(?x) # free-spacing (see `RegEx - Pattern Modifiers`)
(?im) # case-insensitive, ^ and $ match at line breaks
(?(DEFINE) # definition of sub-routines
(?'SECTION'
^\h* # optional leading whitespace at start-of-line
(?: # known section names
(?:after|before)\.(?:report\.\d+|\w+(?:\.\w+)*\.\d+)
| (?:field|zoom\.from)\.(?:all|other|\w+(?:\.\w+)*)
| (?:footer|group|header)\.\d+
| choice\.\w+(?:\.\w+)*
| detail\.\d+
| form\.(?:all|other|\d+)
| functions
| main\.table\.io
): # end-of-section-header indicator
)
(?'SECTION_EMPTY'
^\h* # optional leading whitespace at start-of-line
(?: # known `empty` section names
after\.(?:form\.read|program|receive\.data|update\.db\.commit)
| before\.(?:(?:display|new)\.object|program)
| declaration
| on\.(?:display\.total\.line|error)
): # end-of-section-header indicator
)
)
(?&amp;SECTION) # section header
(?s:.*?) # whatever,
(?= # ...up till
\s*
(?:
(?&amp;SECTION) # ...next section header,
| (?&amp;SECTION_EMPTY) # ...next `empty` section header
| \Z # ...or end-of-text
)
)
"
>
<className>
<nameExpr expr="^\h*\K\w+(?:\.\w+)*:" />
</className>
<function
mainExpr="(?x) # free-spacing (see `RegEx - Pattern Modifiers`)
(?im) # case-insensitive, ^ and $ match at line breaks
(?(DEFINE) # definition of sub-routines
(?'COMMENT'
\s*\x7C[^\r\n]* # trailing comment
(?: # optional subsequent comment
(?:\r?\n|\n?\r) # - mandatory line-break
\s*\x7C[^\r\n]* # - `trailing` comment
)*
)
)
^\h* # optional leading whitespace at start-of-line
(?:
\K # discard text matched so far
(?: # known sub-section names
after\.(?:choice|d(?:elete|isplay)|f(?:ield|orm)|group|input|layout|re(?:ad|write)|skip\.(?:delete|(?:re)?write)|write|zoom)
| before\.(?:ch(?:ecks|oice)|d(?:elete|isplay)|f(?:ield|orm)|group|input|layout|print|re(?:ad|write)|write|zoom)
| check\.input
| domain\.error
| init\.(?:f(?:ield|orm)|group)
| on\.(?:choice|e(?:ntry|xit)|input)
| read\.view
| ref\.(?:display|input)
| selection\.filter
| when\.field\.changes
): # end-of-sub-section-header indicator
|
function # keyword, start-of-function-header indicator
(?:(?&amp;COMMENT))? # optional `embedded` comment
(?: # optional storage-class specifier
\s+extern
(?:(?&amp;COMMENT))? # ...with optional `embedded` comment
)?
(?: # optional function type specifier
\s+(?:
boolean
| double
| long
| string
| void
| domain
(?:(?&amp;COMMENT))? # ...with optional `embedded` comment
\s+\w+(?:\.\w+)*
)
(?:(?&amp;COMMENT))? # ...with optional `embedded` comment
)?
\s+
\K # discard text matched so far
\w+(?:\.\w+)* # function identifier
(?:(?&amp;COMMENT)(?:\r?\n|\n?\r))? # optional `embedded` comment
\s*\( # start-of-parameter-list indicator
)
"
>
<functionName>
<funcNameExpr expr="\w+(?:\.\w+)*(?:\h*:)?" />
</functionName>
</function>
</classRange>
<function
mainExpr="(?x) # free-spacing (see `RegEx - Pattern Modifiers`)
(?im) # case-insensitive, ^ and $ match at line breaks
(?(DEFINE) # definition of sub-routines
(?'COMMENT'
\s*\x7C[^\r\n]* # trailing comment
(?: # optional subsequent comment
(?:\r?\n|\n?\r) # - mandatory line-break
\s*\x7C[^\r\n]* # - `trailing` comment
)*
)
)
^\h* # optional leading whitespace at start-of-line
(?:
\K # discard text matched so far
(?: # known `empty` section names
after\.(?:form\.read|program|receive\.data|update\.db\.commit)
| before\.(?:display\.object|new\.object|program)
| declaration
| on\.(?:display\.total\.line|error)
): # end-of-section-header indicator
|
function # keyword, start-of-function-header indicator
(?:(?&amp;COMMENT))? # optional `embedded` comment
(?: # optional storage-class specifier
\s+extern
(?:(?&amp;COMMENT))? # ...with optional `embedded` comment
)?
(?: # optional function type specifier
\s+(?:
boolean
| double
| long
| string
| void
| domain
(?:(?&amp;COMMENT))? # ...with optional `embedded` comment
\s+\w+(?:\.\w+)*
)
(?:(?&amp;COMMENT))? # ...with optional `embedded` comment
)?
\s+
\K # discard text matched so far
\w+(?:\.\w+)* # function identifier
(?:(?&amp;COMMENT)(?:\r?\n|\n?\r))? # optional `embedded` comment
\s*\( # start-of-parameter-list indicator
)
"
>
<functionName>
<nameExpr expr="\w+(?:\.\w+)*(?:\h*:)?" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

67
PowerEditor/installer/functionList/bash.xml Normal file
View File

@ -0,0 +1,67 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================== [ Bash ] -->
<!-- BASH - Bourne-Again Shell -->
<parser
displayName="Bash"
id ="bash_function"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?-s:(?:^\x23[^!]|^\h*\x23|\h+\x23).*$) # Single Line Comment
| (?s:\x22(?:[^\x22\x5C]|\x5C.)*\x22) # String Literal - Double Quoted
| (?s:\x27[^\x27]*\x27) # String Literal - Single Quoted
| (?s: # Here Document (Type 1) and Here String
\x3C{2,3}\h*(?'HD1ID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*\b)[^\r\n]*\R
(?s:.*?)
\R\k'HD1ID' # close with exactly the same identifier, in the first column
)
| (?s: # Here Document (Type 2)
\x3C{2}-\h*(?'HD2ID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*\b)[^\r\n]*\R
(?s:.*?)
\R\h*\k'HD2ID' # close with exactly the same identifier
)
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m)^\h* # optional leading whitespace
(?:
(?-i:function\s+)
(?'VALID_ID' # valid identifier, use as subroutine
\b(?!(?-i:
do(?:ne)?
| el(?:if|se)|esac
| f(?:i|or|unction)
| i[fn]
| select
| t(?:hen|ime)
| until
| while
)\b) # keywords, not to be used as identifier
[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]* # valid character combination for identifiers
)
(?:\s*\([^)]*?\))? # parentheses and parameters optional
|
(?&amp;VALID_ID)
\s*\([^)]*?\) # parentheses required, parameters optional
)
[^{;]*?\{ # no semi-colon until start of body
"
>
<functionName>
<nameExpr expr="\b(?!function\b)\w+(?:\s*\([^)]*\))?" />
<!-- comment out the following node to display the function with its parameters -->
<nameExpr expr="\w+(?=\b)" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

35
PowerEditor/installer/functionList/batch.xml Normal file
View File

@ -0,0 +1,35 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ================================ [ Batch / Command Shell Script ] -->
<parser
displayName="Batch / Command Shell Script"
id ="batch_label"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s:(?i:REM)(?:\h.+)?$) # Single Line Comment 1
| (?m-s::{2}.*$) # Single Line Comment 2
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s) # enforce strict line by line search
^ # label starts at the beginning of a line,...
\h* # ...can be preceded by blank characters and
: # ...starts with a colon
\K # keep the text matched so far, out of the overall match
\w # a label name has to start with a word character,...
[\w.\-]+ # ...the remainder of the name can contain dots and minus signs and
\b # ...ends at a word boundary i.e. discard any trailing characters
"
/>
</parser>
</functionList>
</NotepadPlus>

112
PowerEditor/installer/functionList/c.xml Normal file
View File

@ -0,0 +1,112 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- =========================================================== [ C ] -->
<parser
displayName="C"
id ="c_function"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?s:\x2F\x2A.*?\x2A\x2F) # Multi Line Comment
| (?m-s:\x2F{2}.*$) # Single Line Comment
| (?s:\x22(?:[^\x22\x5C]|\x5C.)*\x22) # String Literal - Double Quoted
| (?s:\x27(?:[^\x27\x5C]|\x5C.)*\x27) # String Literal - Single Quoted
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?: # Declaration specifiers
\b
(?:
(?-i:auto|register|static|extern|typedef) # Storage class specifier
| (?: # Type specifier
(?-i:void|char|short|int|long|float|double|(?:un)?signed)
| (?-i:struct|union|enum)
\s+
(?&amp;VALID_ID) # Struct, Union or Enum Specifier (simplified)
| (?&amp;VALID_ID) # Type-definition name
)
| (?'TYPE_QUALIFIER'(?-i:const|volatile))
)
\b
\s*
)*
(?'DECLARATOR'
(?'POINTER'
\*
\s*
(?:
\b(?&amp;TYPE_QUALIFIER)\b
\s*
)*
(?:(?&amp;POINTER))? # Boost::Regex 1.58-1.59 do not correctly handle quantifiers on subroutine calls
)?
(?: # 'DIRECT_DECLARATOR'
\s*
(?'VALID_ID' # valid identifier, use as subroutine
\b(?!(?-i:
auto
| break
| c(?:ase|har|on(?:st|ntinue))
| d(?:efault|o(?:uble)?)
| e(?:lse|num|xtern)
| f(?:loat|or)
| goto
| i(?:f|n(?:t|line))
| long
| while
| re(?:gister|strict|turn)
| s(?:hort|i(?:gned|zeof)|t(?:atic|ruct)|witch)
| typedef
| un(?:ion|signed)
| vo(?:id|latile)
| _(?:
A(?:lignas|lignof|tomic)
| Bool
| Complex
| Generic
| Imaginary
| Noreturn
| Static_assert
| Thread_local
)
)\b) # keywords, not to be used as identifier
[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]* # valid character combination for identifiers
)
| \s*\(
(?&amp;DECLARATOR)
\)
| \s*(?&amp;VALID_ID)
\s*\[
[^[\];{]*?
\]
| \s*(?&amp;VALID_ID)
\s*\(
[^();{]*?
\)
)
\s*
)
(?=\{) # start of function body
"
>
<functionName>
<nameExpr expr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*
\s*\( # start of parameters
(?s:.*?) # whatever, until...
\) # end of parameters
" />
<!-- comment out the following node to display the method with its parameters -->
<!-- <nameExpr expr="[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*" /> -->
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

44
PowerEditor/installer/functionList/cobol-free.xml Normal file
View File

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- Variant for COBOL free-form reference format -->
<parser id="cobol_section_free" displayName="COBOL free-form reference format">
<!-- working comment Expression:
commentExpr="(?m-s)(?:\*&gt;).*$"
cannot be used because problems with comment boundaries
in current FunctionList implementation, for details see
https://sourceforge.net/p/notepad-plus/patches/597/
-->
<!-- Variant with paragraphs (don't work with comment lines
before section/paragraph header, can be activated when
comment boundaries work and the commentExpr is used) -->
<!--
<function
mainExpr="(?m-s)(?<=\.)\s*(?!exit\s)[\w_-]+(\s+section(\s*|(\s+[\w_-]+)?))(?=\.)"
"
>
<functionName>
<nameExpr expr="(?m-s)(?<=[\s\.])[\w_-]+(\s*section\s*([\w_-]+)?)?"/>
</functionName>
</function>
-->
<!-- Variant without paragraphs (works with comment lines before section header) -->
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
[\s\.](?!exit\s)[\w_-]+\s+section(\s*|(\s+[\w_-]+)?)(?=\.) # all names that come before `section` but not `exit section`
"
>
<functionName>
<nameExpr expr="[\w_-]+\s*section"/>
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

27
PowerEditor/installer/functionList/cobol.xml Normal file
View File

@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- Variant for COBOL fixed-form reference format -->
<parser id="cobol_section_fixed" displayName="COBOL fixed-form reference format">
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s)(^.{6}[ D]) # ignore first 6 columns, 7 must be empty or D (debug-line)
([\t ]{0,3}) # don't start after column 12
(?!exit\s)[\w_-]+(\.|((?'seps'([\t ]|\*&gt;.*|([\n\r]+(.{6}([ D]|\*.*)|.{0,6}$)))+)section(\.|((?&amp;seps)(\.|[\w_-]+\.)))))
# all names that come before `section` but not `exit section`
"
>
<functionName>
<nameExpr expr="[\w_-]+((?=\.)|((?'seps'([\t ]|\*&gt;.*|([\n\r]+(.{6}([ D]|\*.*)|.{0,6}$)))+)section((?=\.)|(?&amp;seps)((?=\.)|[\w_-]+(?=\.)))))"/>
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

304
PowerEditor/installer/functionList/cpp.xml Normal file
View File

@ -0,0 +1,304 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================================= [ C++ ] -->
<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>

43
PowerEditor/installer/functionList/cs.xml Normal file
View File

@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================================== [ C# ] -->
<!--
| Based on:
| http://sourceforge.net/p/notepad-plus/patches/613/
\-->
<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>
</functionList>
</NotepadPlus>

30
PowerEditor/installer/functionList/ini.xml Normal file
View File

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================= [ Initialisation File ] -->
<!-- File format used for: .INF / .INI / .REG / .editorconfig -->
<parser
displayName="INI Section"
id ="ini_section"
commentExpr="(?x)
(?m-s:[;\#].*$) # Single Line Comment
"
>
<function
mainExpr="^\h*[\[&quot;][\w*.;\x20()\-]+[&quot;\]]"
>
<functionName>
<nameExpr expr="[^[\]&quot;]*" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

104
PowerEditor/installer/functionList/inno.xml Normal file
View File

@ -0,0 +1,104 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ================================================== [ Inno Setup ] -->
<parser
displayName="Inno Setup"
id ="innosetup_syntax"
>
<classRange
mainExpr ="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?ms)
(?'SECTION_HEADER'
^ # header starts at beginning of a line
\[ # start of section header
(?-i:Code) # `Code` section name
] # end of section header
)
.*? # whatever, up till...
(?= # ...next valid section header or...
^ # +-- header starts at beginning of a line
\[ # +-- start-of-header indicator
(?-i:
Components|(?:Custom)?Messages
| Dirs
| Files
| I(?:cons|nstallDelete)
| Languages
| R(?:egistry|un)
| Setup
| T(?:asks|ypes)
| Uninstall(?:Delete|Run)
) # +-- valid section name
] # \-- end-of-header indicator
| \Z # ...end-of-file
)
"
>
<className>
<nameExpr expr="^\[\K[^\h\]]+(?=])" />
</className>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s)^\h* # optional leading whitespace
(?i:FUNCTION\h+)
(?'VALID_ID'
[A-Za-z_]\w*
)
\s*\( # start-of-parameter-list indicator
[^()]* # parameter list
\s*\) # end-of-parameter-list indicator
\s*: # type indicator
\s*[A-Za-z_]\w* # type identifier
\s*; # end-of-statement indicator
"
>
<functionName>
<funcNameExpr expr="(?i:FUNCTION\h+)\K[A-Za-z_]\w*\s*\([^()]*\)" />
<!-- comment out the following node to display the method with its parameters -->
<funcNameExpr expr="[A-Za-z_]\w*" />
</functionName>
</function>
</classRange>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?ms)
(?'SECTION_HEADER'
^ # header starts at beginning of a line
\[ # start-of-header indicator
(?-i:
Components|(?:Custom)?Messages
| Dirs
| Files
| I(?:cons|nstallDelete)
| Languages
| R(?:egistry|un)
| Setup
| T(?:asks|ypes)
| Uninstall(?:Delete|Run)
) # valid section name
] # end-of-header indicator
)
.*? # whatever, up till...
(?=
(?&amp;SECTION_HEADER) # ...next valid section header,...
| ^\[(?-i:Code)] # ...`Code` section header or...
| \Z # ...end-of-file
)
"
>
<functionName>
<nameExpr expr="^\[\K[^\]]+(?=])" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

232
PowerEditor/installer/functionList/java.xml Normal file
View File

@ -0,0 +1,232 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================== [ Java ] -->
<!--
| Based on:
| https://notepad-plus-plus.org/community/topic/12691/function-list-with-java-problems
\-->
<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>
</functionList>
</NotepadPlus>

32
PowerEditor/installer/functionList/javascript.js.xml Normal file
View File

@ -0,0 +1,32 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ================================================ [ JavaScript ] -->
<parser
displayName="JavaScript"
id ="javascript_function"
commentExpr="(?s:/\*.*?\*/)|(?m-s://.*?$)"
>
<function
mainExpr="((^|\s+|[;\}\.])([A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*\s*[=:]|^|[\s;\}]+)\s*function(\s+[A-Za-z_$][\w$]*)?\s*\([^\)\(]*\)[\n\s]*\{"
>
<functionName>
<nameExpr expr="[A-Za-z_$][\w$]*\s*[=:]|[A-Za-z_$][\w$]*\s*\(" />
<nameExpr expr="[A-Za-z_$][\w$]*" />
</functionName>
<className>
<nameExpr expr="([A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*\." />
<nameExpr expr="([A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*" />
</className>
</function>
</parser>
</functionList>
</NotepadPlus>

76
PowerEditor/installer/functionList/krl.xml Normal file
View File

@ -0,0 +1,76 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================================= [ KRL ] -->
<!-- KRL - KUKA Robot Language -->
<!--
| https://notepad-plus-plus.org/community/topic/12264/function-list-for-new-language
\-->
<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*\([^)]*\)
"
>
<!-- comment out the following node to display the method with its parameters -->
<functionName>
<nameExpr expr="[$A-Za-z_\x7F-\xFF][$\w\x7F-\xFF]{0,23}" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

146
PowerEditor/installer/functionList/nsis.xml Normal file
View File

@ -0,0 +1,146 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================== [ NSIS ] -->
<!-- NSIS - Nullsoft Scriptable Install System -->
<parser
displayName="NSIS"
id ="nsis_syntax"
>
<classRange
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
\b(?-i:SectionGroup)\b # open indicator
(?s:.*?)
\b(?-i:SectionGroupEnd)\b # close indicator
"
>
<className>
<nameExpr expr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s)
SectionGroup\h+(?-i:/e\h+)? # start indicator and its optional switch
\K # keep the text matched so far, out of the overall match
.+$ # whatever, till end-of-line
"
/>
<nameExpr expr="[^\r\n\x22]*" />
</className>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m)
^(?'INDENT'\h*) # optional leading whitespace at start-of-line
(?:
(?-i:!macro)
\h+ # required whitespace separator
\K # keep the text matched so far, out of the overall match
[^\r\n]*$ # whatever, until end-of-line
|
(?'TAG'(?-i:Function|PageEx|Section))
\h+ # required whitespace separator
(?-i:/o\h+)? # optional switch
\K # keep the text matched so far, out of the overall match
(?s:
.*? # whatever,
(?= # up till...
^\k'INDENT' # ...equal indent at start-of-line for...
\k'TAG'End\b # ...matching close indicator
)
)
|
\x24\x7B # start-of-open-element indicator
(?'ID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)
\x7D # end-of-open-element indicator
\h+ # required whitespace separator
(?-i:/o\h+)? # optional switch
\K # keep the text matched so far, out of the overall match
(?s:
.*? # whatever,
(?= # up till...
^\k'INDENT' # ...equal indent at start-of-line for...
\x24\x7B\k'ID'End\x7D # ...matching close indicator
)
)
)
"
>
<functionName>
<funcNameExpr expr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m)
[^\r\n]+? # whatever,
(?= # up till...
\h* # ...optional whitespace and...
(?:
\x2F\x2A # ...start of multi line comment or...
| [\x23;] # ...start of single line comment or...
| $ # ...end-of-line
)
)
"
/>
</functionName>
</function>
</classRange>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m)
^(?'INDENT'\h*) # optional leading whitespace at start-of-line
(?:
(?-i:!macro)
\h+ # required whitespace separator
\K # keep the text matched so far, out of the overall match
[^\r\n]*$ # whatever, until end-of-line
|
(?'TAG'(?-i:Function|PageEx|Section))
\h+ # required whitespace separator
(?-i:/o\h+)? # optional switch
\K # keep the text matched so far, out of the overall match
(?s:
.*? # whatever,
(?= # up till...
^\k'INDENT' # ...equal indent at start-of-line for...
\k'TAG'End\b # ...matching close indicator
)
)
|
\x24\x7B # start-of-open-element indicator
(?'ID'[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)
\x7D # end-of-open-element indicator
\h+ # required whitespace separator
(?-i:/o\h+)? # optional switch
\K # keep the text matched so far, out of the overall match
(?s:
.*? # whatever,
(?= # up till...
^\k'INDENT' # ...equal indent at start-of-line for...
\x24\x7B\k'ID'End\x7D # ...matching close indicator
)
)
)
"
>
<functionName>
<nameExpr expr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m)
[^\r\n]+? # whatever,
(?= # up till...
\h* # ...optional whitespace and...
(?:
\x2F\x2A # ...start of multi line comment or...
| [\x23;] # ...start of single line comment or...
| $ # ...end-of-line
)
)
"
/>
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

132
PowerEditor/installer/functionList/overrideMap.xml Normal file
View File

@ -0,0 +1,132 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<associationMap>
<!--
This file is optional (can be removed).
Each functionlist parse rule links to a language ID ("langID").
The "id" is the parse rule's default file name, but users can override it.
Here are the default value they are using:
<association id= "php.xml" langID= "1" />
<association id= "c.xml" langID= "2" />
<association id= "cpp.xml" langID= "3" /> (C++)
<association id= "cs.xml" langID= "4" /> (C#)
<association id= "objc.xml" langID= "5" /> (Obective-C)
<association id= "java.xml" langID= "6" />
<association id= "rc.xml" langID= "7" /> (Windows Resource file)
<association id= "html.xml" langID= "8" />
<association id= "xml.xml" langID= "9" />
<association id= "makefile.xml" langID= "10"/>
<association id= "pascal.xml" langID= "11"/>
<association id= "batch.xml" langID= "12"/>
<association id= "ini.xml" langID= "13"/>
<association id= "asp.xml" langID= "16"/>
<association id= "sql.xml" langID= "17"/>
<association id= "vb.xml" langID= "18"/>
<association id= "css.xml" langID= "20"/>
<association id= "perl.xml" langID= "21"/>
<association id= "python.xml" langID= "22"/>
<association id= "lua.xml" langID= "23"/>
<association id= "tex.xml" langID= "24"/> (TeX)
<association id= "fortran.xml" langID= "25"/>
<association id= "bash.xml" langID= "26"/>
<association id= "actionscript.xml" langID= "27"/>
<association id= "nsis.xml" langID= "28"/>
<association id= "tcl.xml" langID= "29"/>
<association id= "lisp.xml" langID= "30"/>
<association id= "scheme.xml" langID= "31"/>
<association id= "asm.xml" langID= "32"/> (Assembly)
<association id= "diff.xml" langID= "33"/>
<association id= "props.xml" langID= "34"/>
<association id= "postscript.xml" langID= "35"/>
<association id= "ruby.xml" langID= "36"/>
<association id= "smalltalk.xml" langID= "37"/>
<association id= "vhdl.xml" langID= "38"/>
<association id= "kix.xml" langID= "39"/> (KiXtart)
<association id= "autoit.xml" langID= "40"/>
<association id= "caml.xml" langID= "41"/>
<association id= "ada.xml" langID= "42"/>
<association id= "verilog.xml" langID= "43"/>
<association id= "matlab.xml" langID= "44"/>
<association id= "haskell.xml" langID= "45"/>
<association id= "inno.xml" langID= "46"/> (Inno Setup)
<association id= "cmake.xml" langID= "48"/>
<association id= "yaml.xml" langID= "49"/>
<association id= "cobol.xml" langID= "50"/>
<association id= "gui4cli.xml" langID= "51"/>
<association id= "d.xml" langID= "52"/>
<association id= "powershell.xml" langID= "53"/>
<association id= "r.xml" langID= "54"/>
<association id= "jsp.xml" langID= "55"/>
<association id= "coffeescript.xml" langID= "56"/>
<association id= "json.xml" langID= "57"/>
<association id= "javascript.js.xml" langID= "58"/>
<association id= "fortran77.xml" langID= "59"/>
<association id= "baanc.xml" langID= "60"/> (BaanC)
<association id= "srec.xml" langID= "61"/> (Motorola S-Record binary data)
<association id= "ihex.xml" langID= "62"/> (Intel HEX binary data)
<association id= "tehex.xml" langID= "63"/> (Tektronix extended HEX binary data)
<association id= "swift.xml" langID= "64"/>
<association id= "asn1.xml" langID= "65"/> (Abstract Syntax Notation One)
<association id= "avs.xml" langID= "66"/> (AviSynth)
<association id= "blitzbasic.xml" langID= "67"/> (BlitzBasic)
<association id= "purebasic.xml" langID= "68"/>
<association id= "freebasic.xml" langID= "69"/>
<association id= "csound.xml" langID= "70"/>
<association id= "erlang.xml" langID= "71"/>
<association id= "escript.xml" langID= "72"/>
<association id= "forth.xml" langID= "73"/>
<association id= "latex.xml" langID= "74"/>
<association id= "mmixal.xml" langID= "75"/>
<association id= "nimrod.xml" langID= "76"/>
<association id= "nncrontab.xml" langID= "77"/> (extended crontab)
<association id= "oscript.xml" langID= "78"/>
<association id= "rebol.xml" langID= "79"/>
<association id= "registry.xml" langID= "80"/>
<association id= "rust.xml" langID= "81"/>
<association id= "spice.xml" langID= "82"/>
<association id= "txt2tags.xml" langID= "83"/>
<association id= "visualprolog.xml" langID= "84"/>
If you create your own parse rule of supported languages (above) for your specific need,
you can copy it without modifying the original one, and make it point to your rule.
For example, you have created your php parse rule, named "myphp2.xml". You add the rule file
into the functionlist directory and add the following line in this file:
<association id= "myphp2.xml" langID= "1" />
and that's it.
-->
<!--
As there is currently only one langID for COBOL:
uncomment the following line to change to cobol-free.xml (cobol section free)
if this is your favourite format
-->
<!--
<association id= "cobol-free.xml" langID= "50"/>
-->
<!--
For User Defined Languages (UDL's) use:
<association id="my_parser.xml" userDefinedLangName="My UDL Name" />
If "My UDL Name" doesn't exist yet, you can create it via UDL dialog.
-->
<!-- ==================== User Defined Languages ============================ -->
<association id= "krl.xml" userDefinedLangName="KRL"/>
<association id= "sinumerik.xml" userDefinedLangName="Sinumerik"/>
<association id= "universe_basic.xml" userDefinedLangName="UniVerse BASIC"/>
<!-- ======================================================================== -->
</associationMap>
</functionList>
</NotepadPlus>

40
PowerEditor/installer/functionList/perl.xml Normal file
View File

@ -0,0 +1,40 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================== [ PERL ] -->
<!-- PERL - Practical Extraction and Reporting Language -->
<parser
displayName="PERL"
id ="perl_function"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?m-s:\x23.*$) # Single Line Comment
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
sub
\s+
[A-Za-z_]\w*
(\s*\([^()]*\))? # prototype or signature
(\s*\:\s*[^{]+)? # attributes
\s*\{ # start of class body
"
>
<functionName>
<nameExpr expr="(?:sub\s+)?\K[A-Za-z_]\w*" />
</functionName>
<className>
<nameExpr expr="[A-Za-z_]\w*(?=\s*:{2})" />
</className>
</function>
</parser>
</functionList>
</NotepadPlus>

52
PowerEditor/installer/functionList/php.xml Normal file
View File

@ -0,0 +1,52 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================================= [ PHP ] -->
<!-- PHP - Personal Home Page / PHP Hypertext Preprocessor -->
<parser
id ="php_syntax"
displayName="PHP"
commentExpr="(?s:/\*.*?\*/)|(?m-s://.*?$)"
>
<classRange
mainExpr ="^\s*(class|abstract\s+class|final\s+class|interface|trait)[\t\x20]+[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*(\s*|\s*(extends|implements|(extends\s+(\\|[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*)+\s+implements))\s+(\,\s*|(\\|[A-Za-z_\x7F-\xFF][\w\x7F-\xFF]*))+\s*)?\{"
openSymbole ="\{"
closeSymbole="\}"
>
<className>
<nameExpr expr="(class|abstract\s+class|final\s+class|interface|trait)\s+\w+" />
<nameExpr expr="\s+\w+\Z" />
<nameExpr expr="\w+\Z" />
</className>
<function
mainExpr="^\s*((static|public|protected|private|final)*(\s+(static|public|protected|private|final))+\s+)?(function\s+)+(\w+(\s+\w+)?(\s+|\*\s+|\s+\*|\s+\*\s+))?(\w+\s*::)?(?!(if|while|for|switch))[\w~]+\s*\([^\{]*\{"
>
<functionName>
<funcNameExpr expr="(?!(if|while|for|switch))\w+\s*\([^\{]*" />
<!-- comment out the following node to display the method with parameters -->
<funcNameExpr expr="(?!(if|while|for|switch))\w+" />
</functionName>
</function>
</classRange>
<function
mainExpr="^\s*function\s+\w+\s*\("
>
<functionName>
<nameExpr expr="(?!(if|while|for))\w+\s*\(" />
<nameExpr expr="(?!(if|while|for))\w+" />
</functionName>
<className>
<nameExpr expr="\w+(?=\s*::)" />
</className>
</function>
</parser>
</functionList>
</NotepadPlus>

44
PowerEditor/installer/functionList/powershell.xml Normal file
View File

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ================================================== [ PowerShell ] -->
<parser
displayName="PowerShell"
id ="powershell_function"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?s:\x3C\x23(?:[^\x23]|\x23[^\x3E])*\x23\x3E) # Multi Line Comment
| (?m-s:\x23.*$) # Single Line Comment
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
\b
(?:function|filter)
\s+
(?:
[A-Za-z_]\w*
:
)?
[A-Za-z_][\w\-]*
\s*
[({]
"
>
<functionName>
<nameExpr expr="[A-Za-z_][\w\-]*(?=\s*[({])" />
</functionName>
<className>
<nameExpr expr="[A-Za-z_]\w*(?=:)" />
</className>
</function>
</parser>
</functionList>
</NotepadPlus>

41
PowerEditor/installer/functionList/python.xml Normal file
View File

@ -0,0 +1,41 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ====================================================== [ Python ] -->
<parser
displayName="Python"
id ="python_syntax"
commentExpr="(?s:'''.*?''')|(?m-s:#.*?$)"
>
<classRange
mainExpr ="(?&lt;=^class\x20).*?(?=\n\S|\Z)"
>
<className>
<nameExpr expr="\w+(?=\s*[\(|:])" />
</className>
<function
mainExpr="(?&lt;=\sdef\x20).+?(?=:)"
>
<functionName>
<funcNameExpr expr=".*" />
</functionName>
</function>
</classRange>
<function
mainExpr="(?&lt;=\sdef\x20).+?(?=:)"
>
<functionName>
<nameExpr expr=".*" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

42
PowerEditor/installer/functionList/ruby.xml Normal file
View File

@ -0,0 +1,42 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================== [ Ruby ] -->
<parser
displayName="Ruby"
id ="ruby_syntax"
>
<!-- within a class-->
<classRange
mainExpr ="(?&lt;=^class\x20).*?(?=\n\S|\Z)"
>
<className>
<nameExpr expr="\w+" />
</className>
<function
mainExpr="^\s*def\s+\w+"
>
<functionName>
<funcNameExpr expr="(?&lt;=def\s)\w+" />
</functionName>
</function>
</classRange>
<!-- without class-->
<function
mainExpr="^\s*def\s+\w+"
>
<functionName>
<nameExpr expr="(?&lt;=def\s)\w+" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

29
PowerEditor/installer/functionList/sinumerik.xml Normal file
View File

@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- =================================================== [ Sinumerik ] -->
<!-- Sinumerik - Siemens Numeric Control -->
<!--
| https://notepad-plus-plus.org/community/topic/12520/function-list-for-simatic
| 20161113: Added `(?!\$PATH)` to get around restriction/bug of
| two characters required before comment.
\-->
<parser
displayName="Sinumerik"
id ="sinumerik_function"
commentExpr="(?m-s:;(?!\$PATH).*?$)"
>
<function
mainExpr="(?m)^%_N_\K[A-Za-z_]\w*"
/>
</parser>
</functionList>
</NotepadPlus>

25
PowerEditor/installer/functionList/sql.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================================= [ PL/SQL ] -->
<parser id="plsql_function" displayName="PL/SQL" commentExpr="((/\*.*?\*)/|(//.*?$))">
<function
mainExpr="((PROCEDURE)|(FUNCTION))[\s]+[A-Za-z][\w_]*([\s]*\([^\)]*\)[\s]*)?(([\s]*;)|([\s]*([ia]s))|([\s]+(RETURN)([\s]+[\w%\.]+)+(([\s]*;)|([\s]+([ia]s)))))"
displayMode="$className->$functionName"
>
<functionName>
<nameExpr expr="[\s]+[A-Za-z][\w_]*([\s]*\([^\)]*\))?(([\s]*;)|([\s]*([ia]s))|([\s]+(RETURN)([\s]+[\w%\.]+)+(([\s]*;)|([\s]+([ia]s)))))"/>
<nameExpr expr="[A-Za-z][\w_]*([\s]*\([^\)]*\))?(([\s]*;)|([\s]*([ia]s))|([\s]+(RETURN)([\s]+[\w%\.]+)+(([\s]*;)|([\s]+([ia]s)))))"/>
<nameExpr expr="[A-Za-z][\w_]*([\s]*\([^\)]*\))?(([\s]+(RETURN)([\s]+[\w%\.]+)+))*"/>
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

43
PowerEditor/installer/functionList/universe_basic.xml Normal file
View File

@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ============================================== [ UniVerse BASIC ] -->
<!--
| Based on:
| https://notepad-plus-plus.org/community/topic/12742/functionlist-different-results-with-different-line-endings
\-->
<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>
</functionList>
</NotepadPlus>

39
PowerEditor/installer/functionList/vhdl.xml Normal file
View File

@ -0,0 +1,39 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ======================================================== [ VHDL ] -->
<!--
| Derived from :
| https://community.notepad-plus-plus.org/topic/11554/function-list-for-vhdl
\-->
<parser
displayName="VHDL"
id ="vhdl_syntax"
>
<function
mainExpr="(?x) # free-spacing (see `RegEx - Pattern Modifiers`)
^ # match at beginning of line
\h* # optional leading whitespace
(\w+\h*:)? # ID of process
(?:\h(?!END)\w+\h)* # make sure this is not the end of a module
\h*
(?(1)(?:ENTITY|BLOCK|PROCESS)| # keywords if ':' was detected before
(?:ENTITY|COMPONENT|ARCHITECTURE)) # keywords else
[\h\(]+ # expect at least one blank or parentheses
[A-Za-z0-9_\(\)., ]+ # ID or sensitivity list
(?!\;)"
>
<functionName>
<nameExpr expr=".*" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

45
PowerEditor/installer/functionList/xml.xml Normal file
View File

@ -0,0 +1,45 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!-- ==========================================================================\
|
| To learn how to make your own language parser, please check the following
| link:
| https://npp-user-manual.org/docs/function-list/
|
\=========================================================================== -->
<NotepadPlus>
<functionList>
<!-- ========================================================= [ XML ] -->
<!-- XML - eXtensible Markup Language -->
<parser
displayName="XML Node"
id ="xml_node"
commentExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
(?:\x3C!--(?:[^\-]|-(?!-\x3E))*--\x3E) # Multi Line Comment
"
>
<function
mainExpr="(?x) # Utilize inline comments (see `RegEx - Pattern Modifiers`)
\x3C # begin of node
(?:
(?-i:\?XML) # only name of root node is allowed to start with a question mark
| \w+(?::\w+)? # a node name can contain a colon e.g. `xs:schema`
)
(?: # match attributes
\s+ # at least one whitespace before attribute-name
\w+(?::\w+)? # an attribute name can contain a colon e.g. `xmlns:xs`
\h*=\h* # name-value separator can be surrounded by blanks
(?: # quoted attribute value, embedded escaped quotes allowed...
\x22(?:[^\x22\x5C]|\x5C.)*?\x22 # ...double quoted...
| \x27(?:[^\x27\x5C]|\x5C.)*?\x27 # ...single quoted
)
)+ # only match nodes with at least one attribute
"
>
<functionName>
<nameExpr expr="[^\x3C]*" />
</functionName>
</function>
</parser>
</functionList>
</NotepadPlus>

3
PowerEditor/installer/nppSetup.nsi
View File

@ -110,7 +110,7 @@ SectionEnd
!include "nsisInclude\autoCompletion.nsh"
!include "nsisInclude\functionList.nsh"
!include "nsisInclude\binariesComponents.nsh"
@ -252,6 +252,7 @@ ${MementoSectionDone}
!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
!insertmacro MUI_DESCRIPTION_TEXT ${explorerContextMenu} 'Explorer context menu entry for Notepad++ : Open whatever you want in Notepad++ from Windows Explorer.'
!insertmacro MUI_DESCRIPTION_TEXT ${autoCompletionComponent} 'Install the API files you need for the auto-completion feature (Ctrl+Space).'
!insertmacro MUI_DESCRIPTION_TEXT ${functionListComponent} 'Install the function list files you need for the function list feature (Ctrl+Space).'
!insertmacro MUI_DESCRIPTION_TEXT ${Plugins} 'You may need these plugins to extend the capabilities of Notepad++.'
!insertmacro MUI_DESCRIPTION_TEXT ${localization} 'To use Notepad++ in your favorite language(s), install all/desired language(s).'
!insertmacro MUI_DESCRIPTION_TEXT ${Themes} 'The eye-candy to change visual effects. Use Theme selector to switch among them.'

51
PowerEditor/installer/nsisInclude/autoCompletion.nsh
View File

@ -30,151 +30,126 @@ SectionGroup "Auto-completion Files" autoCompletionComponent
SetOverwrite off
${MementoSection} "C" C
Delete "$INSTDIR\plugins\APIs\c.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\c.xml"
${MementoSectionEnd}
${MementoSection} "C++" C++
Delete "$INSTDIR\plugins\APIs\cpp.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\cpp.xml"
${MementoSectionEnd}
${MementoSection} "Java" Java
Delete "$INSTDIR\plugins\APIs\java.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\java.xml"
${MementoSectionEnd}
${MementoSection} "C#" C#
Delete "$INSTDIR\plugins\APIs\cs.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\cs.xml"
${MementoSectionEnd}
${MementoSection} "HTML" HTML
Delete "$INSTDIR\plugins\APIs\html.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\html.xml"
${MementoSectionEnd}
${MementoSection} "RC" RC
Delete "$INSTDIR\plugins\APIs\rc.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\rc.xml"
${MementoSectionEnd}
${MementoSection} "SQL" SQL
Delete "$INSTDIR\plugins\APIs\sql.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\sql.xml"
${MementoSectionEnd}
${MementoSection} "PHP" PHP
Delete "$INSTDIR\plugins\APIs\php.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\php.xml"
${MementoSectionEnd}
${MementoSection} "CSS" CSS
Delete "$INSTDIR\plugins\APIs\css.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\css.xml"
${MementoSectionEnd}
${MementoSection} "VB" VB
Delete "$INSTDIR\plugins\APIs\vb.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\vb.xml"
${MementoSectionEnd}
${MementoSection} "Perl" Perl
Delete "$INSTDIR\plugins\APIs\perl.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\perl.xml"
${MementoSectionEnd}
${MementoSection} "JavaScript" JavaScript
Delete "$INSTDIR\plugins\APIs\javascript.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\javascript.xml"
${MementoSectionEnd}
${MementoSection} "Python" Python
Delete "$INSTDIR\plugins\APIs\python.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\python.xml"
${MementoSectionEnd}
${MementoSection} "ActionScript" ActionScript
Delete "$INSTDIR\plugins\APIs\actionscript.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\actionscript.xml"
${MementoSectionEnd}
${MementoSection} "LISP" LISP
Delete "$INSTDIR\plugins\APIs\lisp.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\lisp.xml"
${MementoSectionEnd}
${MementoSection} "VHDL" VHDL
Delete "$INSTDIR\plugins\APIs\vhdl.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\vhdl.xml"
${MementoSectionEnd}
${MementoSection} "TeX" TeX
Delete "$INSTDIR\plugins\APIs\tex.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\tex.xml"
${MementoSectionEnd}
${MementoSection} "DocBook" DocBook
Delete "$INSTDIR\plugins\APIs\xml.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\xml.xml"
${MementoSectionEnd}
${MementoSection} "NSIS" NSIS
Delete "$INSTDIR\plugins\APIs\nsis.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\nsis.xml"
${MementoSectionEnd}
${MementoSection} "CMAKE" CMAKE
Delete "$INSTDIR\plugins\APIs\cmake.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\cmake.xml"
${MementoSectionEnd}
${MementoSection} "BATCH" BATCH
Delete "$INSTDIR\plugins\APIs\batch.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\batch.xml"
${MementoSectionEnd}
${MementoSection} "CoffeeScript" CoffeeScript
Delete "$INSTDIR\plugins\APIs\coffee.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\coffee.xml"
${MementoSectionEnd}
${MementoSection} "BaanC" BaanC
Delete "$INSTDIR\plugins\APIs\baanc.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\baanc.xml"
${MementoSectionEnd}
${MementoSection} "Lua" Lua
Delete "$INSTDIR\plugins\APIs\lua.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\lua.xml"
${MementoSectionEnd}
${MementoSection} "AutoIt" AutoIt
Delete "$INSTDIR\plugins\APIs\autoit.xml"
SetOutPath "$INSTDIR\autoCompletion"
File ".\APIs\autoit.xml"
${MementoSectionEnd}
@ -184,128 +159,102 @@ SectionGroupEnd
SectionGroup un.autoCompletionComponent
Section un.PHP
Delete "$INSTDIR\plugins\APIs\php.xml"
Delete "$INSTDIR\autoCompletion\php.xml"
SectionEnd
Section un.CSS
Delete "$INSTDIR\plugins\APIs\css.xml"
Delete "$INSTDIR\autoCompletion\css.xml"
SectionEnd
Section un.HTML
Delete "$INSTDIR\plugins\APIs\html.xml"
Delete "$INSTDIR\autoCompletion\html.xml"
SectionEnd
Section un.SQL
Delete "$INSTDIR\plugins\APIs\sql.xml"
Delete "$INSTDIR\autoCompletion\sql.xml"
SectionEnd
Section un.RC
Delete "$INSTDIR\plugins\APIs\rc.xml"
Delete "$INSTDIR\autoCompletion\rc.xml"
SectionEnd
Section un.VB
Delete "$INSTDIR\plugins\APIs\vb.xml"
Delete "$INSTDIR\autoCompletion\vb.xml"
SectionEnd
Section un.Perl
Delete "$INSTDIR\plugins\APIs\perl.xml"
Delete "$INSTDIR\autoCompletion\perl.xml"
SectionEnd
Section un.C
Delete "$INSTDIR\plugins\APIs\c.xml"
Delete "$INSTDIR\autoCompletion\c.xml"
SectionEnd
Section un.C++
Delete "$INSTDIR\plugins\APIs\cpp.xml"
Delete "$INSTDIR\autoCompletion\cpp.xml"
SectionEnd
Section un.Java
Delete "$INSTDIR\plugins\APIs\java.xml"
Delete "$INSTDIR\autoCompletion\java.xml"
SectionEnd
Section un.C#
Delete "$INSTDIR\plugins\APIs\cs.xml"
Delete "$INSTDIR\autoCompletion\cs.xml"
SectionEnd
Section un.JavaScript
Delete "$INSTDIR\plugins\APIs\javascript.xml"
Delete "$INSTDIR\autoCompletion\javascript.xml"
SectionEnd
Section un.Python
Delete "$INSTDIR\plugins\APIs\python.xml"
Delete "$INSTDIR\autoCompletion\python.xml"
SectionEnd
Section un.ActionScript
Delete "$INSTDIR\plugins\APIs\actionscript.xml"
Delete "$INSTDIR\autoCompletion\actionscript.xml"
SectionEnd
Section un.LISP
Delete "$INSTDIR\plugins\APIs\lisp.xml"
Delete "$INSTDIR\autoCompletion\lisp.xml"
SectionEnd
Section un.VHDL
Delete "$INSTDIR\plugins\APIs\vhdl.xml"
Delete "$INSTDIR\autoCompletion\vhdl.xml"
SectionEnd
Section un.TeX
Delete "$INSTDIR\plugins\APIs\tex.xml"
Delete "$INSTDIR\autoCompletion\tex.xml"
SectionEnd
Section un.DocBook
Delete "$INSTDIR\plugins\APIs\xml.xml"
Delete "$INSTDIR\autoCompletion\xml.xml"
SectionEnd
Section un.NSIS
Delete "$INSTDIR\plugins\APIs\nsis.xml"
Delete "$INSTDIR\autoCompletion\nsis.xml"
SectionEnd
Section un.CMAKE
Delete "$INSTDIR\plugins\APIs\cmake.xml"
Delete "$INSTDIR\autoCompletion\cmake.xml"
SectionEnd
Section un.BATCH
Delete "$INSTDIR\plugins\APIs\batch.xml"
Delete "$INSTDIR\autoCompletion\batch.xml"
SectionEnd
Section un.CoffeeScript
Delete "$INSTDIR\plugins\APIs\coffee.xml"
Delete "$INSTDIR\autoCompletion\coffee.xml"
SectionEnd
Section un.BaanC
Delete "$INSTDIR\plugins\APIs\baanc.xml"
Delete "$INSTDIR\autoCompletion\baanc.xml"
SectionEnd
Section un.Lua
Delete "$INSTDIR\plugins\APIs\lua.xml"
Delete "$INSTDIR\autoCompletion\lua.xml"
SectionEnd
Section un.autoit
Delete "$INSTDIR\plugins\APIs\autoit.xml"
Delete "$INSTDIR\autoCompletion\autoit.xml"
SectionEnd

281
PowerEditor/installer/nsisInclude/functionList.nsh Normal file
View File

@ -0,0 +1,281 @@
; this file is part of installer for Notepad++
; Copyright (C)2016 Don HO <don.h@free.fr>
;
; This program is free software; you can redistribute it and/or
; modify it under the terms of the GNU General Public License
; as published by the Free Software Foundation; either
; version 2 of the License, or (at your option) any later version.
;
; Note that the GPL places important restrictions on "derived works", yet
; it does not provide a detailed definition of that term. To avoid
; misunderstandings, we consider an application to constitute a
; "derivative work" for the purpose of this license if it does any of the
; following:
; 1. Integrates source code from Notepad++.
; 2. Integrates/includes/aggregates Notepad++ into a proprietary executable
; installer, such as those produced by InstallShield.
; 3. Links to a library or executes a program that does any of the above.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program; if not, write to the Free Software
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
SectionGroup "Function List Files" functionListComponent
SetOverwrite off
; UPDATE_PATH: the value is $UPDATE_PATH if doLocalConf.xml exit,
; otherwise the value is $APPDATA\${APPNAME}
${MementoSection} "C" C_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\c.xml"
${MementoSectionEnd}
${MementoSection} "C++" C++_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\cpp.xml"
${MementoSectionEnd}
${MementoSection} "Java" Java_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\java.xml"
${MementoSectionEnd}
${MementoSection} "C#" C#_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\cs.xml"
${MementoSectionEnd}
${MementoSection} "Assembly" Assembly_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\asm.xml"
${MementoSectionEnd}
${MementoSection} "Bash" Bash_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\bash.xml"
${MementoSectionEnd}
${MementoSection} "SQL" SQL_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\sql.xml"
${MementoSectionEnd}
${MementoSection} "PHP" PHP_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\php.xml"
${MementoSectionEnd}
${MementoSection} "COBOL section free" COBOL-section-free
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\cobol-free.xml"
${MementoSectionEnd}
${MementoSection} "COBOL" COBOL_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\cobol.xml"
${MementoSectionEnd}
${MementoSection} "Perl" Perl_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\perl.xml"
${MementoSectionEnd}
${MementoSection} "JavaScript" JavaScript_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\javascript.js.xml"
${MementoSectionEnd}
${MementoSection} "Python" Python_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\python.xml"
${MementoSectionEnd}
${MementoSection} "ini" ini_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\ini.xml"
${MementoSectionEnd}
${MementoSection} "Inno Setup" Innosetup_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\inno.xml"
${MementoSectionEnd}
${MementoSection} "VHDL" VHDL_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\vhdl.xml"
${MementoSectionEnd}
${MementoSection} "KRL" KRL_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\krl.xml"
${MementoSectionEnd}
${MementoSection} "Override Map" OverrideMap_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\overrideMap.xml"
${MementoSectionEnd}
${MementoSection} "NSIS" NSIS_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\nsis.xml"
${MementoSectionEnd}
${MementoSection} "PowerShell" PowerShell_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\powershell.xml"
${MementoSectionEnd}
${MementoSection} "BATCH" BATCH_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\batch.xml"
${MementoSectionEnd}
${MementoSection} "Ruby" Ruby_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\ruby.xml"
${MementoSectionEnd}
${MementoSection} "BaanC" BaanC_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\baanc.xml"
${MementoSectionEnd}
${MementoSection} "Sinumerik" Sinumerik_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\sinumerik.xml"
${MementoSectionEnd}
${MementoSection} "AutoIt" AutoIt_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\autoit.xml"
${MementoSectionEnd}
${MementoSection} "UniVerse BASIC" UniVerseBASIC_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\universe_basic.xml"
${MementoSectionEnd}
${MementoSection} "XML" XML_FL
SetOutPath "$UPDATE_PATH\functionList"
File ".\functionList\xml.xml"
${MementoSectionEnd}
SectionGroupEnd
SectionGroup un.functionListComponent
Section un.PHP_FL
Delete "$UPDATE_PATH\functionList\php.xml"
SectionEnd
Section un.Assembly_FL
Delete "$UPDATE_PATH\functionList\asm.xml"
SectionEnd
Section un.SQL_FL
Delete "$UPDATE_PATH\functionList\sql.xml"
SectionEnd
Section un.Bash_FL
Delete "$UPDATE_PATH\functionList\bash.xml"
SectionEnd
Section un.COBOL-section-free_FL
Delete "$UPDATE_PATH\functionList\cobol-free.xml"
SectionEnd
Section un.Perl_FL
Delete "$UPDATE_PATH\functionList\perl.xml"
SectionEnd
Section un.C_FL
Delete "$UPDATE_PATH\functionList\c.xml"
SectionEnd
Section un.C++_FL
Delete "$UPDATE_PATH\functionList\cpp.xml"
SectionEnd
Section un.Java_FL
Delete "$UPDATE_PATH\functionList\java.xml"
SectionEnd
Section un.C#_FL
Delete "$UPDATE_PATH\functionList\cs.xml"
SectionEnd
Section un.JavaScript_FL
Delete "$UPDATE_PATH\functionList\javascript.js.xml"
SectionEnd
Section un.Python_FL
Delete "$UPDATE_PATH\functionList\python.xml"
SectionEnd
Section un.COBOL_FL
Delete "$UPDATE_PATH\functionList\cobol.xml"
SectionEnd
Section un.ini_FL
Delete "$UPDATE_PATH\functionList\ini.xml"
SectionEnd
Section un.VHDL_FL
Delete "$UPDATE_PATH\functionList\vhdl.xml"
SectionEnd
Section un.Innosetup_FL
Delete "$UPDATE_PATH\functionList\inno.xml"
SectionEnd
Section un.XML_FL
Delete "$UPDATE_PATH\functionList\xml.xml"
SectionEnd
Section un.NSIS_FL
Delete "$UPDATE_PATH\functionList\nsis.xml"
SectionEnd
Section un.KRL_FL
Delete "$UPDATE_PATH\functionList\krl.xml"
SectionEnd
Section un.BATCH_FL
Delete "$UPDATE_PATH\functionList\batch.xml"
SectionEnd
Section un.OverrideMap_FL
Delete "$UPDATE_PATH\functionList\overrideMap.xml"
SectionEnd
Section un.BaanC_FL
Delete "$UPDATE_PATH\functionList\baanc.xml"
SectionEnd
Section un.PowerShell_FL
Delete "$UPDATE_PATH\functionList\powershell.xml"
SectionEnd
Section un.AutoIt_FL
Delete "$UPDATE_PATH\functionList\autoit.xml"
SectionEnd
Section un.Ruby_FL
Delete "$UPDATE_PATH\functionList\ruby.xml"
SectionEnd
Section un.UniVerseBASIC_FL
Delete "$UPDATE_PATH\functionList\universe_basic.xml"
SectionEnd
Section un.Sinumerik_FL
Delete "$UPDATE_PATH\functionList\sinumerik.xml"
SectionEnd
SectionGroupEnd

2
PowerEditor/installer/nsisInclude/mainSectionFuncs.nsh
View File

@ -85,14 +85,12 @@ Function copyCommonFiles
SetOverwrite off
SetOutPath "$UPDATE_PATH\"
File "..\bin\contextMenu.xml"
File "..\bin\functionList.xml"
SetOverwrite on
SetOutPath "$INSTDIR\"
File "..\bin\langs.model.xml"
File "..\bin\stylers.model.xml"
File "..\bin\contextMenu.xml"
File "..\bin\functionList.xml"
SetOverwrite off
File "..\bin\shortcuts.xml"

12
PowerEditor/installer/packageAll.bat
View File

@ -129,6 +129,7 @@ mkdir .\zipped.package.release\updater
mkdir .\zipped.package.release\localization
mkdir .\zipped.package.release\themes
mkdir .\zipped.package.release\autoCompletion
mkdir .\zipped.package.release\functionList
mkdir .\zipped.package.release\userDefineLangs
mkdir .\zipped.package.release\plugins
mkdir .\zipped.package.release\plugins\NppExport
@ -146,6 +147,7 @@ mkdir .\zipped.package.release64\updater
mkdir .\zipped.package.release64\localization
mkdir .\zipped.package.release64\themes
mkdir .\zipped.package.release64\autoCompletion
mkdir .\zipped.package.release64\functionList
mkdir .\zipped.package.release64\userDefineLangs
mkdir .\zipped.package.release64\plugins
mkdir .\zipped.package.release64\plugins\NppExport
@ -169,8 +171,6 @@ copy /Y ..\src\contextMenu.xml .\zipped.package.release\
If ErrorLevel 1 goto End
copy /Y ..\src\shortcuts.xml .\zipped.package.release\
If ErrorLevel 1 goto End
copy /Y ..\src\functionList.xml .\zipped.package.release\
If ErrorLevel 1 goto End
copy /Y ..\bin\doLocalConf.xml .\zipped.package.release\
If ErrorLevel 1 goto End
copy /Y ..\bin\"notepad++.exe" .\zipped.package.release\
@ -194,8 +194,6 @@ copy /Y ..\src\contextMenu.xml .\zipped.package.release64\
If ErrorLevel 1 goto End
copy /Y ..\src\shortcuts.xml .\zipped.package.release64\
If ErrorLevel 1 goto End
copy /Y ..\src\functionList.xml .\zipped.package.release64\
If ErrorLevel 1 goto End
copy /Y ..\bin\doLocalConf.xml .\zipped.package.release64\
If ErrorLevel 1 goto End
copy /Y ..\bin64\"notepad++.exe" .\zipped.package.release64\
@ -232,6 +230,12 @@ If ErrorLevel 1 goto End
copy /Y ".\APIs\*.xml" .\zipped.package.release64\autoCompletion\
If ErrorLevel 1 goto End
rem FunctionList files: Copy all files into Notepad++ 32-bit/64-bit package folders
copy /Y ".\functionList\*.xml" .\zipped.package.release\functionList\
If ErrorLevel 1 goto End
copy /Y ".\functionList\*.xml" .\zipped.package.release64\functionList\
If ErrorLevel 1 goto End
rem Markdown as UserDefineLanguge: Markdown syntax highlighter into Notepad++ 32-bit/64-bit package folders
copy /Y "..\bin\userDefineLangs\userDefinedLang-markdown.default.modern.xml" .\zipped.package.release\userDefineLangs\
If ErrorLevel 1 goto End

6
PowerEditor/src/WinControls/FunctionList/functionListPanel.cpp
View File

@ -478,12 +478,12 @@ void FunctionListPanel::init(HINSTANCE hInst, HWND hPere, ScintillaEditView **pp
if (!doLocalConf)
{
generic_string funcListXmlPath = (NppParameters::getInstance()).getUserPath();
PathAppend(funcListXmlPath, TEXT("functionList.xml"));
PathAppend(funcListXmlPath, TEXT("functionList"));
if (!PathFileExists(funcListXmlPath.c_str()))
{
generic_string funcListDefaultXmlPath = (NppParameters::getInstance()).getNppPath();
PathAppend(funcListDefaultXmlPath, TEXT("functionList.xml"));
PathAppend(funcListDefaultXmlPath, TEXT("functionList"));
if (PathFileExists(funcListDefaultXmlPath.c_str()))
{
::CopyFile(funcListDefaultXmlPath.c_str(), funcListXmlPath.c_str(), TRUE);
@ -498,7 +498,7 @@ void FunctionListPanel::init(HINSTANCE hInst, HWND hPere, ScintillaEditView **pp
else
{
generic_string funcListDefaultXmlPath = (NppParameters::getInstance()).getNppPath();
PathAppend(funcListDefaultXmlPath, TEXT("functionList.xml"));
PathAppend(funcListDefaultXmlPath, TEXT("functionList"));
if (PathFileExists(funcListDefaultXmlPath.c_str()))
{
_funcParserMgr.init(funcListDefaultXmlPath, ppEditView);

291
PowerEditor/src/WinControls/FunctionList/functionParser.cpp
View File

@ -34,30 +34,19 @@ using namespace std;
FunctionParsersManager::~FunctionParsersManager()
{
for (size_t i = 0, len = _parsers.size(); i < len; ++i)
for (size_t i = 0, len = L_EXTERNAL + nbMaxUserDefined; i < len; ++i)
{
delete _parsers[i];
if (_parsers[i] != nullptr)
delete _parsers[i];
}
delete _pXmlFuncListDoc;
}
bool FunctionParsersManager::init(const generic_string& xmlPath, ScintillaEditView ** ppEditView)
bool FunctionParsersManager::init(const generic_string& xmlDirPath, ScintillaEditView ** ppEditView)
{
_ppEditView = ppEditView;
bool loadOkay = false;
_xmlDirPath = xmlDirPath;
if (PathFileExists(xmlPath.c_str()))
{
_pXmlFuncListDoc = new TiXmlDocument(xmlPath);
loadOkay = _pXmlFuncListDoc->LoadFile();
if (loadOkay)
{
loadOkay = getFuncListFromXmlTree();
}
}
return loadOkay;
return getOverrideMapFromXmlTree();
}
bool FunctionParsersManager::getZonePaserParameters(TiXmlNode *classRangeParser, generic_string &mainExprStr, generic_string &openSymboleStr, generic_string &closeSymboleStr, std::vector<generic_string> &classNameExprArray, generic_string &functionExprStr, std::vector<generic_string> &functionNameExprArray)
@ -153,20 +142,121 @@ bool FunctionParsersManager::getUnitPaserParameters(TiXmlNode *functionParser, g
return true;
}
void FunctionParsersManager::writeFunctionListXml(const TCHAR *destFoder) const
bool FunctionParsersManager::loadFuncListFromXmlTree(LangType lType, const generic_string& overrideId, int udlIndex)
{
generic_string dest = destFoder;
PathAppend(dest, TEXT("functionList.xml"));
if (_pXmlFuncListDoc)
_pXmlFuncListDoc->SaveFile(dest.c_str());
generic_string funcListRulePath = _xmlDirPath;
funcListRulePath += TEXT("\\");
int index = -1;
if (lType == L_USER) // UDL
{
if (overrideId.empty())
return false;
if (udlIndex == -1)
return false;
index = udlIndex;
funcListRulePath += overrideId;
}
else // Supported Language
{
index = lType;
if (overrideId.empty())
{
generic_string lexerName = ScintillaEditView::langNames[lType].lexerName;
funcListRulePath += lexerName;
funcListRulePath += TEXT(".xml");
}
else
{
funcListRulePath += overrideId;
}
}
if (index > _currentUDIndex)
return false;
if (_parsers[index] == nullptr)
return false;
TiXmlDocument xmlFuncListDoc(funcListRulePath);
bool loadOK = xmlFuncListDoc.LoadFile();
if (!loadOK)
return false;
TiXmlNode *root = xmlFuncListDoc.FirstChild(TEXT("NotepadPlus"));
if (!root)
return false;
root = root->FirstChild(TEXT("functionList"));
if (!root)
return false;
TiXmlNode *parserRoot = root->FirstChild(TEXT("parser"));
if (!parserRoot)
return false;
const TCHAR *id = (parserRoot->ToElement())->Attribute(TEXT("id"));
if (!id || !id[0])
return false;
generic_string commentExpr(TEXT(""));
const TCHAR *pCommentExpr = (parserRoot->ToElement())->Attribute(TEXT("commentExpr"));
if (pCommentExpr && pCommentExpr[0])
commentExpr = pCommentExpr;
std::vector<generic_string> classNameExprArray;
std::vector<generic_string> functionNameExprArray;
const TCHAR *displayName = (parserRoot->ToElement())->Attribute(TEXT("displayName"));
if (!displayName || !displayName[0])
displayName = id;
TiXmlNode *classRangeParser = parserRoot->FirstChild(TEXT("classRange"));
TiXmlNode *functionParser = parserRoot->FirstChild(TEXT("function"));
if (classRangeParser && functionParser)
{
generic_string mainExpr, openSymbole, closeSymbole, functionExpr;
getZonePaserParameters(classRangeParser, mainExpr, openSymbole, closeSymbole, classNameExprArray, functionExpr, functionNameExprArray);
generic_string mainExpr2;
std::vector<generic_string> classNameExprArray2;
std::vector<generic_string> functionNameExprArray2;
getUnitPaserParameters(functionParser, mainExpr2, functionNameExprArray2, classNameExprArray2);
FunctionUnitParser *funcUnitPaser = new FunctionUnitParser(id, displayName, commentExpr.c_str(), mainExpr2.c_str(), functionNameExprArray2, classNameExprArray2);
_parsers[index]->_parser = new FunctionMixParser(id, displayName, commentExpr.c_str(), mainExpr.c_str(), openSymbole.c_str(), closeSymbole.c_str(), classNameExprArray, functionExpr.c_str(), functionNameExprArray, funcUnitPaser);
}
else if (classRangeParser)
{
generic_string mainExpr, openSymbole, closeSymbole, functionExpr;
getZonePaserParameters(classRangeParser, mainExpr, openSymbole, closeSymbole, classNameExprArray, functionExpr, functionNameExprArray);
_parsers[index]->_parser = new FunctionZoneParser(id, displayName, commentExpr.c_str(), mainExpr.c_str(), openSymbole.c_str(), closeSymbole.c_str(), classNameExprArray, functionExpr.c_str(), functionNameExprArray);
}
else if (functionParser)
{
generic_string mainExpr;
getUnitPaserParameters(functionParser, mainExpr, functionNameExprArray, classNameExprArray);
_parsers[index]->_parser = new FunctionUnitParser(id, displayName, commentExpr.c_str(), mainExpr.c_str(), functionNameExprArray, classNameExprArray);
}
return true;
}
bool FunctionParsersManager::getFuncListFromXmlTree()
bool FunctionParsersManager::getOverrideMapFromXmlTree()
{
if (!_pXmlFuncListDoc)
generic_string funcListRulePath = _xmlDirPath;
funcListRulePath += TEXT("\\overrideMap.xml");
TiXmlDocument xmlFuncListDoc(funcListRulePath);
bool loadOK = xmlFuncListDoc.LoadFile();
if (!loadOK)
return false;
TiXmlNode *root = _pXmlFuncListDoc->FirstChild(TEXT("NotepadPlus"));
TiXmlNode *root = xmlFuncListDoc.FirstChild(TEXT("NotepadPlus"));
if (!root)
return false;
@ -174,61 +264,6 @@ bool FunctionParsersManager::getFuncListFromXmlTree()
if (!root)
return false;
TiXmlNode *parserRoot = root->FirstChild(TEXT("parsers"));
if (!parserRoot)
return false;
for (TiXmlNode *childNode = parserRoot->FirstChildElement(TEXT("parser"));
childNode;
childNode = childNode->NextSibling(TEXT("parser")) )
{
const TCHAR *id = (childNode->ToElement())->Attribute(TEXT("id"));
if (!id || !id[0])
continue;
generic_string commentExpr(TEXT(""));
const TCHAR *pCommentExpr = (childNode->ToElement())->Attribute(TEXT("commentExpr"));
if (pCommentExpr && pCommentExpr[0])
commentExpr = pCommentExpr;
std::vector<generic_string> classNameExprArray;
std::vector<generic_string> functionNameExprArray;
const TCHAR *displayName = (childNode->ToElement())->Attribute(TEXT("displayName"));
if (!displayName || !displayName[0])
displayName = id;
TiXmlNode *classRangeParser = childNode->FirstChild(TEXT("classRange"));
TiXmlNode *functionParser = childNode->FirstChild(TEXT("function"));
if (classRangeParser && functionParser)
{
generic_string mainExpr, openSymbole, closeSymbole, functionExpr;
getZonePaserParameters(classRangeParser, mainExpr, openSymbole, closeSymbole, classNameExprArray, functionExpr, functionNameExprArray);
generic_string mainExpr2;
std::vector<generic_string> classNameExprArray2;
std::vector<generic_string> functionNameExprArray2;
getUnitPaserParameters(functionParser, mainExpr2, functionNameExprArray2, classNameExprArray2);
FunctionUnitParser *funcUnitPaser = new FunctionUnitParser(id, displayName, commentExpr.c_str(), mainExpr2.c_str(), functionNameExprArray2, classNameExprArray2);
_parsers.push_back(new FunctionMixParser(id, displayName, commentExpr.c_str(), mainExpr.c_str(), openSymbole.c_str(), closeSymbole.c_str(), classNameExprArray, functionExpr.c_str(), functionNameExprArray, funcUnitPaser));
}
else if (classRangeParser)
{
generic_string mainExpr, openSymbole, closeSymbole, functionExpr;
getZonePaserParameters(classRangeParser, mainExpr, openSymbole, closeSymbole, classNameExprArray, functionExpr, functionNameExprArray);
_parsers.push_back(new FunctionZoneParser(id, displayName, commentExpr.c_str(), mainExpr.c_str(), openSymbole.c_str(), closeSymbole.c_str(), classNameExprArray, functionExpr.c_str(), functionNameExprArray));
}
else if (functionParser)
{
generic_string mainExpr;
getUnitPaserParameters(functionParser, mainExpr, functionNameExprArray, classNameExprArray);
_parsers.push_back(new FunctionUnitParser(id, displayName, commentExpr.c_str(), mainExpr.c_str(), functionNameExprArray, classNameExprArray));
}
}
TiXmlNode *associationMapRoot = root->FirstChild(TEXT("associationMap"));
if (associationMapRoot)
{
@ -238,24 +273,29 @@ bool FunctionParsersManager::getFuncListFromXmlTree()
{
int langID;
const TCHAR *langIDStr = (childNode->ToElement())->Attribute(TEXT("langID"), &langID);
const TCHAR *exts = (childNode->ToElement())->Attribute(TEXT("ext"));
const TCHAR *id = (childNode->ToElement())->Attribute(TEXT("id"));
const TCHAR *userDefinedLangName = (childNode->ToElement())->Attribute(TEXT("userDefinedLangName"));
if (((langIDStr && langIDStr[0]) || (exts && exts[0]) || (userDefinedLangName && userDefinedLangName[0])) && (id && id[0]))
if (!(id && id[0]))
continue;
if (langIDStr && langIDStr[0])
{
for (size_t i = 0, len = _parsers.size(); i < len; ++i)
_parsers[langID] = new ParserInfo(id);
}
else if (userDefinedLangName && userDefinedLangName[0])
{
if (_currentUDIndex < L_EXTERNAL + nbMaxUserDefined)
{
if (_parsers[i]->_id == id)
{
_associationMap.push_back(AssociationInfo(static_cast<int32_t>(i), langIDStr ? langID : -1, exts ? exts : TEXT(""), userDefinedLangName ? userDefinedLangName : TEXT("")));
break;
}
++_currentUDIndex;
_parsers[_currentUDIndex] = new ParserInfo(id, userDefinedLangName);
}
}
}
}
return (_parsers.size() != 0);
return true;
}
FunctionParser * FunctionParsersManager::getParser(const AssociationInfo & assoInfo)
@ -263,7 +303,6 @@ FunctionParser * FunctionParsersManager::getParser(const AssociationInfo & assoI
const unsigned char doNothing = 0;
const unsigned char checkLangID = 1;
const unsigned char checkUserDefined = 2;
const unsigned char checkExt = 3;
unsigned char choice = doNothing;
// langID != -1 && langID != L_USER
@ -272,39 +311,66 @@ FunctionParser * FunctionParsersManager::getParser(const AssociationInfo & assoI
// langID == L_USER, we chack the userDefinedLangName
else if (assoInfo._langID == L_USER && assoInfo._userDefinedLangName != TEXT(""))
choice = checkUserDefined;
// langID == -1, we chack the ext
else if (assoInfo._langID == -1 && assoInfo._ext != TEXT(""))
choice = checkExt;
else
return NULL;
for (size_t i = 0, len = _associationMap.size(); i < len; ++i)
switch (choice)
{
switch (choice)
case checkLangID:
{
case checkLangID:
if (_parsers[assoInfo._langID] != nullptr)
{
if (assoInfo._langID == _associationMap[i]._langID)
return _parsers[_associationMap[i]._id];
if (_parsers[assoInfo._langID]->_parser != nullptr)
return _parsers[assoInfo._langID]->_parser;
else
{
// load it
if (loadFuncListFromXmlTree(static_cast<LangType>(assoInfo._langID), _parsers[assoInfo._langID]->_id))
return _parsers[assoInfo._langID]->_parser;
}
}
break;
case checkUserDefined:
else
{
if (assoInfo._userDefinedLangName == _associationMap[i]._userDefinedLangName)
return _parsers[_associationMap[i]._id];
}
break;
_parsers[assoInfo._langID] = new ParserInfo;
// load it
if (loadFuncListFromXmlTree(static_cast<LangType>(assoInfo._langID), _parsers[assoInfo._langID]->_id))
return _parsers[assoInfo._langID]->_parser;
case checkExt:
{
if (assoInfo._ext == _associationMap[i]._ext)
return _parsers[_associationMap[i]._id];
return nullptr;
}
break;
}
break;
case checkUserDefined:
{
if (_currentUDIndex == L_EXTERNAL) // no User Defined Language parser
return nullptr;
for (int i = L_EXTERNAL + 1; i <= _currentUDIndex; ++i)
{
if (_parsers[i]->_userDefinedLangName == assoInfo._userDefinedLangName)
{
if (_parsers[i]->_parser)
{
return _parsers[i]->_parser;
}
else
{
// load it
if (loadFuncListFromXmlTree(static_cast<LangType>(assoInfo._langID), _parsers[i]->_id, i))
return _parsers[i]->_parser;
}
break;
}
}
return nullptr;
}
break;
}
return NULL;
}
@ -427,9 +493,6 @@ generic_string FunctionParser::parseSubLevel(size_t begin, size_t end, std::vect
bool FunctionParsersManager::parse(std::vector<foundInfo> & foundInfos, const AssociationInfo & assoInfo)
{
if (!_pXmlFuncListDoc)
return false;
// Serch the right parser from the given ext in the map
FunctionParser *fp = getParser(assoInfo);
if (!fp)

23
PowerEditor/src/WinControls/FunctionList/functionParser.h
View File

@ -139,6 +139,19 @@ struct AssociationInfo final
};
};
const int nbMaxUserDefined = 25;
struct ParserInfo
{
generic_string _id; // xml parser rule file name - if empty, then we use default name. Mandatory if _userDefinedLangName is not empty
FunctionParser* _parser = nullptr;
generic_string _userDefinedLangName;
ParserInfo() {};
ParserInfo(const generic_string& id): _id(id) {};
ParserInfo(const generic_string& id, const generic_string& userDefinedLangName): _id(id), _userDefinedLangName(userDefinedLangName) {};
~ParserInfo() { if (_parser) delete _parser; }
};
class FunctionParsersManager final
{
@ -147,16 +160,16 @@ public:
bool init(const generic_string& xmlPath, ScintillaEditView ** ppEditView);
bool parse(std::vector<foundInfo> & foundInfos, const AssociationInfo & assoInfo);
void writeFunctionListXml(const TCHAR *destFoder) const;
private:
ScintillaEditView **_ppEditView = nullptr;
std::vector<FunctionParser *> _parsers;
std::vector<AssociationInfo> _associationMap;
TiXmlDocument *_pXmlFuncListDoc = nullptr;
generic_string _xmlDirPath;
ParserInfo* _parsers[L_EXTERNAL + nbMaxUserDefined] = {nullptr};
int _currentUDIndex = L_EXTERNAL;
bool getFuncListFromXmlTree();
bool getOverrideMapFromXmlTree();
bool loadFuncListFromXmlTree(LangType lType, const generic_string& overrideId, int udlIndex = -1);
bool getZonePaserParameters(TiXmlNode *classRangeParser, generic_string &mainExprStr, generic_string &openSymboleStr, generic_string &closeSymboleStr, std::vector<generic_string> &classNameExprArray, generic_string &functionExprStr, std::vector<generic_string> &functionNameExprArray);
bool getUnitPaserParameters(TiXmlNode *functionParser, generic_string &mainExprStr, std::vector<generic_string> &functionNameExprArray, std::vector<generic_string> &classNameExprArray);
FunctionParser * getParser(const AssociationInfo & assoInfo);

1738
PowerEditor/src/functionList.xml
View File

File diff suppressed because it is too large Load Diff

3
PowerEditor/visual.net/notepadPlus.vcxproj
View File

@ -217,7 +217,6 @@
copy ..\src\langs.model.xml ..\bin\langs.model.xml
copy ..\src\stylers.model.xml ..\bin\stylers.model.xml
copy ..\src\shortcuts.xml ..\bin\shortcuts.xml
copy ..\src\functionList.xml ..\bin\functionList.xml
copy ..\src\contextMenu.xml ..\bin\contextMenu.xml
</Command>
</PostBuildEvent>
@ -270,7 +269,6 @@ copy ..\src\contextMenu.xml ..\bin\contextMenu.xml
copy ..\src\langs.model.xml ..\bin64\langs.model.xml
copy ..\src\stylers.model.xml ..\bin64\stylers.model.xml
copy ..\src\shortcuts.xml ..\bin64\shortcuts.xml
copy ..\src\functionList.xml ..\bin64\functionList.xml
copy ..\src\contextMenu.xml ..\bin64\contextMenu.xml
</Command>
</PostBuildEvent>
@ -679,7 +677,6 @@ copy ..\src\contextMenu.xml ..\bin64\contextMenu.xml
<ClInclude Include="..\src\WinControls\ReadDirectoryChanges\ReadDirectoryChangesPrivate.h" />
<ClInclude Include="..\src\WinControls\ReadDirectoryChanges\ThreadSafeQueue.h" />
<ClInclude Include="..\src\WinControls\ReadDirectoryChanges\ReadFileChanges.h" />
</ItemGroup>
<ItemGroup>
<Manifest Include="..\src\notepad++.exe.manifest" />

8
appveyor.yml
View File

@ -1,4 +1,4 @@
version: 7.8.{build}
version: 7.9.{build}
image: Visual Studio 2017
@ -62,8 +62,8 @@ after_build:
if ($env:PLATFORM_INPUT -eq "Win32" -and $env:CONFIGURATION -eq "Unicode Debug") {
Push-AppveyorArtifact "PowerEditor\visual.net\Unicode Debug\Notepad++.exe" -FileName "$nppFileName"
Start-FileDownload 'https://github.com/notepad-plus-plus/notepad-plus-plus/releases/download/v7.8.9/npp.7.8.9.bin.minimalist.7z'
7z x -y npp.7.8.9.bin.minimalist.7z | Out-Null
Start-FileDownload 'https://github.com/notepad-plus-plus/notepad-plus-plus/releases/download/v7.9/npp.7.9.portable.minimalist.7z'
7z x -y npp.7.9.portable.minimalist.7z | Out-Null
#take SciLexer.dll from downloaded version due to dependency of the functionlist tests on a version build with boost regex
#what is not the case for the dll build on appveyor CI (would either need a very time consuming boost build or usage of nuget packages)
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\SciLexer.dll" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin"
@ -71,8 +71,8 @@ after_build:
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\src\langs.model.xml" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin"
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\src\stylers.model.xml" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin"
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\src\shortcuts.xml" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin"
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\src\functionList.xml" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin"
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\src\contextMenu.xml" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin"
Copy-Item "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\installer\functionList" -Destination "$env:APPVEYOR_BUILD_FOLDER\PowerEditor\bin" -Recurse
cd .\PowerEditor\Test\FunctionList\
.\unitTestLauncher.ps1
.\unitTestLauncher.ps1