From 4cdd96f0203867472b927663072237d5ffb0c15e Mon Sep 17 00:00:00 2001 From: Christian Grasser Date: Thu, 25 Mar 2021 23:22:29 +0100 Subject: [PATCH] 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 --- .../FunctionList/ada/unitTest.expected.result | 1 + PowerEditor/Test/FunctionList/ada/unittest | 43 +++++ PowerEditor/Test/FunctionList/c/unitTest | 131 +++++++++++++++ .../FunctionList/c/unitTest.expected.result | 2 +- .../fortran/unitTest.expected.result | 1 + .../Test/FunctionList/fortran/unittest | 152 ++++++++++++++++++ .../fortran77/unitTest.expected.result | 1 + .../Test/FunctionList/fortran77/unittest | 17 ++ .../haskell/unitTest.expected.result | 1 + .../Test/FunctionList/haskell/unittest | 116 +++++++++++++ PowerEditor/Test/FunctionList/rust/unitTest | 77 +++++++++ .../rust/unitTest.expected.result | 1 + PowerEditor/installer/functionList/ada.xml | 86 ++++++++++ .../installer/functionList/fortran.xml | 49 ++++++ .../installer/functionList/fortran77.xml | 35 ++++ .../installer/functionList/haskell.xml | 51 ++++++ PowerEditor/installer/functionList/rust.xml | 46 ++++++ .../installer/nsisInclude/functionList.nsh | 106 ++++++++---- 18 files changed, 885 insertions(+), 31 deletions(-) create mode 100644 PowerEditor/Test/FunctionList/ada/unitTest.expected.result create mode 100644 PowerEditor/Test/FunctionList/ada/unittest create mode 100644 PowerEditor/Test/FunctionList/fortran/unitTest.expected.result create mode 100644 PowerEditor/Test/FunctionList/fortran/unittest create mode 100644 PowerEditor/Test/FunctionList/fortran77/unitTest.expected.result create mode 100644 PowerEditor/Test/FunctionList/fortran77/unittest create mode 100644 PowerEditor/Test/FunctionList/haskell/unitTest.expected.result create mode 100644 PowerEditor/Test/FunctionList/haskell/unittest create mode 100644 PowerEditor/Test/FunctionList/rust/unitTest create mode 100644 PowerEditor/Test/FunctionList/rust/unitTest.expected.result create mode 100644 PowerEditor/installer/functionList/ada.xml create mode 100644 PowerEditor/installer/functionList/fortran.xml create mode 100644 PowerEditor/installer/functionList/fortran77.xml create mode 100644 PowerEditor/installer/functionList/haskell.xml create mode 100644 PowerEditor/installer/functionList/rust.xml diff --git a/PowerEditor/Test/FunctionList/ada/unitTest.expected.result b/PowerEditor/Test/FunctionList/ada/unitTest.expected.result new file mode 100644 index 000000000..697de6b77 --- /dev/null +++ b/PowerEditor/Test/FunctionList/ada/unitTest.expected.result @@ -0,0 +1 @@ +{"leaves":["BiSeqOut"],"root":"unitTest"} \ No newline at end of file diff --git a/PowerEditor/Test/FunctionList/ada/unittest b/PowerEditor/Test/FunctionList/ada/unittest new file mode 100644 index 000000000..4860d09b5 --- /dev/null +++ b/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) + diff --git a/PowerEditor/Test/FunctionList/c/unitTest b/PowerEditor/Test/FunctionList/c/unitTest index e69de29bb..4334b0788 100644 --- a/PowerEditor/Test/FunctionList/c/unitTest +++ b/PowerEditor/Test/FunctionList/c/unitTest @@ -0,0 +1,131 @@ +/** + * @file + * @brief Functions related to 3D quaternions and Euler angles. + * @author Krishna Vedala + */ + +#include +#ifdef __arm__ // if compiling for ARM-Cortex processors +#define LIBQUAT_ARM +#include +#else +#include +#endif +#include + +#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; +} diff --git a/PowerEditor/Test/FunctionList/c/unitTest.expected.result b/PowerEditor/Test/FunctionList/c/unitTest.expected.result index a576e1852..328df0f02 100644 --- a/PowerEditor/Test/FunctionList/c/unitTest.expected.result +++ b/PowerEditor/Test/FunctionList/c/unitTest.expected.result @@ -1 +1 @@ -{"root":"unitTest"} \ No newline at end of file +{"leaves":["quat_from_euler(const euler *in_euler)","euler_from_quat(const quaternion *in_quat)","test()","main()"],"root":"unitTest"} \ No newline at end of file diff --git a/PowerEditor/Test/FunctionList/fortran/unitTest.expected.result b/PowerEditor/Test/FunctionList/fortran/unitTest.expected.result new file mode 100644 index 000000000..bee8cffbe --- /dev/null +++ b/PowerEditor/Test/FunctionList/fortran/unitTest.expected.result @@ -0,0 +1 @@ +{"leaves":["setTime","getTime","printTime","PredictTime","PrintTimeSecondsHoursDays"],"root":"unitTest"} \ No newline at end of file diff --git a/PowerEditor/Test/FunctionList/fortran/unittest b/PowerEditor/Test/FunctionList/fortran/unittest new file mode 100644 index 000000000..27635c136 --- /dev/null +++ b/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 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 diff --git a/PowerEditor/Test/FunctionList/rust/unitTest b/PowerEditor/Test/FunctionList/rust/unitTest new file mode 100644 index 000000000..7159dce9b --- /dev/null +++ b/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 + 'a { + async move { x.len() } +} + +fn generic_example2(arr: [i32; N]) { + // Used as a type within a function body. + let x: [i32; N]; + // Used as an expression. + println!("{}", N * 2); +} diff --git a/PowerEditor/Test/FunctionList/rust/unitTest.expected.result b/PowerEditor/Test/FunctionList/rust/unitTest.expected.result new file mode 100644 index 000000000..f44f67de4 --- /dev/null +++ b/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"} \ No newline at end of file diff --git a/PowerEditor/installer/functionList/ada.xml b/PowerEditor/installer/functionList/ada.xml new file mode 100644 index 000000000..195cc4711 --- /dev/null +++ b/PowerEditor/installer/functionList/ada.xml @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/PowerEditor/installer/functionList/fortran.xml b/PowerEditor/installer/functionList/fortran.xml new file mode 100644 index 000000000..007a7014b --- /dev/null +++ b/PowerEditor/installer/functionList/fortran.xml @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/PowerEditor/installer/functionList/fortran77.xml b/PowerEditor/installer/functionList/fortran77.xml new file mode 100644 index 000000000..f991e960e --- /dev/null +++ b/PowerEditor/installer/functionList/fortran77.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/PowerEditor/installer/functionList/haskell.xml b/PowerEditor/installer/functionList/haskell.xml new file mode 100644 index 000000000..670ecab46 --- /dev/null +++ b/PowerEditor/installer/functionList/haskell.xml @@ -0,0 +1,51 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/PowerEditor/installer/functionList/rust.xml b/PowerEditor/installer/functionList/rust.xml new file mode 100644 index 000000000..e1672479e --- /dev/null +++ b/PowerEditor/installer/functionList/rust.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/PowerEditor/installer/nsisInclude/functionList.nsh b/PowerEditor/installer/nsisInclude/functionList.nsh index 80afc5ab5..2ebc671bf 100644 --- a/PowerEditor/installer/nsisInclude/functionList.nsh +++ b/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