morphio 3.1.0__tar.gz → 3.2.0__tar.gz

MorphIO-3.2.0/.github/workflows/check-sdist.yml

@@ -0,0 +1,27 @@
+name: Check that `sdist` builds and installs
+on: [pull_request, push]
+
+jobs:
+  build_sdist:
+    name: Build sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'true'
+
+      - name: Set up Python 3.6
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.6
+
+      - name: Build a source tarball
+        run:
+          python setup.py sdist
+
+      - name: Test tarball
+        run: |
+          sudo apt install -y libhdf5-dev
+          pip install -r tests/requirement_tests.txt
+          pip install dist/*
+          pytest -s -v tests

{MorphIO-3.1.0 → MorphIO-3.2.0}/.github/workflows/clang_format_check.yaml

@@ -1,6 +1,5 @@
 name: clang-format-check
-on:
-    pull_request:
+on: [pull_request, push]
 
 jobs:
   build:

{MorphIO-3.1.0 → MorphIO-3.2.0}/.github/workflows/coverage_test.yaml

@@ -1,5 +1,6 @@
 name: coverage-test
 on: [pull_request, push]
+
 env:
   CC: gcc-9
   CXX: g++-9

{MorphIO-3.1.0 → MorphIO-3.2.0}/.github/workflows/docstring_check.yaml

@@ -1,6 +1,5 @@
 name: docstring-check
-on:
-    push:
+on: [pull_request, push]
 
 jobs:
   build:

{MorphIO-3.1.0 → MorphIO-3.2.0}/.github/workflows/publish-sdist-wheels.yml

@@ -47,7 +47,7 @@ jobs:
         env:
           CIBW_BEFORE_BUILD: |
             brew update
-            brew unlink gcc@8 gcc@9
+            brew --version
             brew install cmake
             brew install hdf5
         run: |

{MorphIO-3.1.0 → MorphIO-3.2.0}/.github/workflows/run-tests.yml

@@ -1,6 +1,5 @@
 name: Run tests
-on:
-    pull_request:
+on: [pull_request, push]
 
 jobs:
   build:
@@ -30,7 +29,7 @@ jobs:
         if: runner.os == 'macOS'
         run: |
             brew update
-            brew unlink gcc@8 gcc@9  # work around for https://github.com/actions/virtual-environments/issues/2391
+            brew --version
             brew install cmake || true  # macos image has cmake installed, but a new version may exist; ignore it if so
             brew install hdf5
 

{MorphIO-3.1.0 → MorphIO-3.2.0}/.gitmodules

@@ -4,9 +4,9 @@
 [submodule "3rdparty/pybind11"]
 	path = 3rdparty/pybind11
 	url = https://github.com/pybind/pybind11.git
-[submodule "3rdparty/lexertl"]
-	path = 3rdparty/lexertl
-	url = https://github.com/wizmer/lexertl.git
 [submodule "3rdparty/GSL_LITE"]
 	path = 3rdparty/GSL_LITE
 	url = https://github.com/martinmoene/gsl-lite.git
+[submodule "3rdparty/lexertl14"]
+	path = 3rdparty/lexertl14
+	url = https://github.com/BenHanson/lexertl14

{MorphIO-3.1.0 → MorphIO-3.2.0}/3rdparty/CMakeLists.txt

@@ -13,7 +13,7 @@ add_subdirectory(GSL_LITE)
 target_include_directories(gsl-lite SYSTEM INTERFACE)
 
 add_library(lexertl INTERFACE)
-target_include_directories(lexertl SYSTEM INTERFACE lexertl)
+target_include_directories(lexertl SYSTEM INTERFACE lexertl14/include)
 
 if(BUILD_BINDINGS)
   add_subdirectory(pybind11)

MorphIO-3.2.0/3rdparty/lexertl14/CMakeLists.txt

@@ -0,0 +1,50 @@
+#
+# Part of CMake configuration for lexertl library
+#
+# Copyright (c) 2013 Mateusz Loskot <mateusz@loskot.net>
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+cmake_minimum_required (VERSION 3.5)
+project(lexertl VERSION 0.1.0)
+
+# Define project
+add_library(lexertl INTERFACE)
+target_include_directories(lexertl INTERFACE 
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+	$<INSTALL_INTERFACE:include>
+)
+
+if (BUILD_EXAMPLES)
+	# Add the examples
+	add_subdirectory(examples)
+endif ()
+
+if (BUILD_TESTING)
+	enable_testing()
+	add_subdirectory(test)
+endif()
+
+# Generate install
+install(TARGETS lexertl EXPORT lexertlTargets
+	ARCHIVE DESTINATION lib
+	LIBRARY DESTINATION lib
+	RUNTIME DESTINATION bin
+	PUBLIC_HEADER DESTINATION include
+)
+install(DIRECTORY include/lexertl DESTINATION include)
+install(EXPORT lexertlTargets
+	FILE lexertlTargets.cmake
+	NAMESPACE lexertl::
+	DESTINATION lib/cmake/lexertl
+)
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file("lexertlConfigVersion.cmake"
+	VERSION ${lexertl_VERSION}
+	COMPATIBILITY SameMajorVersion
+)
+install(FILES "lexertlConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/lexertlConfigVersion.cmake"
+	DESTINATION lib/cmake/lexertl
+)
+

MorphIO-3.2.0/3rdparty/lexertl14/include/lexertl/char_traits.hpp

@@ -0,0 +1,45 @@
+// char_traits.hpp
+// Copyright (c) 2005-2020 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef LEXERTL_CHAR_TRAITS_HPP
+#define LEXERTL_CHAR_TRAITS_HPP
+
+#include <cstdint>
+
+namespace lexertl
+{
+    template<typename ch_type>
+    struct basic_char_traits
+    {
+        using char_type = ch_type;
+        using index_type = ch_type;
+
+        static index_type max_val()
+        {
+            const std::uint32_t max_ = 0x10ffff;
+
+            return sizeof(char_type) > 2 ?
+                max_ : (max_ & 0xffff);
+        }
+    };
+
+    template<>
+    struct basic_char_traits<char>
+    {
+        using char_type = char;
+        using index_type = unsigned char;
+
+        static index_type max_val()
+        {
+            // Prevent annoying warning (VC++)
+            index_type zero_ = 0;
+
+            return ~zero_;
+        }
+    };
+}
+
+#endif

MorphIO-3.2.0/3rdparty/lexertl14/include/lexertl/debug.hpp

@@ -0,0 +1,316 @@
+// debug.hpp
+// Copyright (c) 2005-2020 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef LEXERTL_DEBUG_HPP
+#define LEXERTL_DEBUG_HPP
+
+#include <map>
+#include <ostream>
+#include "rules.hpp"
+#include "sm_to_csm.hpp"
+#include "state_machine.hpp"
+#include "string_token.hpp"
+#include <vector>
+
+namespace lexertl
+{
+    template<typename sm, typename char_type, typename id_type = uint16_t,
+        bool is_dfa = true>
+        class basic_debug
+    {
+    public:
+        using char_state_machine =
+            basic_char_state_machine<char_type, id_type, is_dfa>;
+        using ostream = std::basic_ostream<char_type>;
+        using rules = basic_rules<char_type, char_type, id_type>;
+        using string = std::basic_string<char_type>;
+
+        static void dump(const sm& sm_, rules& rules_, ostream& stream_)
+        {
+            char_state_machine csm_;
+
+            sm_to_csm(sm_, csm_);
+            dump(csm_, rules_, stream_);
+        }
+
+        static void dump(const sm& sm_, ostream& stream_)
+        {
+            char_state_machine csm_;
+
+            sm_to_csm(sm_, csm_);
+            dump(csm_, stream_);
+        }
+
+        static void dump(const char_state_machine& csm_, rules& rules_,
+            ostream& stream_)
+        {
+            for (std::size_t dfa_ = 0, dfas_ = csm_.size();
+                dfa_ < dfas_; ++dfa_)
+            {
+                lexer_state(stream_);
+                stream_ << rules_.state(dfa_) << std::endl << std::endl;
+
+                dump_ex(csm_._sm_vector[dfa_], stream_);
+            }
+        }
+
+        static void dump(const char_state_machine& csm_, ostream& stream_)
+        {
+            for (std::size_t dfa_ = 0, dfas_ = csm_.size();
+                dfa_ < dfas_; ++dfa_)
+            {
+                lexer_state(stream_);
+                stream_ << dfa_ << std::endl << std::endl;
+
+                dump_ex(csm_._sm_vector[dfa_], stream_);
+            }
+        }
+
+    protected:
+        using dfa_state = typename char_state_machine::state;
+        using string_token = typename dfa_state::string_token;
+        using stringstream = std::basic_stringstream<char_type>;
+
+        static void dump_ex(const typename char_state_machine::dfa& dfa_,
+            ostream& stream_)
+        {
+            const std::size_t states_ = dfa_._states.size();
+            const id_type bol_index_ = dfa_._bol_index;
+
+            for (std::size_t i_ = 0; i_ < states_; ++i_)
+            {
+                const dfa_state& state_ = dfa_._states[i_];
+
+                state(stream_);
+                stream_ << i_ << std::endl;
+
+                if (state_._end_state)
+                {
+                    end_state(stream_);
+
+                    if (state_._push_pop_dfa ==
+                        dfa_state::push_pop_dfa::push_dfa)
+                    {
+                        push(stream_);
+                        stream_ << state_._push_dfa;
+                    }
+                    else if (state_._push_pop_dfa ==
+                        dfa_state::push_pop_dfa::pop_dfa)
+                    {
+                        pop(stream_);
+                    }
+
+                    id(stream_);
+                    stream_ << static_cast<std::size_t>(state_._id);
+                    user_id(stream_);
+                    stream_ << static_cast<std::size_t>(state_._user_id);
+                    dfa(stream_);
+                    stream_ << static_cast<std::size_t>(state_._next_dfa);
+                    stream_ << std::endl;
+                }
+
+                if (i_ == 0 && bol_index_ != char_state_machine::npos())
+                {
+                    bol(stream_);
+                    stream_ << static_cast<std::size_t>(bol_index_) <<
+                        std::endl;
+                }
+
+                if (state_._eol_index != char_state_machine::npos())
+                {
+                    eol(stream_);
+                    stream_ << static_cast<std::size_t>(state_._eol_index) <<
+                        std::endl;
+                }
+
+                for (const auto& tran_ : state_._transitions)
+                {
+                    string_token token_ = tran_.second;
+
+                    open_bracket(stream_);
+
+                    if (!tran_.second.any() && tran_.second.negatable())
+                    {
+                        token_.negate();
+                        negated(stream_);
+                    }
+
+                    string chars_;
+
+                    for (const auto& range_ : token_._ranges)
+                    {
+                        if (range_.first == '-' || range_.first == '^' ||
+                            range_.first == ']')
+                        {
+                            stream_ << '\\';
+                        }
+
+                        chars_ = string_token::escape_char
+                        (range_.first);
+
+                        if (range_.first != range_.second)
+                        {
+                            if (range_.first + 1 < range_.second)
+                            {
+                                chars_ += '-';
+                            }
+
+                            if (range_.second == '-' || range_.second == '^' ||
+                                range_.second == ']')
+                            {
+                                stream_ << '\\';
+                            }
+
+                            chars_ += string_token::escape_char(range_.second);
+                        }
+
+                        stream_ << chars_;
+                    }
+
+                    close_bracket(stream_);
+                    stream_ << static_cast<std::size_t>(tran_.first) <<
+                        std::endl;
+                }
+
+                stream_ << std::endl;
+            }
+        }
+
+        static void lexer_state(std::ostream& stream_)
+        {
+            stream_ << "Lexer state: ";
+        }
+
+        static void lexer_state(std::wostream& stream_)
+        {
+            stream_ << L"Lexer state: ";
+        }
+
+        static void state(std::ostream& stream_)
+        {
+            stream_ << "State: ";
+        }
+
+        static void state(std::wostream& stream_)
+        {
+            stream_ << L"State: ";
+        }
+
+        static void bol(std::ostream& stream_)
+        {
+            stream_ << "  BOL -> ";
+        }
+
+        static void bol(std::wostream& stream_)
+        {
+            stream_ << L"  BOL -> ";
+        }
+
+        static void eol(std::ostream& stream_)
+        {
+            stream_ << "  EOL -> ";
+        }
+
+        static void eol(std::wostream& stream_)
+        {
+            stream_ << L"  EOL -> ";
+        }
+
+        static void end_state(std::ostream& stream_)
+        {
+            stream_ << "  END STATE";
+        }
+
+        static void end_state(std::wostream& stream_)
+        {
+            stream_ << L"  END STATE";
+        }
+
+        static void id(std::ostream& stream_)
+        {
+            stream_ << ", Id = ";
+        }
+
+        static void id(std::wostream& stream_)
+        {
+            stream_ << L", Id = ";
+        }
+
+        static void push(std::ostream& stream_)
+        {
+            stream_ << ", PUSH ";
+        }
+
+        static void push(std::wostream& stream_)
+        {
+            stream_ << L", PUSH ";
+        }
+
+        static void pop(std::ostream& stream_)
+        {
+            stream_ << ", POP";
+        }
+
+        static void pop(std::wostream& stream_)
+        {
+            stream_ << L", POP";
+        }
+
+        static void user_id(std::ostream& stream_)
+        {
+            stream_ << ", User Id = ";
+        }
+
+        static void user_id(std::wostream& stream_)
+        {
+            stream_ << L", User Id = ";
+        }
+
+        static void open_bracket(std::ostream& stream_)
+        {
+            stream_ << "  [";
+        }
+
+        static void open_bracket(std::wostream& stream_)
+        {
+            stream_ << L"  [";
+        }
+
+        static void negated(std::ostream& stream_)
+        {
+            stream_ << "^";
+        }
+
+        static void negated(std::wostream& stream_)
+        {
+            stream_ << L"^";
+        }
+
+        static void close_bracket(std::ostream& stream_)
+        {
+            stream_ << "] -> ";
+        }
+
+        static void close_bracket(std::wostream& stream_)
+        {
+            stream_ << L"] -> ";
+        }
+
+        static void dfa(std::ostream& stream_)
+        {
+            stream_ << ", dfa = ";
+        }
+
+        static void dfa(std::wostream& stream_)
+        {
+            stream_ << L", dfa = ";
+        }
+    };
+
+    using debug = basic_debug<state_machine, char>;
+    using wdebug = basic_debug<wstate_machine, wchar_t>;
+}
+
+#endif