Add ada, fortran, fortran77 & haskell in function lists

- added missing unittest for c
- added further function lists for ada, fortran, fortran77, haskell from previous PR of MAPJe71_functionlist_update3
- added simple rust function list
- unittest files from the internet probably no complex ones
- added to installer

Fix #9698, close #3393, close #9727

PowerEditor/Test/FunctionList/ada/unitTest.expected.result

@@ -0,0 +1 @@
+{"leaves":["BiSeqOut"],"root":"unitTest"}

PowerEditor/Test/FunctionList/ada/unittest

@@ -0,0 +1,43 @@
+                                       -- Chapter 24 - Program 1 from https://perso.telecom-paristech.fr/pautet/Ada95/e_c24_p1.ada
+with Ada.Text_IO;
+use Ada.Text_IO;
+with Ada.Sequential_IO;
+
+procedure BiSeqOut is
+
+   type MY_REC is
+      record
+         Age     : INTEGER;
+         Sex     : CHARACTER;
+         Initial : CHARACTER;
+      end record;
+
+   package Seq_IO is new Ada.Sequential_IO(MY_REC);
+   use Seq_IO;
+
+   Myself      : MY_REC;
+   My_Out_File : Seq_IO.FILE_TYPE;
+
+begin
+
+   Create(My_Out_File, Out_File, "NAMEFILE.TXT");
+
+   Myself.Sex := 'M';
+   Myself.Initial := 'X';
+
+   for Index in 1..100 loop
+      Myself.Age := Index;
+      Write(My_Out_File, Myself);
+   end loop;
+
+   Close(My_Out_File);
+
+end BiSeqOut;
+
+
+
+
+-- Result of Execution
+
+--   (The only output is a binary file named NAMEFILE.TXT)
+

PowerEditor/Test/FunctionList/c/unitTest

@@ -0,0 +1,131 @@
+/**
+ * @file
+ * @brief Functions related to 3D quaternions and Euler angles.
+ * @author Krishna Vedala
+ */
+
+#include <stdio.h>
+#ifdef __arm__  // if compiling for ARM-Cortex processors
+#define LIBQUAT_ARM
+#include <arm_math.h>
+#else
+#include <math.h>
+#endif
+#include <assert.h>
+
+#include "geometry_datatypes.h"
+
+/**
+ * @addtogroup quats 3D Quaternion operations
+ * @{
+ */
+
+/**
+ * Function to convert given Euler angles to a quaternion.
+ * \f{eqnarray*}{
+ * q_{0} & =
+ * &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)
+ * +
+ * \sin\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\
+ * q_{1} & =
+ * &\sin\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)
+ * -
+ * \cos\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\
+ * q_{2} & =
+ * &\cos\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)
+ * +
+ * \sin\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\
+ * q_{3} & =
+ * &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)
+ * -
+ * \sin\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)\\
+ * \f}
+ *
+ * @param [in] in_euler input Euler angles instance
+ * @returns converted quaternion
+ */
+quaternion quat_from_euler(const euler *in_euler)
+{
+    quaternion out_quat;
+
+    if (!in_euler)  // if null
+    {
+        fprintf(stderr, "%s: Invalid input.", __func__);
+        return out_quat;
+    }
+
+    quaternion temp;
+
+    float cy = cosf(in_euler->yaw * 0.5f);
+    float sy = sinf(in_euler->yaw * 0.5f);
+    float cp = cosf(in_euler->pitch * 0.5f);
+    float sp = sinf(in_euler->pitch * 0.5f);
+    float cr = cosf(in_euler->roll * 0.5f);
+    float sr = sinf(in_euler->roll * 0.5f);
+
+    temp.w = cr * cp * cy + sr * sp * sy;
+    temp.q1 = sr * cp * cy - cr * sp * sy;
+    temp.q2 = cr * sp * cy + sr * cp * sy;
+    temp.q3 = cr * cp * sy - sr * sp * cy;
+
+    return temp;
+}
+
+/**
+ * Function to convert given quaternion to Euler angles.
+ * \f{eqnarray*}{
+ * \phi & = &
+ * \tan^{-1}\left[\frac{2\left(q_0q_1+q_2q_3\right)}{1-2\left(q_1^2+q_2^2\right)}\right]\\
+ * \theta & =
+ * &-\sin^{-1}\left[2\left(q_0q_2-q_3q_1\right)\right]\\
+ * \psi & = &
+ * \tan^{-1}\left[\frac{2\left(q_0q_3+q_1q_2\right)}{1-2\left(q_2^2+q_3^2\right)}\right]\\
+ * \f}
+ *
+ * @param [in] in_quat input quaternion instance
+ * @returns converted euler angles
+ */
+euler euler_from_quat(const quaternion *in_quat)
+{
+    euler out_euler;
+    if (!in_quat)  // if null
+    {
+        fprintf(stderr, "%s: Invalid input.", __func__);
+        return out_euler;
+    }
+
+    out_euler.roll = atan2f(
+        2.f * (in_quat->w * in_quat->q1 + in_quat->q2 * in_quat->q3),
+        1.f - 2.f * (in_quat->q1 * in_quat->q1 + in_quat->q2 * in_quat->q2));
+    out_euler.pitch =
+        asinf(2.f * (in_quat->w * in_quat->q2 + in_quat->q1 * in_quat->q3));
+    out_euler.yaw = atan2f(
+        2.f * (in_quat->w * in_quat->q3 + in_quat->q1 * in_quat->q2),
+        1.f - 2.f * (in_quat->q2 * in_quat->q2 + in_quat->q3 * in_quat->q3));
+
+    return out_euler;
+}
+
+/** @} */
+
+static void test()
+{
+    quaternion quat = {0.7071f, 0.7071f, 0.f, 0.f};
+    euler eul = euler_from_quat(&quat);
+    printf("Euler: %.4g, %.4g, %.4g\n", eul.pitch, eul.roll, eul.yaw);
+
+    quaternion test_quat = quat_from_euler(&eul);
+    printf("Quaternion: %.4g %+.4g %+.4g %+.4g\n", test_quat.w,
+           test_quat.dual.x, test_quat.dual.y, test_quat.dual.z);
+
+    assert(fabsf(test_quat.w - quat.w) < .01);
+    assert(fabsf(test_quat.q1 - quat.q1) < .01);
+    assert(fabsf(test_quat.q2 - quat.q2) < .01);
+    assert(fabsf(test_quat.q3 - quat.q3) < .01);
+}
+
+int main()
+{
+    test();
+    return 0;
+}

PowerEditor/Test/FunctionList/c/unitTest.expected.result

@@ -1 +1 @@
-{"root":"unitTest"}
+{"leaves":["quat_from_euler(const euler *in_euler)","euler_from_quat(const quaternion *in_quat)","test()","main()"],"root":"unitTest"}

PowerEditor/Test/FunctionList/fortran/unitTest.expected.result

@@ -0,0 +1 @@
+{"leaves":["setTime","getTime","printTime","PredictTime","PrintTimeSecondsHoursDays"],"root":"unitTest"}

PowerEditor/Test/FunctionList/fortran/unittest

@@ -0,0 +1,152 @@
+! Fortran Time Module
+!
+!  To Use:
+!    1) declare a ClockTime variable: type (ClockTime) :: Timer 
+!    2) Set a beginning Time: call set(Timer)
+!    3a) Print Elapsed Time: printTime(Timer)
+!    3b) Print Remaining Time: printRemainingTime(Timer,ratio)
+!    3c) Predict Completion Time: predict(Timer,ratio)
+! 
+! Copyright (c) 2008 Charles O'Neill
+! 
+! Permission is hereby granted, free of charge, to any person
+! obtaining a copy of this software and associated documentation
+! files (the "Software"), to deal in the Software without
+! restriction, including without limitation the rights to use,
+! copy, modify, merge, publish, distribute, sublicense, and/or sell
+! copies of the Software, and to permit persons to whom the
+! Software is furnished to do so, subject to the following
+! conditions:
+! 
+! The above copyright notice and this permission notice shall be
+! included in all copies or substantial portions of the Software.
+! 
+! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+! EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+! OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+! NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+! HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+! WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+! FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+! OTHER DEALINGS IN THE SOFTWARE.
+
+module ClockTiming
+  implicit none
+
+  ! Integer Precision
+  integer, parameter :: IS = 2
+  ! Real Single Precision
+  integer, parameter :: SP = 4  ! 4 gives 32 bits 
+  ! Real Double Precision
+  integer, parameter :: DP = 8  ! 4 gives 32 bits, 8 gives 64 bits (double)
+
+  type ClockTime
+     private
+     real(SP)  :: time_begin
+  end type
+
+  ! Time Constants
+  real(SP),parameter :: SecondsPerMinutes = 60.0
+  real(SP),parameter :: MinutesPerHour = 60.0
+  real(SP),parameter :: HoursPerDay = 24.0
+    
+  real(SP),parameter :: PrintMaxSeconds = 90.0d0
+  real(SP),parameter :: PrintMaxMinutes = SecondsPerMinutes*MinutesPerHour
+  real(SP),parameter :: PrintMaxHours = SecondsPerMinutes*MinutesPerHour*HoursPerDay
+    
+  !.................................  
+  ! Public Interfaces to ClockTime Data
+  
+  ! Resets timer to zero
+  interface set
+     module procedure setTime
+  end interface
+  
+  ! Returns elapsed time
+  interface get
+     module procedure getTime
+  end interface
+  
+  ! Prints total elapsed time
+  interface printTime
+     module procedure printTime
+  end interface
+
+  ! Prints total remaining time
+  interface printRemainingTime
+    module procedure PrintTimeSecondsHoursDays
+  end interface
+  
+  ! Predicts total elapsed time 
+  interface predict
+     module procedure PredictTime
+  end interface
+
+  private :: setTime, getTime, PredictTime, PrintTimeSecondsHoursDays
+
+contains
+
+  ! Resets timer to zero
+  subroutine setTime(this)
+    implicit none
+    type (ClockTime)   :: this
+    ! CPU_TIME is the system's clock time function 
+    CALL CPU_TIME ( this%time_begin )
+  end subroutine setTime
+
+  ! Returns elapsed time
+  function getTime(this)
+    implicit none
+    real(SP) :: getTime, time_end
+    type (ClockTime)   :: this
+    CALL CPU_TIME ( time_end )
+    getTime=time_end - this%time_begin
+  end function getTime
+
+  ! Prints total elapsed time
+  subroutine printTime(this)
+    implicit none
+    type (ClockTime)   :: this
+    write(*,'(/ '' Operation time '', f8.3, '' seconds.'')') getTime(this)
+  end subroutine printTime
+
+  ! Predicts remaining time before completion
+  function PredictTime(this,CompletionRatio)
+    implicit none
+    real(SP) :: PredictTime
+    type (ClockTime) :: this
+    real(SP)   :: CompletionRatio
+    ! Definitions:
+    ! CompletionRatio = Ratio of Completed Tasks to Total Tasks
+    ! Time_Remaining = Time_TotalPredicted - Time_elapsed 
+    !                = Time_elapsed/CompletionRatio*(1-CompletionRatio)
+    PredictTime = getTime(this)*(1-CompletionRatio)/CompletionRatio
+  end function PredictTime
+
+  ! Pretty Prints remaining time
+  subroutine PrintTimeSecondsHoursDays(this, PredictionRatio)
+    ! Choose to output either seconds, hours or days depending on magnitude
+    implicit none    
+    type (ClockTime)   :: this    
+    real(SP) :: PredictionRatio
+    real(SP) :: Seconds
+    
+    Seconds = PredictTime(this,PredictionRatio)
+    
+    if(Seconds<PrintMaxSeconds)then
+        ! Seconds
+        write(*,'(  f5.1 , '' seconds'')',advance='no') Seconds
+    elseif(Seconds<PrintMaxMinutes)then
+        ! Minutes
+        write(*,'(  f5.1 , '' minutes'')',advance='no') Seconds/SecondsPerMinutes
+    elseif(Seconds<PrintMaxHours)then
+        ! Hours
+        write(*,'(  f5.1 , '' hours'')',advance='no') Seconds/SecondsPerMinutes/MinutesPerHour
+    else
+        ! Days
+        write(*,'(  f5.1 , '' days'')',advance='no') Seconds/SecondsPerMinutes/MinutesPerHour/HoursPerDay
+    endif
+        
+  end subroutine
+
+end module

PowerEditor/Test/FunctionList/fortran77/unitTest.expected.result

@@ -0,0 +1 @@
+{"leaves":["printtext"],"root":"unitTest"}

PowerEditor/Test/FunctionList/fortran77/unittest

@@ -0,0 +1,17 @@
+       program hello_world3
+       implicit none
+       character*32 text
+c
+       text = 'Hello World'
+c
+       call printtext(text)
+
+       end
+
+       subroutine printtext(tekst)
+       implicit none
+       character*32 tekst
+c
+       write (*,*) tekst
+c
+       end

PowerEditor/Test/FunctionList/haskell/unitTest.expected.result

@@ -0,0 +1 @@
+{"leaves":["main","getAllUsernames","getAllUserIds","getUsernameById","sql"],"root":"unitTest"}

PowerEditor/Test/FunctionList/haskell/unittest

@@ -0,0 +1,116 @@
+-- Necessary:
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TypeFamilies #-}
+
+-- Incidental:
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+module Main where
+
+import Control.Monad
+import Data.Hashable
+import Data.List
+import Data.Text (Text)
+import Data.Traversable (for)
+import Data.Typeable
+import Haxl.Core
+import System.Random
+
+import qualified Data.Text as Text
+
+main :: IO ()
+main = do
+  let stateStore = stateSet UserState{} stateEmpty
+  env0 <- initEnv stateStore ()
+  names <- runHaxl env0 getAllUsernames
+  print names
+
+-- Data source API.
+
+getAllUsernames :: Haxl [Name]
+getAllUsernames = do
+  userIds <- getAllUserIds
+  for userIds $ \userId -> do
+    getUsernameById userId
+
+getAllUserIds :: Haxl [Id]
+getAllUserIds = dataFetch GetAllIds
+
+getUsernameById :: Id -> Haxl Name
+getUsernameById userId = dataFetch (GetNameById userId)
+
+-- Aliases.
+
+type Haxl = GenHaxl () ()
+type Id = Int
+type Name = Text
+
+-- Data source implementation.
+
+data UserReq a where
+  GetAllIds   :: UserReq [Id]
+  GetNameById :: Id -> UserReq Name
+  deriving (Typeable)
+
+deriving instance Eq (UserReq a)
+instance Hashable (UserReq a) where
+   hashWithSalt s GetAllIds       = hashWithSalt s (0::Int)
+   hashWithSalt s (GetNameById a) = hashWithSalt s (1::Int, a)
+
+deriving instance Show (UserReq a)
+instance ShowP UserReq where showp = show
+
+instance StateKey UserReq where
+  data State UserReq = UserState {}
+
+instance DataSourceName UserReq where
+  dataSourceName _ = "UserDataSource"
+
+instance DataSource u UserReq where
+  fetch _state _flags _userEnv = SyncFetch $ \blockedFetches -> do
+    let
+      allIdVars :: [ResultVar [Id]]
+      allIdVars = [r | BlockedFetch GetAllIds r <- blockedFetches]
+
+      idStrings :: [String]
+      idStrings = map show ids
+
+      ids :: [Id]
+      vars :: [ResultVar Name]
+      (ids, vars) = unzip
+        [(userId, r) | BlockedFetch (GetNameById userId) r <- blockedFetches]
+
+    unless (null allIdVars) $ do
+      allIds <- sql "select id from ids"
+      mapM_ (\r -> putSuccess r allIds) allIdVars
+
+    unless (null ids) $ do
+      names <- sql $ unwords
+        [ "select name from names where"
+        , intercalate " or " $ map ("id = " ++) idStrings
+        , "order by find_in_set(id, '" ++ intercalate "," idStrings ++ "')"
+        ]
+      mapM_ (uncurry putSuccess) (zip vars names)
+
+-- Mock SQL API.
+
+class SQLResult a where
+  mockResult :: IO a
+
+instance SQLResult a => SQLResult [a] where
+  mockResult = replicateM 10 mockResult
+
+instance SQLResult Name where
+  -- An infinite number of employees, all named Jim.
+  mockResult = ("Jim" `Text.append`) . Text.pack . show <$> randomRIO (1::Int, 100)
+
+instance SQLResult Id where
+  mockResult = randomRIO (1, 100)
+
+sql :: SQLResult a => String -> IO a
+sql query = print query >> mockResult

PowerEditor/Test/FunctionList/rust/unitTest

@@ -0,0 +1,77 @@
+// Unlike C/C++, there's no restriction on the order of function definitions
+fn main() {
+    // We can use this function here, and define it somewhere later
+    fizzbuzz_to(100);
+}
+
+// Function that returns a boolean value
+fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
+    // Corner case, early return
+    if rhs == 0 {
+        return false;
+    }
+
+    // This is an expression, the `return` keyword is not necessary here
+    lhs % rhs == 0
+}
+
+// Functions that "don't" return a value, actually return the unit type `()`
+fn fizzbuzz(n: u32) -> () {
+    if is_divisible_by(n, 15) {
+        println!("fizzbuzz");
+    } else if is_divisible_by(n, 3) {
+        println!("fizz");
+    } else if is_divisible_by(n, 5) {
+        println!("buzz");
+    } else {
+        println!("{}", n);
+    }
+}
+
+// When a function returns `()`, the return type can be omitted from the
+// signature
+fn fizzbuzz_to(n: u32) {
+    for n in 1..n + 1 {
+        fizzbuzz(n);
+    }
+}
+
+async fn async_example(n: u32) {
+    for n in 1..n + 1 {
+        fizzbuzz(n);
+    }
+}
+
+const fn const_example(n: u32) {
+    for n in 1..n + 1 {
+        fizzbuzz(n);
+    }
+}
+
+extern "Rust" fn foo() {}
+
+unsafe fn unsafe_example(n: u32) {
+    for n in 1..n + 1 {
+        fizzbuzz(n);
+    }
+}
+
+// Declares a function with the "C" ABI
+extern "C" fn new_i32() -> i32 { 0 }
+
+// Declares a function with the "stdcall" ABI
+extern   "stdcall" fn new_i32_stdcall() -> i32 { 0 }
+
+async fn regular_example() { }
+async unsafe fn unsafe_example() { }
+
+const fn generic_example<'a>(x: &'a str) -> impl Future<Output = usize> + 'a {
+    async move { x.len() }
+}
+
+fn generic_example2<const N: usize>(arr: [i32; N]) {
+    // Used as a type within a function body.
+    let x: [i32; N];
+    // Used as an expression.
+    println!("{}", N * 2);
+}

PowerEditor/Test/FunctionList/rust/unitTest.expected.result

@@ -0,0 +1 @@
+{"leaves":["main","is_divisible_by","fizzbuzz","fizzbuzz_to","async_example","const_example","foo","unsafe_example","new_i32","new_i32_stdcall","regular_example","unsafe_example","generic_example","generic_example2"],"root":"unitTest"}

PowerEditor/installer/functionList/ada.xml

@@ -0,0 +1,86 @@
+<?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>
+		<!--
+		|   Based on:
+		|       http://stackoverflow.com/questions/32126855/notepad-and-ada
+		\-->
+		<parser
+			displayName="ADA"
+			id         ="ada_syntax"
+			commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
+							(?m-s:-{2}.*?$)                                 # Single Line Comment
+						"
+		>
+			<function
+				mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
+						^\h*                                                # optional leading whitespace at start-of-line
+						(?:
+							(?-i:function)
+							\s+
+							(?'VALID_ID'                                    # valid identifier, use as subroutine
+								\b(?!(?-i:                                  # keywords (case-sensitive), not to be used as identifier
+									a(?:b(?:ort|s(?:tract)?)|cce(?:pt|ss)|l(?:iased|l)|nd|rray|t)
+								|	b(?:egin|ody)
+								|	c(?:ase|onstant)
+								|	d(?:eclare|el(?:ay|ta)|igits|o)
+								|	e(?:ls(?:e|if)|n(?:d|try)|x(?:ception|it))
+								|	f(?:or|unction)
+								|	g(?:eneric|oto)
+								|	i(?:[fs]|n(?:terface)?)
+								|	l(?:imited|oop)
+								|	mod
+								|	n(?:ew|ot|ull)
+								|	o(?:[fr]|thers|ut|verriding)
+								|	p(?:ackage|r(?:agma|ivate|o(?:cedure|tected)))
+								|	r(?:a(?:is|ng)e|e(?:cord|m|names|queue|turn|verse))
+								|	s(?:e(?:lect|parate)|ome|ubtype|ynchronized)
+								|	t(?:a(?:gged|sk)|erminate|hen|ype)
+								|	u(?:ntil|se)
+								|	w(?:h(?:en|ile)|ith)
+								|	xor
+								)\b)
+								[A-Za-z_]\w*                                # valid character combination for identifiers
+							)
+							(?'PARAMETERS'
+								\s*
+								\(                                          # start-of-parameters indicator
+								[^()]*                                      # parameters
+								\)                                          # end-of-parameters indicator
+							)?                                              # parentheses and parameters optional
+							\s*return                                       # function returns a value with...
+							\s+(?&amp;VALID_ID)                             # ...type-name
+						|
+							(?-i:procedure)
+							\s+(?&amp;VALID_ID)
+							(?:(?&amp;PARAMETERS))?                         # Boost::Regex 1.58-1.59 do not correctly handle quantifiers on subroutine calls
+						)
+						\s*(?-i:\bis\b)                                     # end-of-definition indicator
+					"
+			>
+				<functionName>
+					<nameExpr expr="(?x)                                    # free-spacing (see `RegEx - Pattern Modifiers`)
+							(?:function|procedure)\s+
+							\K                                              # discard text matched so far
+							[A-Za-z_]\w*
+							(?:\s*\([^()]*\))?                              # parentheses and parameters optional
+							(?=
+								\s*
+								\b(?:return|is)
+							)
+						"
+					/>
+					<!-- comment out the following node to display the method with its parameters -->
+<!--						<nameExpr expr="[A-Za-z_]\w*" /> -->
+				</functionName>
+			</function>
+		</parser>
+	</functionList>
+</NotepadPlus>

PowerEditor/installer/functionList/fortran.xml

@@ -0,0 +1,49 @@
+<?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>
+		<!--
+		|   Based on:
+		|       https://notepad-plus-plus.org/community/topic/11059/custom-functions-list-rules
+		|       https://notepad-plus-plus.org/community/topic/13553/functionlist-xml-regular-expressions-not-parsing-properly
+		\-->
+		<parser
+			displayName="Fortran Free Form style - FORmula TRANslation"
+			id         ="fortran_freeform"
+			commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
+							(?m-s:!.*$)                                     # Single Line Comment
+						"
+		>
+			<function
+				mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
+						(?im-s)                                             # case-insensitive, ^ and $ match at line breaks, dot does not
+						^\h*                                                # optional leading whitespace at start-of-line
+						(?:
+							(?:
+								ELEMENTAL
+							|	(?:IM)?PURE
+							|	MODULE
+							|	(?:NON_)?RECURSIVE
+							)
+							\s+
+						)*
+						(?:FUNCTION|SUBROUTINE)\s+
+						\K                                                  # discard text matched so far
+						[A-Z]\w{0,62}                                       # valid character combination for identifiers
+						(?:\s*\([^()]*\))?                                  # optional paramater list
+					"
+			>
+				<!-- comment out the following node to display the method with its parameters -->
+				<functionName>
+					<nameExpr expr="\w+" />
+				</functionName>
+			</function>
+		</parser>
+	</functionList>
+</NotepadPlus>

PowerEditor/installer/functionList/fortran77.xml

@@ -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>
+		<parser
+			displayName="Fortran Fixed Form style - FORmula TRANslation"
+			id         ="fortran_fixedform"
+			commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
+							(?m-s:(?:!|^[Cc*].*$)                           # Single Line Comment 1..3
+						"
+		>
+			<function
+				mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
+						(?im-s)                                             # case-insensitive, ^ and $ match at line breaks, dot does not
+						^\h*                                                # optional leading whitespace at start-of-line
+						(?:FUNCTION|SUBROUTINE)\s+
+						\K                                                  # discard text matched so far
+						[A-Z]\w{0,62}                                       # valid character combination for identifiers
+						(?:\s*\([^()]*\))?                                  # optional paramater list
+					"
+			>
+				<!-- comment out the following node to display the method with its parameters -->
+				<functionName>
+					<nameExpr expr="\w+" />
+				</functionName>
+			</function>
+		</parser>
+	</functionList>
+</NotepadPlus>

PowerEditor/installer/functionList/haskell.xml

@@ -0,0 +1,51 @@
+<?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>
+		<!--
+		|   Based on:
+		|       https://notepad-plus-plus.org/community/topic/12972/trouble-with-defining-a-function-list-entry/7
+		|
+		|   By convention, the style of comment is indicated by the file extension,
+		|   with ".hs"  indicating a "usual"  Haskell file
+		|   and  ".lhs" indicating a literate Haskell file.
+		\-->
+		<parser
+			displayName="Haskell"
+			id         ="haskell_function"
+			commentExpr="(?x)                                               # free-spacing (see `RegEx - Pattern Modifiers`)
+							(?s:                                            # Multi Line Comment (nesting allowed)
+								\{-                                         # - start-of-comment indicator
+								(?>                                         # - followed by zero or more characters...
+									[^{-]                                   #   ...not part of the start indicator,
+								|	\{(?!-)                                 #   ...not being a start-of-comment indicator,
+								|	-(?!\})                                 #   ...not being an end-of-comment indicator and
+								|	(?R)                                    #   ...balancing through recursion (nesting)
+								)*
+								-\}                                         # - end-of-comment indicator
+							)
+						|	(?m-s:-{2}.*?$)                                 # Single Line Comment
+						"
+		>
+			<function
+				mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
+						(?m-s)                                              # ^ and $ match at line breaks, dot does not
+						^                                                   # NO leading whitespace at start-of-line
+						[A-Za-z][\w\x27]*                                   # valid character combination for identifiers
+						\x20+::\x20
+						.*?$                                                # whatever, until end-of-line
+					"
+			>
+				<functionName>
+					<nameExpr expr="[A-Za-z][\w\x27]*" />
+				</functionName>
+			</function>
+		</parser>
+	</functionList>
+</NotepadPlus>

PowerEditor/installer/functionList/rust.xml

@@ -0,0 +1,46 @@
+<?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="Rust"
+			id         ="rust_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
+						"
+		>
+			<function
+				mainExpr="(?x)                                              # free-spacing (see `RegEx - Pattern Modifiers`)
+						^\h*                                                # optional leading whitespace at start-of-line
+						(?:
+							(?-i:
+								async
+							|	const
+							|	(?-i:extern\s+(?s:\x22(?:[^\x22\x5C]|\x5C.)*\x22))
+							|	unsafe
+							)
+							\s+
+						)*
+						(?-i:fn)\s+
+						\K                                                  # discard text matched so far
+						(?:[a-zA-Z][a-zA-Z0-9_]*|_[a-zA-Z0-9_]+)            # valid character combination for identifiers
+						(?:&lt;.*$gt;)?                                     # optional generic params
+						(?:\s*\([^()]*\))?                                  # optional parameter list
+					"
+			>
+				<!-- comment out the following node to display the method with its parameters -->
+				<functionName>
+					<nameExpr expr="\w+" />
+				</functionName>
+			</function>
+		</parser>
+	</functionList>
+</NotepadPlus>

PowerEditor/installer/nsisInclude/functionList.nsh

@@ -17,12 +17,12 @@
 
 SectionGroup "Function List Files" functionListComponent
 	SetOverwrite on
-	
+
 	${MementoSection} "C" C_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\c.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "C++" C++_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\cpp.xml"
@@ -37,22 +37,22 @@ SectionGroup "Function List Files" functionListComponent
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\cs.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "Assembly" Assembly_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\asm.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "Bash" Bash_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\bash.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "SQL" SQL_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\sql.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "PHP" PHP_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\php.xml"
@@ -72,7 +72,7 @@ SectionGroup "Function List Files" functionListComponent
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\perl.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "JavaScript" JavaScript_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\javascript.js.xml"
@@ -82,32 +82,32 @@ SectionGroup "Function List Files" functionListComponent
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\python.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "ini" ini_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\ini.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "Inno Setup" Innosetup_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\inno.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "VHDL" VHDL_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\vhdl.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "KRL" KRL_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\krl.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "NSIS" NSIS_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\nsis.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "PowerShell" PowerShell_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\powershell.xml"
@@ -117,7 +117,7 @@ SectionGroup "Function List Files" functionListComponent
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\batch.xml"
 	${MementoSectionEnd}
-	
+
 	${MementoSection} "Ruby" Ruby_FL
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\ruby.xml"
@@ -147,7 +147,32 @@ SectionGroup "Function List Files" functionListComponent
 		SetOutPath "$INSTDIR\functionList"
 		File ".\functionList\xml.xml"
 	${MementoSectionEnd}
-	
+
+	${MementoSection} "Ada" Ada_FL
+		SetOutPath "$INSTDIR\functionList"
+		File ".\functionList\ada.xml"
+	${MementoSectionEnd}
+
+	${MementoSection} "Fortan" Fortan_FL
+		SetOutPath "$INSTDIR\functionList"
+		File ".\functionList\fortan.xml"
+	${MementoSectionEnd}
+
+	${MementoSection} "Fortan77" Fortan77_FL
+		SetOutPath "$INSTDIR\functionList"
+		File ".\functionList\fortan77.xml"
+	${MementoSectionEnd}
+
+	${MementoSection} "Haskell" Haskell_FL
+		SetOutPath "$INSTDIR\functionList"
+		File ".\functionList\haskell.xml"
+	${MementoSectionEnd}
+
+	${MementoSection} "Rust" Rust_FL
+		SetOutPath "$INSTDIR\functionList"
+		File ".\functionList\rust.xml"
+	${MementoSectionEnd}
+
 	SetOverwrite off
 	${MementoSection} "Override Map" OverrideMap_FL
 		SetOutPath "$INSTDIR\functionList"
@@ -161,15 +186,15 @@ SectionGroup un.functionListComponent
 	Section un.PHP_FL
 		Delete "$INSTDIR\functionList\php.xml"
 	SectionEnd
-	
+
 	Section un.Assembly_FL
 		Delete "$INSTDIR\functionList\asm.xml"
 	SectionEnd
-	
+
 	Section un.SQL_FL
 		Delete "$INSTDIR\functionList\sql.xml"
 	SectionEnd
-	
+
 	Section un.Bash_FL
 		Delete "$INSTDIR\functionList\bash.xml"
 	SectionEnd
@@ -185,19 +210,19 @@ SectionGroup un.functionListComponent
 	Section un.C_FL
 		Delete "$INSTDIR\functionList\c.xml"
 	SectionEnd
-	
+
 	Section un.C++_FL
 		Delete "$INSTDIR\functionList\cpp.xml"
 	SectionEnd
-	
+
 	Section un.Java_FL
 		Delete "$INSTDIR\functionList\java.xml"
 	SectionEnd
-	
+
 	Section un.C#_FL
 		Delete "$INSTDIR\functionList\cs.xml"
 	SectionEnd
-	
+
 	Section un.JavaScript_FL
 		Delete "$INSTDIR\functionList\javascript.js.xml"
 	SectionEnd
@@ -209,27 +234,27 @@ SectionGroup un.functionListComponent
 	Section un.COBOL_FL
 		Delete "$INSTDIR\functionList\cobol.xml"
 	SectionEnd
-	
+
 	Section un.ini_FL
 		Delete "$INSTDIR\functionList\ini.xml"
 	SectionEnd
-	
+
 	Section un.VHDL_FL
 		Delete "$INSTDIR\functionList\vhdl.xml"
-	SectionEnd	
+	SectionEnd
-	
+
 	Section un.Innosetup_FL
 		Delete "$INSTDIR\functionList\inno.xml"
 	SectionEnd
-	
+
 	Section un.XML_FL
 		Delete "$INSTDIR\functionList\xml.xml"
 	SectionEnd
-	
+
 	Section un.NSIS_FL
 		Delete "$INSTDIR\functionList\nsis.xml"
 	SectionEnd
-	
+
 	Section un.KRL_FL
 		Delete "$INSTDIR\functionList\krl.xml"
 	SectionEnd
@@ -237,7 +262,7 @@ SectionGroup un.functionListComponent
 	Section un.BATCH_FL
 		Delete "$INSTDIR\functionList\batch.xml"
 	SectionEnd
-	
+
 	Section un.OverrideMap_FL
 		Delete "$INSTDIR\functionList\overrideMap.xml"
 	SectionEnd
@@ -266,4 +291,25 @@ SectionGroup un.functionListComponent
 		Delete "$INSTDIR\functionList\sinumerik.xml"
 	SectionEnd
 
+	Section un.Ada_FL
+		Delete "$INSTDIR\functionList\ada.xml"
+	SectionEnd
+
+	Section un.Fortan_FL
+		Delete "$INSTDIR\functionList\fortan.xml"
+	SectionEnd
+
+	Section un.Fortan77_FL
+		Delete "$INSTDIR\functionList\fortan77.xml"
+	SectionEnd
+
+	Section un.Haskell_FL
+		Delete "$INSTDIR\functionList\haskell.xml"
+	SectionEnd
+
+	Section un.Rust_FL
+		Delete "$INSTDIR\functionList\rust.xml"
+	SectionEnd
+
+
 SectionGroupEnd