Merge branch 'release/1.0.5'

Author: samharrison7

.gitignore

@@ -2,6 +2,9 @@
 makefile
 Makefile
 
+# Build dirs
+build*/
+
 # Sublime Text and Visual Studio project files
 *.sublime-project
 *.sublime-workspace
@@ -57,4 +60,3 @@ snip/
 *.out
 *.app
 bin/
-build/

CHANGELOG.md

@@ -3,6 +3,17 @@ Notable changes to the Fortran Error Handler are documented here.
 
 ## [Unreleased]
 
+## [1.0.5] - 2023-05-31
+
+### Added
+- [meson.build](./meson.build) file to enable builds using meson. Added details to README.md.
+
+### Removed
+- Removed need to specify `-fbackslash` (or equivalent for other compilers) by using `char(27)` for terminal escape character.
+
+### Fixed
+- Removed whitespace in `fpm.toml` file table names to make compatible with latest fpm versions.
+
 ## [1.0.4] - 2022-01-02
 
 ### Fixed
@@ -31,7 +42,8 @@ No changes to code. Release is only to archive on Zenodo.
 ### Added
 - First major release.
 
-[Unreleased]: https://github.com/samharrison7/fortran-error-handler/compare/1.0.4...HEAD 
+[Unreleased]: https://github.com/samharrison7/fortran-error-handler/compare/1.0.5...HEAD 
+[1.0.5]: https://github.com/samharrison7/fortran-error-handler/releases/tag/1.0.5
 [1.0.4]: https://github.com/samharrison7/fortran-error-handler/releases/tag/1.0.4
 [1.0.3]: https://github.com/samharrison7/fortran-error-handler/releases/tag/1.0.3
 [1.0.2]: https://github.com/samharrison7/fortran-error-handler/releases/tag/1.0.2

CMakeLists.txt

@@ -4,10 +4,10 @@ project(fortran_error_handler)
 enable_language(Fortran)
 
 if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
-    set(FLAGS "-O3 -fcheck=all -fbackslash -ffpe-trap=zero,invalid,overflow")
+    set(FLAGS "-O3 -fcheck=all -ffpe-trap=zero,invalid,overflow")
 endif()
 if(CMAKE_Fortran_COMPILER_ID MATCHES "Intel")
-    set(FLAGS "/O3 /fpe:0 /assume:bscc")
+    set(FLAGS "/O3 /fpe:0")
 endif()
 
 set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${FLAGS}")

Makefile.example

@@ -1,6 +1,6 @@
 FC=gfortran
 WARNINGS = -Wall
-FCFLAGS = -O1 -fcheck=all -fbackslash -fopenmp ${WARNINGS}
+FCFLAGS = -O1 -fcheck=all -fopenmp ${WARNINGS}
 DEBUGFLAGS = -g -ffpe-trap=zero,invalid,overflow,underflow -pg
 EXEC_FILE = main
 EXEC_PATH = ./bin/
@@ -21,12 +21,6 @@ VPATH = src \
 #   make main: Compile and create exe.
 #   make run: Run the compiled exe.
 #   make clean: Remove compiled files.
-#   
-#   GFortran bug causes "character length mismatch in array constructor"
-#   errors with allocatable character variables, even when they're the correct length.
-#   -O1 or higher must be used. See
-#   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70231 and
-#   https://stackoverflow.com/questions/44385909/adding-to-an-array-of-characters-in-fortran.
 $(EXEC_FILE): $(OBJECTS)
 	$(FC) $(FCFLAGS) $(DEBUGFLAGS) -o $(EXEC_PATH)$@ $^
 %.o: %.f90

README.md

@@ -15,7 +15,7 @@ Fortran error handling frameworks are few and far between, and those that do exi
 <a name="getting-started"></a>
 ## Getting started
 
-There are a few ways to get the Fortran Error Handler into your project.
+There are a few ways to get the Fortran Error Handler into your project. The following have been tested with recent version of the GFortran and Intel Fortran compiler (`ifort`, not `ifx`).
 
 ### `fpm` - Fortran Package Manager
 
@@ -31,15 +31,14 @@ Or you can clone the repo and build the library yourself using fpm:
 ```bash
 $ git clone https://github.com/samharrison7/fortran-error-handler
 $ cd fortran-error-handler
-$ fpm build --flag="-fbackslash"
+$ fpm build
 ```
 
-A static library (e.g. `libfeh.a` on Linux) and `.mod` files will be generated in the `build` directory for you to use. An example executable (using `example/example_usage.f90`) will also be generated. Running `fpm test` will run tests (using `tests/run_tests.f90`) for the framework. The `-fbackslash` flag is a GFortran flag to enable coloured terminal output, and is only needed if the `bashColors` option is `.true.` (default). The equivalent `ifort` flag is `/assume:bscc`.
-
+A static library (e.g. `libfeh.a` on Linux) and `.mod` files will be generated in the `build` directory for you to use. An example executable (using `example/example_usage.f90`) will also be generated. Running `fpm test` will run tests (using `tests/run_tests.f90`) for the framework. 
 You can also get fpm to install the Fortran Error Handler locally (e.g. to `/home/<user>/.local`):
 
 ```bash
-$ fpm install --flag="-fbackslash"
+$ fpm install
 ```
 
 Fpm can easily be installed using Conda: `conda install -c conda-forge fpm`.
@@ -48,9 +47,29 @@ Fpm can easily be installed using Conda: `conda install -c conda-forge fpm`.
 
 Another simple method is to simple grab a copy of the source files (in `src/`) and include at the start of your compilation setup. Source files should be compiled in this order: `ErrorInstance.f90`, `ErrorHandler.f90`, `ErrorCriteria.f90`, `Result.f90`. An example [Makefile.example](./Makefile.example) is included, which can be altered according to your compiler and preferences. 
 
-### `cmake`
+### Meson
 
-The code can also be compiled using `cmake`, which generates a library and `.mod` files, an example executable, and executable of unit tests.
+If you use [meson](https://mesonbuild.com/), a [meson.build](./meson.build) file is provided. For example, if you want to build into the `buildmeson` directory:
+
+```bash
+$ meson buildmeson
+$ ninja -C buildmeson
+```
+
+From meson 0.56, you can use the `meson compile` command instead of `ninja`. This will generate the example and test executables, a shared library and module files. You can run the tests directly using meson: `meson test -C buildmeson`.
+
+By default, the library is built with a debug build type. To build for release (with `-O3` optimisations), specify this via the `--buildtype=release` option:
+
+```bash
+$ meson buildrelease --buildtype=release
+$ ninja -C buildrelease
+```
+
+Installing using meson (`meson install`) isn't recommended at the moment as `.mod` files are not installed - see [this issue](https://github.com/mesonbuild/meson/issues/5374).
+
+### CMake
+
+The code can also be compiled using CMake, which similarly generates a library and `.mod` files, an example executable, and executable of unit tests.
 
 ```bash
 $ mkdir build
@@ -63,8 +82,6 @@ $ ./test
 $ ./example
 ```
 
-The framework has been tested using GFortran 7 upwards and Intel Fortran 18.
-
 <a name="usage"></a>
 ## Usage
 
@@ -187,9 +204,6 @@ Explore the documentation for each class to learn how to best use the framework,
 ## Caveats and limitations <a name="caveats"></a>
 
 - Error code must be less than 99999.
-- GFortran bugs:
-    - `-O1` or higher must be used to avoid "character length mismatch in array constructor" errors with allocatable character variables.
-    - `-fcheck=no-bounds` must be used to avoid errors on allocating rank-2 or higher arrays.
 - Result objects only support up to rank-4 (4 dimensional) data.
 - Limited support for different kinds, due to Fortran's lack of kind polymorphism. In particular, ErrorCriteria only accept 4-byte integers and single precision, double precision and quadruple precision reals, as such:
 

codemeta.json

@@ -41,11 +41,11 @@
   "identifier": "",
   "codeRepository": "https://github.com/samharrison7/fortran-error-handler",
   "datePublished": "2020-06-05",
-  "dateModified": "2020-06-05",
+  "dateModified": "2023-05-31",
   "dateCreated": "2020-06-05",
   "description": "Comprehensive error framework for applications requiring functional and robust error handling, utilising the power of modern object-oriented Fortran.",
   "keywords": "Fortran, error handling",
   "license": "MIT",
   "title": "Fortran Error Handler",
-  "version": "v1.0.3"
+  "version": "v1.0.5"
 }

fpm.toml

@@ -1,16 +1,16 @@
 name = "feh"
-version = "1.0.4"
+version = "1.0.5"
 license = "MIT"
 author = "Sam Harrison"
 maintainer = "[email protected]"
 copyright = "Copyright 2022, Sam Harrison"
 
-[[ example ]]
+[[example]]
 name = "example"
 source-dir = "example"
 main = "example_usage.f90"
 
-[[ test ]]
+[[test]]
 name = "tests"
 source-dir = "tests"
 main = "run_tests.f90"

meson.build

@@ -0,0 +1,31 @@
+project('feh', 'fortran', meson_version: '>=0.50')
+
+# Compiler flags
+flags = ''
+if meson.get_compiler('fortran').get_id() == 'gcc'
+    flags = ['-fbacktrace']
+endif
+if meson.get_compiler('fortran').get_id() == 'intel'
+    flags = ['-traceback']
+endif
+add_global_arguments(flags, language : 'fortran')
+
+# Files that are common to all build
+files = ['src/ErrorInstance.f90', 'src/ErrorHandler.f90',
+         'src/ErrorCriteria.f90', 'src/Result.f90']
+
+# Add example executable
+executable('example', files(files + ['example/example_usage.f90']))
+
+# Add an exe for the test
+test = executable('testexe', files(files + ['tests/assert.f90',
+                                   'tests/util.f90',
+                                   'tests/tests_ErrorCriteria.f90',
+                                   'tests/tests_ErrorInstance.f90',
+                                   'tests/tests_Result.f90',
+                                   'tests/run_tests.f90']))
+# Create the test itself
+test('test', test)
+
+# Add the library and make it installable
+library('feh', files, install : true)

src/ErrorHandler.f90

@@ -67,18 +67,22 @@ subroutine initErrorHandler(this, &
                         printErrorCode, &
                         triggerWarnings, &
                         on)
-            class(ErrorHandler), intent(inout)          :: this             !! This ErrorHandler instance
-            type(ErrorInstance), intent(in), optional   :: errors(:)        !! List of ErrorInstances to add
-            character(len=*), intent(in), optional      :: criticalPrefix   !! Prefix for error messages if they're critical
-            character(len=*), intent(in), optional      :: warningPrefix    !! Prefix for error messages if they're warnings
-            character(len=*), intent(in), optional      :: messageSuffix    !! Suffix for error messages
-            logical, intent(in), optional               :: bashColors       !! Use bash colours or not?
-            logical, intent(in), optional               :: printErrorCode   !! Should the error code be prepended to the prefix?
-            logical, intent(in), optional               :: triggerWarnings  !! Should warnings be printed on trigger?
-            logical, intent(in), optional               :: on               !! Turn the ErrorHandler on or off
-            integer                                     :: i                ! Loop iterator.
-            logical, allocatable                        :: mask(:)          ! Logical mask to remove default errors from input errors array.
-            type(ErrorInstance)                         :: defaultErrors(2) ! Temporary array containing default errors.
+            class(ErrorHandler), intent(inout)          :: this                     !! This ErrorHandler instance
+            type(ErrorInstance), intent(in), optional   :: errors(:)                !! List of ErrorInstances to add
+            character(len=*), intent(in), optional      :: criticalPrefix           !! Prefix for error messages if they're critical
+            character(len=*), intent(in), optional      :: warningPrefix            !! Prefix for error messages if they're warnings
+            character(len=*), intent(in), optional      :: messageSuffix            !! Suffix for error messages
+            logical, intent(in), optional               :: bashColors               !! Use bash colours or not?
+            logical, intent(in), optional               :: printErrorCode           !! Should the error code be prepended to the prefix?
+            logical, intent(in), optional               :: triggerWarnings          !! Should warnings be printed on trigger?
+            logical, intent(in), optional               :: on                       !! Turn the ErrorHandler on or off
+            integer                                     :: i                        ! Loop iterator.
+            logical, allocatable                        :: mask(:)                  ! Logical mask to remove default errors from input errors array.
+            type(ErrorInstance)                         :: defaultErrors(2)         ! Temporary array containing default errors.
+            character(len=*), parameter                 :: ESC = char(27)           ! Terminal escape character
+            character(len=*), parameter                 :: COLOR_RED = ESC//"[91m"  ! Escape sequence for red text
+            character(len=*), parameter                 :: COLOR_BLUE = ESC//"[94m" ! Escape sequence for blue text
+            character(len=*), parameter                 :: COLOR_RESET = ESC//"[0m" ! Escape sequence to reset text color
 
             ! Stop the program running is ErrorHandler is already initialised
             call this%stopIfInitialised()
@@ -137,8 +141,8 @@ subroutine initErrorHandler(this, &
 
             ! Set whether bash colors wanted or not, and add them to prefixes if so
             if (present(bashColors)) this%bashColors = bashColors
-            if (this%bashColors .eqv. .true.) this%criticalPrefix = "\x1B[91m" // adjustl(trim(this%criticalPrefix)) // "\x1B[0m"
-            if (this%bashColors .eqv. .true.) this%warningPrefix = "\x1B[94m" // adjustl(trim(this%warningPrefix)) // "\x1B[0m"
+            if (this%bashColors .eqv. .true.) this%criticalPrefix = COLOR_RED // adjustl(trim(this%criticalPrefix)) // COLOR_RESET
+            if (this%bashColors .eqv. .true.) this%warningPrefix = COLOR_BLUE // adjustl(trim(this%warningPrefix)) // COLOR_RESET
 
             ! Set whether we want the error code to be prefixed to the message and whether
             ! we want warnings to be triggered