minimap2 0.2.25.0 → 0.2.25.1

data/ext/minimap2/lib/simde/test/arm/test-arm-internal.h

@@ -0,0 +1,18 @@
+#if !defined(SIMDE_TESTS_ARM_INTERNAL_H)
+#define SIMDE_TESTS_CURRENT_ARCH arm
+
+#include "../run-tests.h"
+
+HEDLEY_BEGIN_C_DECLS
+
+#define SIMDE_TESTS_ARM_GENERATE_SUITE_GETTERS(isax) \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(void); \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, cpp)(void); \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)(void); \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   cpp)(void)
+
+SIMDE_TESTS_ARM_GENERATE_SUITE_GETTERS(neon);
+
+HEDLEY_END_C_DECLS
+
+#endif /* !defined(SIMDE_TESTS_ARM_INTERNAL_H) */

data/ext/minimap2/lib/simde/test/arm/test-arm.c

@@ -0,0 +1,20 @@
+#include "test-arm.h"
+#include "test-arm-internal.h"
+#include "neon/test-neon.h"
+
+#include <stdio.h>
+
+MunitSuite*
+simde_tests_arm_get_suite(void) {
+  static MunitSuite children[] = {
+    { NULL, NULL, NULL, 1, MUNIT_SUITE_OPTION_NONE },
+    { NULL, NULL, NULL, 1, MUNIT_SUITE_OPTION_NONE }
+  };
+  static MunitSuite suite = { HEDLEY_STATIC_CAST(char*, "/arm"), NULL, NULL, 1, MUNIT_SUITE_OPTION_NONE };
+
+  children[0] = *simde_tests_arm_neon_get_suite();
+
+  suite.suites = children;
+
+  return &suite;
+}

data/ext/minimap2/lib/simde/test/arm/test-arm.h

@@ -0,0 +1,8 @@
+#include "../../simde/hedley.h"
+#include "../munit/munit.h"
+
+HEDLEY_BEGIN_C_DECLS
+
+MunitSuite* simde_tests_arm_get_suite(void);
+
+HEDLEY_END_C_DECLS

data/ext/minimap2/lib/simde/test/cmake/AddCompilerFlags.cmake

@@ -0,0 +1,171 @@
+# This module provides a convenient way to add C/C++ compiler flags if
+# the compiler supports them.
+
+include (CheckCCompilerFlag)
+include (CheckCXXCompilerFlag)
+
+cmake_policy(SET CMP0054 NEW)
+
+# Depending on the settings, some compilers will accept unknown flags.
+# We try to disable this behavior by also passing these flags when we
+# check if a flag is supported.
+set (ADD_COMPILER_FLAGS_PREPEND "")
+
+if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
+  set (ADD_COMPILER_FLAGS_PREPEND "-Wall -Wextra -Werror")
+elseif (CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  set (ADD_COMPILER_FLAGS_PREPEND "-Werror=unknown-warning-option")
+endif ()
+
+##
+# Set a variable to different flags, depending on which compiler is in
+# use.
+#
+# Example:
+#   set_compiler_specific_flags(VARIABLE varname MSVC /wd666 INTEL /wd1729)
+#
+#   This will set varname to /wd666 if the compiler is MSVC, and /wd1729
+#   if it is Intel.
+#
+# Possible compilers:
+#  - GCC: GNU C Compiler
+#  - GCCISH: A compiler that (tries to) be GCC-compatible on the CLI
+#    (i.e., anything but MSVC).
+#  - CLANG: clang
+#  - MSVC: Microsoft Visual C++ compiler
+#  - INTEL: Intel C Compiler
+#  - PGI: PGI C Compiler
+#
+# Note: the compiler is determined based on the value of the
+# CMAKE_C_COMPILER_ID variable, not CMAKE_CXX_COMPILER_ID.
+##
+function (set_compiler_specific_flags)
+  set (oneValueArgs VARIABLE)
+  set (multiValueArgs GCC GCCISH INTEL CLANG MSVC PGI)
+  cmake_parse_arguments(COMPILER_SPECIFIC_FLAGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+  unset (options)
+  unset (oneValueArgs)
+  unset (multiValueArgs)
+
+  set (compiler_flags)
+
+  if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    list (APPEND compiler_flags ${COMPILER_SPECIFIC_FLAGS_GCC})
+  elseif(CMAKE_C_COMPILER_ID STREQUAL "Clang")
+    list (APPEND compiler_flags ${COMPILER_SPECIFIC_FLAGS_CLANG})
+  elseif(CMAKE_C_COMPILER_ID STREQUAL "Intel")
+    list (APPEND compiler_flags ${COMPILER_SPECIFIC_FLAGS_INTEL})
+  elseif(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+    list (APPEND compiler_flags ${COMPILER_SPECIFIC_FLAGS_MSVC})
+  elseif(CMAKE_C_COMPILER_ID STREQUAL "PGI")
+    list (APPEND compiler_flags ${COMPILER_SPECIFIC_FLAGS_PGI})
+  endif()
+
+  set(GCCISH_COMPILERS GNU Clang Intel)
+  list(FIND GCCISH_COMPILERS "${CMAKE_C_COMPILER_ID}" IS_GCCISH)
+  if (IS_GCCISH GREATER -1)
+    list (APPEND compiler_flags ${COMPILER_SPECIFIC_FLAGS_GCCISH})
+  endif ()
+
+  set (${COMPILER_SPECIFIC_FLAGS_VARIABLE} "${compiler_flags}" PARENT_SCOPE)
+endfunction ()
+
+function (source_file_add_compiler_flags_unchecked file)
+  set (flags ${ARGV})
+  list (REMOVE_AT flags 0)
+  get_source_file_property (sources ${file} SOURCES)
+
+  foreach (flag ${flags})
+    get_source_file_property (existing ${file} COMPILE_FLAGS)
+    if ("${existing}" STREQUAL "NOTFOUND")
+      set_source_files_properties (${file}
+        PROPERTIES COMPILE_FLAGS "${flag}")
+    else ()
+      set_source_files_properties (${file}
+        PROPERTIES COMPILE_FLAGS "${existing} ${flag}")
+    endif ()
+  endforeach (flag)
+endfunction ()
+
+function (source_file_add_compiler_flags file)
+  set (flags ${ARGV})
+  list (REMOVE_AT flags 0)
+  get_source_file_property (sources ${file} SOURCES)
+
+  foreach (flag ${flags})
+    if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
+      # Because https://gcc.gnu.org/wiki/FAQ#wnowarning
+      string (REGEX REPLACE "\\-Wno\\-(.+)" "-W\\1" flag_to_test "${flag}")
+    else ()
+      set (flag_to_test ${flag})
+    endif ()
+
+    if (file MATCHES "\\.c$")
+      string (REGEX REPLACE "[^a-zA-Z0-9]+" "_" test_name "CFLAG_${flag_to_test}")
+      CHECK_C_COMPILER_FLAG ("${ADD_COMPILER_FLAGS_PREPEND} ${flag_to_test}" ${test_name})
+    elseif (file MATCHES "\\.(cpp|cc|cxx)$")
+      string (REGEX REPLACE "[^a-zA-Z0-9]+" "_" test_name "CXXFLAG_${flag_to_test}")
+      CHECK_CXX_COMPILER_FLAG ("${ADD_COMPILER_FLAGS_PREPEND} ${flag_to_test}" ${test_name})
+    endif ()
+
+    if (${test_name})
+      source_file_add_compiler_flags_unchecked (${file} ${flag})
+    endif ()
+
+    unset (test_name)
+    unset (flag_to_test)
+  endforeach (flag)
+
+  unset (flags)
+endfunction ()
+
+function (target_add_compiler_flags target)
+  set (flags ${ARGV})
+  list (REMOVE_AT flags 0)
+  get_target_property (sources ${target} SOURCES)
+
+  foreach (source ${sources})
+    source_file_add_compiler_flags (${source} ${flags})
+  endforeach (source)
+
+  unset (flags)
+  unset (sources)
+endfunction (target_add_compiler_flags)
+
+# global_add_compiler_flags (flag1 [flag2 [flag3 ...]]):
+#
+# This just adds the requested compiler flags to
+# CMAKE_C/CXX_FLAGS variable if they work with the compiler.
+function (global_add_compiler_flags)
+  set (flags ${ARGV})
+
+  foreach (flag ${flags})
+    if ("GNU" STREQUAL "${CMAKE_C_COMPILER_ID}")
+      # Because https://gcc.gnu.org/wiki/FAQ#wnowarning
+      string (REGEX REPLACE "\\-Wno\\-(.+)" "-W\\1" flag_to_test "${flag}")
+    else ()
+      set (flag_to_test "${flag}")
+    endif ()
+
+    string (REGEX REPLACE "[^a-zA-Z0-9]+" "_" c_test_name "CFLAG_${flag_to_test}")
+    CHECK_C_COMPILER_FLAG ("${ADD_COMPILER_FLAGS_PREPEND} ${flag_to_test}" ${c_test_name})
+    if (${c_test_name})
+      set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+    endif ()
+    unset (c_test_name)
+
+    string (REGEX REPLACE "[^a-zA-Z0-9]+" "_" cxx_test_name "CFLAG_${flag_to_test}")
+    CHECK_CXX_COMPILER_FLAG ("${ADD_COMPILER_FLAGS_PREPEND} ${flag_to_test}" ${cxx_test_name})
+    if (${cxx_test_name})
+      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+    endif ()
+    unset (cxx_test_name)
+
+    unset (flag_to_test)
+  endforeach (flag)
+
+  unset (flags)
+
+  set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" PARENT_SCOPE)
+  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE)
+endfunction (global_add_compiler_flags)

data/ext/minimap2/lib/simde/test/cmake/ExtraWarningFlags.cmake

@@ -0,0 +1,68 @@
+# This is basically supposed to be the CMake equivalent of
+# https://git.gnome.org/browse/gnome-common/tree/macros2/gnome-compiler-flags.m4
+
+include (AddCompilerFlags)
+
+if (MSVC)
+  set (EXTRA_WARNING_FLAGS
+    /W4
+    /analyze)
+else ()
+  set (EXTRA_WARNING_FLAGS
+    -Wall
+    -Wcast-align
+    -Wclobbered
+    -Wempty-body
+    -Werror=format=2
+    -Werror=format-security
+    -Werror=implicit-function-declaration
+    -Werror=init-self
+    -Werror=missing-include-dirs
+    -Werror=missing-prototypes
+    -Werror=pointer-arith
+    -Wextra
+    -Wformat-nonliteral
+    -Wformat-security
+    -Wignored-qualifiers
+    -Winit-self
+    -Winvalid-pch
+    -Wlogical-op
+    -Wmissing-declarations
+    -Wmissing-format-attribute
+    -Wmissing-include-dirs
+    -Wmissing-noreturn
+    -Wmissing-parameter-type
+    -Wmissing-prototypes
+    -Wnested-externs
+    -Wno-missing-field-initializers
+    -Wno-strict-aliasing
+    -Wno-uninitialized
+    -Wno-unused-parameter
+    -Wold-style-definition
+    -Woverride-init
+    -Wpacked
+    -Wpointer-arith
+    -Wredundant-decls
+    -Wreturn-type
+    -Wshadow
+    -Wsign-compare
+    -Wstrict-prototypes
+    -Wswitch-enum
+    -Wsync-nand
+    -Wtype-limits
+    -Wundef
+    -Wuninitialized
+    -WUnsafe-loop-optimizations
+    -Wwrite-strings
+    -Wsuggest-attribute=format)
+endif ()
+
+mark_as_advanced (EXTRA_WARNING_FLAGS)
+
+function (target_add_extra_warning_flags target)
+  target_add_compiler_flags (${target} ${EXTRA_WARNING_FLAGS})
+endfunction (target_add_extra_warning_flags)
+
+function (source_file_add_extra_warning_flags file)
+  source_file_add_compiler_flags (${file} ${EXTRA_WARNING_FLAGS})
+endfunction (source_file_add_extra_warning_flags)

data/ext/minimap2/lib/simde/test/meson.build

@@ -0,0 +1,64 @@
+munit_deps = []
+munit_defs = []
+if cc.get_id() == 'pgi'
+  munit_deps += dependency('openmp')
+endif
+if cc.has_function('clock_gettime')
+  librt_dep = cc.find_library('rt', required: false)
+  if not librt_dep.found()
+    munit_defs += '-DPSNIP_CLOCK_NO_LIBRT'
+  endif
+  munit_deps += librt_dep
+endif
+munit = static_library('munit', 'munit/munit.c', dependencies: munit_deps)
+
+simde_c_defs = []
+simde_cxx_defs = []
+simde_c_args = []
+simde_cxx_args = []
+simde_deps = []
+
+c_openmp_simd = false
+cxx_openmp_simd = false
+foreach omp_arg : ['-fopenmp-simd', '-qopenmp-simd']
+  if (not c_openmp_simd) and cc.has_argument(omp_arg)
+    simde_c_args += omp_arg
+    simde_c_defs += '-DSIMDE_ENABLE_OPENMP'
+    c_openmp_simd = true
+  endif
+
+  if (not cxx_openmp_simd) and cxx.has_argument(omp_arg)
+    simde_cxx_args += omp_arg
+    simde_cxx_defs += '-DSIMDE_ENABLE_OPENMP'
+    cxx_openmp_simd = true
+  endif
+endforeach
+
+simde_native_c_flags = []
+# if cc.has_argument('-march=native+simd')
+#   simde_native_c_flags += '-march=native+simd'
+# elif cc.has_argument('-march=native')
+#   simde_native_c_flags += '-march=native'
+# endif
+
+simde_native_cxx_flags = []
+# if cxx.has_argument('-march=native+simd')
+#   simde_native_cxx_flags += '-march=native+simd'
+# elif cxx.has_argument('-march=native')
+#   simde_native_cxx_flags += '-march=native'
+# endif
+
+if not c_openmp_simd
+  simde_deps += dependency('openmp', required: false)
+endif
+
+simde_include_dir = include_directories('..')
+
+subdir('x86')
+subdir('arm')
+
+executable('run-tests', 'run-tests.c',
+           link_with: [munit, simde_tests_x86, simde_tests_arm],
+           dependencies: simde_deps,
+           c_args: simde_c_args + simde_c_defs + simde_native_c_flags,
+           cpp_args: simde_cxx_args + simde_cxx_defs + simde_native_cxx_flags)

data/ext/minimap2/lib/simde/test/munit/COPYING

@@ -0,0 +1,21 @@
+µnit Testing Framework
+Copyright (c) 2013-2016 Evan Nemerson <evan@nemerson.com>
+
+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.

data/ext/minimap2/lib/simde/test/munit/Makefile

@@ -0,0 +1,55 @@
+# Using µnit is very simple; just include the header and add the C
+# file to your sources.  That said, here is a simple Makefile to build
+# the example.
+
+CSTD:=99
+OPENMP:=n
+ASAN:=n
+UBSAN:=n
+EXTENSION:=
+TEST_ENV:=
+CFLAGS:=
+AGGRESSIVE_WARNINGS=n
+
+ifeq ($(CC),pgcc)
+        CFLAGS+=-c$(CSTD)
+else
+        CFLAGS+=-std=c$(CSTD)
+endif
+
+ifeq ($(OPENMP),y)
+        ifeq ($(CC),pgcc)
+                CFLAGS+=-mp
+        else
+                CFLAGS+=-fopenmp
+        endif
+endif
+
+ifneq ($(SANITIZER),)
+        CFLAGS+=-fsanitize=$(SANITIZER)
+endif
+
+ifneq ($(CC),pgcc)
+        ifeq ($(EXTRA_WARNINGS),y)
+                CFLAGS+=-Wall -Wextra -Werror
+        endif
+
+        ifeq ($(ASAN),y)
+                CFLAGS+=-fsanitize=address
+        endif
+
+        ifeq ($(UBSAN),y)
+                CFLAGS+=-fsanitize=undefined
+        endif
+endif
+
+example$(EXTENSION): munit.h munit.c example.c
+	$(CC) $(CFLAGS) -o $@ munit.c example.c
+
+test:
+	$(TEST_ENV) ./example$(EXTENSION)
+
+clean:
+	rm -f example$(EXTENSION)
+
+all: example$(EXTENSION)

data/ext/minimap2/lib/simde/test/munit/README.md

@@ -0,0 +1,54 @@
+# µnit
+
+µnit is a small but full-featured unit testing framework for C.  It has
+no dependencies (beyond libc), is permissively licensed (MIT), and is
+easy to include into any project.
+
+For more information, see
+[the µnit web site](https://nemequ.github.io/munit).
+
+[![Build status](https://travis-ci.org/nemequ/munit.svg?branch=master)](https://travis-ci.org/nemequ/munit)
+[![Windows build status](https://ci.appveyor.com/api/projects/status/db515g5ifcwjohq7/branch/master?svg=true)](https://ci.appveyor.com/project/quixdb/munit/branch/master)
+
+## Features
+
+Features µnit currently includes include:
+
+ * Handy assertion macros which make for nice error messages.
+ * Reproducible cross-platform random number generation, including
+   support for supplying a seed via CLI.
+ * Timing of both wall-clock and CPU time.
+ * Parameterized tests.
+ * Nested test suites.
+ * Flexible CLI.
+ * Forking
+   ([except on Windows](https://github.com/nemequ/munit/issues/2)).
+ * Hiding output of successful tests.
+
+Features µnit does not currently include, but some day may include
+(a.k.a., if you file a PR…), include:
+
+ * [TAP](http://testanything.org/) support; feel free to discuss in
+   [issue #1](https://github.com/nemequ/munit/issues/1)
+
+### Include into your project with meson
+
+In your `subprojects` folder put a `munit.wrap` file containing:
+
+```
+[wrap-git]
+directory=munit
+url=https://github.com/nemequ/munit/
+revision=head
+```
+
+Then you can use a subproject fallback when you include munit as a
+dependency to your project: `dependency('munit', fallback: ['munit', 'munit_dep'])`
+
+## Documentation
+
+See [the µnit web site](https://nemequ.github.io/munit).
+
+Additionally, there is a heavily-commented
+[example.c](https://github.com/nemequ/munit/blob/master/example.c) in
+the repository.